hashstruct 1.0.0

data/README.mdown

@@ -0,0 +1,69 @@
+HashStruct provides an object based on Hash, but acts like Struct (or OpenStruct), providing helpful
+accessors for each key from the get-go. It also magically parses string values when it can (eg, dates,
+URIs, numbers, and does so recursively.
+
+You can use HashStruct as a first-class object like this:
+
+    h = HashStruct.new
+    h.foo = 1
+    h.bar = 'zot'
+
+Or you can pass it a hash of existing values:
+
+    h = HashStruct.new(
+      :foo => 1,
+      :bar => 'z')
+
+Or simply an existing hash:
+
+    thing = { :foo => 1, :bar => 'z' }
+    h = HashStruct.new(thing)
+
+Or because it's a Hash underneath, you can use the '[]' construction method:
+
+    h = HashStruct[
+      [:foo, 1], [:bar, 'z']
+    ]
+
+Or a combination:
+
+    h = HashStruct.new(
+      :foo => 1,
+      :bar => 'z')
+    h.zot = :x
+
+HashStruct magically converts any values from strings (and sub-arrays/hashes) to native objects, when it can.  Like so:
+
+    h = HashStruct.new(
+      :an_int       => '1',                         # => 1
+      :a_float      => '1.5',                       # => 1.5
+      :a_url        => 'http://foo.com/bar',        # => #<URI::HTTP:0x000001009c6160 URL:http://foo.com/bar>
+      :a_date       => '2008-01-02',                # => #<DateTime: 2008-01-02T00:00:00+00:00 (4908935/2,0/1,2299161)>
+      :a_date_time  => '2011-06-17 09:36:49 -0700', # => #<DateTime: 2011-06-17T09:36:49-07:00 (212175088609/86400,-7/24,2299161)>
+      :a_bool_true  => 'true',                      # => true
+      :a_bool_false => 'false',                     # => false
+      :a_percentage => '50%',                       # => 0.5
+      :an_int_array => %w{1 2 3},                   # => [1, 2, 3]
+    )
+
+You can't turn off the magical conversion. (Secret: you could monkey-patch `#convert_value` to
+simply return the passed-in object.)
+
+You can also easily subclass HashStruct. You can add helper methods if needed, or accessor methods,
+which will be noticed and used by HashStruct. Note that any additional instance variables are not treated
+as part of the structure.
+
+  class Thing < HashStruct
+
+    attr_accessor :mul
+
+    def foo_mul
+      self.foo * @mul
+    end
+
+  end
+
+  t = Thing.new
+  t.foo = 2
+  t.mul = 2
+  t.foo_mul   # => 4

data/lib/hashstruct.rb

@@ -0,0 +1,89 @@
+require 'date'
+require 'uri'
+
+class HashStruct < Hash
+
+  VERSION = '1.0.0'
+
+  def initialize(args={})
+    super()
+    args.each { |key, value| self[key] = value }
+  end
+
+  def [](key)
+    key = key.to_sym
+    if methods.include?(key)
+      method(key).call
+    elsif has_key?(key)
+      fetch(key)
+    else
+      nil
+    end
+  end
+
+  def []=(key, value)
+    if methods.include?(:"#{key}=")
+      method(:"#{key}=").call(convert_object(value))
+    else
+      store(key.to_s.to_sym, convert_object(value))
+    end
+  end
+
+  def method_missing(method_id, *args)
+    method_name = method_id.to_s
+    if method_name =~ /=$/
+      raise ArgumentError, "wrong number of arguments for method #{method_name.inspect} (#{args.length} for 1)", caller(1) if args.length != 1
+      raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
+      self[method_name.chop.to_sym] = args.first
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 0)", caller(1) if args.length != 0
+      self[method_id]
+    end
+  end
+
+  def convert_object(obj)
+    case obj
+    when String
+      case obj
+      # URI
+      when %r{^(ftp|http|https|mailto):}
+        URI.parse(obj) rescue obj
+      # integer
+      when %r{^-?[1-9][\d,]*$}
+        obj.gsub(/,/, '').to_i
+      # hex integer
+      when %r{^0x[0-9a-f]+$}i
+        obj.hex
+      # float
+      when %r{^-?[\d,]+\.\d+$}
+        obj.gsub(/,/, '').to_f
+      # percent
+      when %r{^-?[\d,]+(\.\d+)?%$}
+        obj.to_f / 100
+      # date
+      when %r{^\d{4}-\d{2}-\d{2}},      # 2010-06-06
+           %r{^\d{1,2}/\d{1,2}/\d{4}},  # 06/06/2010
+           %r{^\d{4}/\d{1,2}/\d{1,2}},  # 2010/06/06
+           %r{^(Sun|Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s*\d*\s*\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\b}  # Sun, 06 Jun 2010 23:02:25 GMT
+        DateTime.parse(obj)
+      # boolean true
+      when 'true'
+        true
+      # boolean false
+      when 'false'
+        false
+      else
+        obj
+      end
+    when Array
+      obj.map { |o| convert_object(o) }
+    when Hash
+      HashStruct.new(obj)
+    when HashStruct
+      obj
+    else
+      obj
+    end
+  end
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: hashstruct
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- John Labovitz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-13 00:00:00.000000000 Z
+dependencies: []
+description: ! "\n    HashStruct provides an object based on Hash, but acts like Struct
+  (or OpenStruct), providing helpful\n    accessors for each key from the get-go.
+  It also magically parses string values when it can (eg, dates,\n    URIs, numbers,
+  and does so recursively.\n  "
+email: johnl@johnlabovitz.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hashstruct.rb
+- README.mdown
+homepage: http://github.com/jslabovitz/hashstruct
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Overly helpful magic hash structure.
+test_files: []