module ActiveRecord
class Base
def self.from_hash(hash)
h = hash.dup
h.each do |key,value|
h[key].map! { |e| reflect_on_association(key.to_sym ).klass.from_hash e } if value.is_a?(Array)
h[key] = reflect_on_association(key.to_sym).klass.from_hash(value) if value.is_a?(Hash)
end
new h
end

def from_json( json )
self.class.from_hash(ActiveSupport::JSON.safe_json_decode(json))
end

# The xml has a surrounding class tag (e.g. ship-to),
# but the hash has no counterpart (e.g. ’ship_to’ => {} )
def from_xml( xml )
from_hash begin
Hash.from_xml(xml)[to_s.demodulize.underscore]
rescue ; {} end
end
end # class Base
end # module ActiveRecord

module ActiveSupport
module JSON
def self.safe_json_decode(json)
return {} if !json
begin
decode(json)
rescue ; {} end
end
end
end

ESC [ … m

Thanks for your googling and your blog. I was having the same issues on opensuse 11.1.

http://rpg-314.blogspot.com/2009/10/getting-colors-i-git-output-on-opensuse.html

This post helped me fix it. Thanks a lot.

And now for some performance wars I changed the number of iterations from 50 to 1000 and ran it using ruby 1.8.6 (the one that comes with Leopard), ruby 1.9.1p0 (2009-01-30 revision 21907) and MacRuby 0.4:

ruby 1.8.6
real 0m54.405s
user 0m54.209s
sys 0m0.083s

ruby 1.9.1p0
real 0m10.758s
user 0m8.756s
sys 0m0.133s

MacRuby 0.4
real 1m7.342s
user 1m19.255s
sys 0m2.261s

def mandelbrot(a)
Array.new(50,a).inject(a) { |z,c| z*z+c }
end

which illustrates use of the inject function that doesn’t use a 50-element array of identical values, then I would consider your nit pick “appropriate”.

One nit pick though, it seems your usage of inject isn’t appropriate because you’re creating an array of size 50 just to iterate over something 50 times.

It might be more appropriate to do something like:

def mandelbrot(a)
  z = 0
  50.times { z = z * z + a }
  z
end

That way, if you want to do some large number of iterations, you don’t end up creating and destroying huge arrays. But I guess it’s just preference

1. Baseline:
Benchmark.measure { 100000.times {”hello world”}}.total
anywhere from .016 to .032
2. printf style
Benchmark.measure {100000.times {”%s” % ["hello world"] }}.total
consistent at 0.25
3. interpolation
Benchmark.measure {100000.times {”#{’hello world’}”}}.total
.031

So at this point the difference between #2 and #3 is 0.219, but if you take out the [] ie
#4 Benchmark.measure {100000.times {”%s” % “hello world”}}.total
the number is closer to 0.19 and the difference between #4 and #3 is 0.159

meaning that about 24% of the difference you were seeing was due to the []. (which doesn’t invalidate your observation at all, interpolation is still way faster than the printf style)

Thanks so much for this code. There is one modification that I had to do to make it work with my setup: I was trying to import from xml deep object associations exported with to_xml. For example, I could import something like:

…
…

apples
3

oranges
9

…

But, an order with many items would be exported as:

…
…

apples
3

oranges
9

…

Here’s the modifications that I had to do. Let me know if you spot any issues.

def self.from_hash( hash )
h = hash.dup
h.each do |key,value|

next if reflect_on_association(key.to_sym).nil?

if reflect_on_association(key.to_sym).macro == :has_many
h[key] = h[key][key.singularize].map! { |e|
reflect_on_association(key.to_sym).klass.from_hash e
}
else
h[key] = reflect_on_association(
key.to_sym ).klass.from_hash value
end
end

new h
end

Again, thanks for the code.

Tiberiu Motoc

Thanks for this Post!

I was experiencing this kind of trouble since I’ve started working on git!

Best Brazilian Regards!

http://tips.webdesign10.com/files/rename.pl.txt