map 1.7.0 → 2.0.0

data/README

@@ -2,10 +2,10 @@ NAME
   map.rb
 
 SYNOPSIS
-  the ruby container you've always wanted: a string/symbol indifferent ordered
-  hash that works in all rubies
+  the awesome ruby container you've always wanted: a string/symbol indifferent
+  ordered hash that works in all rubies
 
-  maps are rad ordered hashes that are both ordered, string/symbol
+  maps are bitchin ordered hashes that are both ordered, string/symbol
   indifferent, and have all sorts of sweetness like recursive conversion, more
   robust implementation than HashWithIndifferentAccess, support for struct
   like (map.foo) access, and support for option/keyword access which avoids
@@ -93,8 +93,44 @@ DESCRIPTION
   options = Map.options(:read_only => true)
   read_only = options.getopt(:read_only, :default => false) #=> true
 
-# tons more goodness, see test/map_test.rb
+# maps support some really nice operators that hashes/orderedhashes do not
 #
+  m = Map.new
+  m.set(:h, :a, 0, 42)
+  m.has?(:h, :a)         #=> true
+  p m                    #=> {'h' => {'a' => [42]}} 
+  m.set(:h, :a, 1, 42.0)
+  p m                    #=> {'h' => {'a' => [42, 42.0]}} 
+
+  m.get(:h, :a, 1)       #=> 42.0
+  m.get(:x, :y, :z)      #=> nil
+  m[:x][:y][:z]          #=> raises exception!
+
+# they also support some different iteration styles
+#
+  m = Map.new
+
+  m.set(
+    [:a, :b, :c, 0] => 0,
+    [:a, :b, :c, 1] => 10,
+    [:a, :b, :c, 2] => 20,
+    [:a, :b, :c, 3] => 30
+  )
+
+  m.set(:x, :y, 42)
+  m.set(:x, :z, 42.0)
+
+  m.depth_first_each do |key, val|
+    p key => val
+  end
+
+  #=> [:a, :b, :c, 0] => 0
+  #=> [:a, :b, :c, 1] => 10
+  #=> [:a, :b, :c, 2] => 20
+  #=> [:a, :b, :c, 3] => 30
+  #=> [:x, :y] => 42
+  #=> [:x, :z] => 42.0
+
 
 USAGE
-  again, see test/map_test.rb
+  see lib/map.rb and test/map_test.rb

data/lib/map.rb

@@ -1,5 +1,5 @@
 class Map < Hash
-  Version = '1.7.0' unless defined?(Version)
+  Version = '2.0.0' unless defined?(Version)
   Load = Kernel.method(:load) unless defined?(Load)
 
   class << Map
@@ -51,6 +51,38 @@ class Map < Hash
       allocate.update(other.to_hash)
     end
 
+    def conversion_methods
+      @conversion_methods ||= (
+        map_like = ancestors.select{|ancestor| ancestor <= Map}
+        type_names = map_like.map do |ancestor|
+          name = ancestor.name.to_s.strip
+          next if name.empty?
+          name.downcase.gsub(/::/, '_')
+        end.compact
+        type_names.map{|type_name| "to_#{ type_name }"}
+      )
+    end
+
+    def add_conversion_method!(method)
+      method = method.to_s.strip
+      raise ArguementError if method.empty?
+      module_eval(<<-__, __FILE__, __LINE__)
+        unless public_method_defined?(#{ method.inspect })
+          def #{ method }
+            self
+          end
+        end
+        unless conversion_methods.include?(#{ method.inspect })
+          conversion_methods.unshift(#{ method.inspect })
+        end
+      __
+    end
+
+    def inherited(other)
+      other.module_eval(&Dynamic)
+      super
+    end
+
   # iterate over arguments in pairs smartly.
   #
     def each_pair(*args)
@@ -95,6 +127,13 @@ class Map < Hash
     alias_method '[]', 'new'
   end
 
+  Dynamic = lambda do
+    conversion_methods.reverse_each do |method|
+      add_conversion_method!(method)
+    end
+  end
+  module_eval(&Dynamic)
+
 
 # instance constructor 
 #
@@ -150,7 +189,10 @@ class Map < Hash
   end
 
   def convert_value(value)
-    return value.to_map if value.respond_to?(:to_map)
+    conversion_methods.each do |method|
+      return value.send(method) if value.respond_to?(method)
+    end
+
     case value
       when Hash
         klass.coerce(value)
@@ -392,10 +434,18 @@ class Map < Hash
     string = '{' + array.join(", ") + '}'
   end
 
-# converions
+# conversions
 #
-  def to_map
-    self
+  def conversion_methods
+    self.class.conversion_methods
+  end
+
+  conversion_methods.each do |method|
+    module_eval(<<-__, __FILE__, __LINE__)
+      def #{ method }
+        self
+      end
+    __
   end
 
   def to_hash
@@ -429,10 +479,20 @@ class Map < Hash
   end
   alias_method 'to_a', 'to_array'
 
+  def to_list
+    list = []
+    each_pair do |key, val|
+      list[key.to_i] = val if(key.is_a?(Numeric) or key.to_s =~ %r/^\d+$/)
+    end
+    list
+  end
+
   def to_s
     to_array.to_s
   end
 
+# oh rails - would that map.rb existed before all this non-sense...
+#
   def stringify_keys!; self end
   def stringify_keys; dup end
   def symbolize_keys!; self end
@@ -441,6 +501,156 @@ class Map < Hash
   def to_options; dup end
   def with_indifferent_access!; self end
   def with_indifferent_access; dup end
+
+# a sane method missing that only supports reading previously set values
+#
+  def method_missing(method, *args, &block)
+    method = method.to_s
+    case method
+      when /=$/
+        key = method.chomp('=')
+        value = args.shift
+        self[key] = value
+      else
+        key = method
+        super unless has_key?(key)
+        self[key]
+    end
+  end
+
+# support for compound key indexing and depth first iteration
+#
+  def get(*keys)
+    keys = keys.flatten
+    return self[keys.first] if keys.size <= 1
+    keys, key = keys[0..-2], keys[-1]
+    collection = self
+    keys.each do |k|
+      k = alphanumeric_key_for(k)
+      collection = collection[k]
+      return collection unless collection.respond_to?('[]')
+    end
+    collection[alphanumeric_key_for(key)]
+  end
+
+  def has?(*keys)
+    keys = keys.flatten
+    collection = self
+    return collection_has_key?(collection, keys.first) if keys.size <= 1
+    keys, key = keys[0..-2], keys[-1]
+    keys.each do |k|
+      k = alphanumeric_key_for(k)
+      collection = collection[k]
+      return collection unless collection.respond_to?('[]')
+    end
+    return false unless(collection.is_a?(Hash) or collection.is_a?(Array))
+    collection_has_key?(collection, alphanumeric_key_for(key))
+  end
+
+  def collection_has_key?(collection, key)
+    case collection
+      when Hash
+        collection.has_key?(key)
+      when Array
+        return false unless key
+        (0...collection.size).include?(Integer(key))
+    end
+  end
+
+  def set(*args)
+    if args.size == 1 and args.first.is_a?(Hash)
+      options = args.shift
+    else
+      options = {}
+      value = args.pop
+      keys = args
+      options[keys] = value
+    end
+
+    options.each do |keys, value|
+      keys = Array(keys).flatten
+
+      collection = self
+      if keys.size <= 1
+        collection[keys.first] = value
+        next
+      end
+
+      key = nil
+
+      keys.each_cons(2) do |a, b|
+        a, b = alphanumeric_key_for(a), alphanumeric_key_for(b)
+
+        case b
+          when Numeric
+            collection[a] ||= []
+            raise(IndexError, "(#{ collection.inspect })[#{ a.inspect }]=#{ value.inspect }") unless collection[a].is_a?(Array)
+
+          when String, Symbol
+            collection[a] ||= {}
+            raise(IndexError, "(#{ collection.inspect })[#{ a.inspect }]=#{ value.inspect }") unless collection[a].is_a?(Hash)
+        end
+        collection = collection[a]
+        key = b
+      end
+
+      collection[key] = value
+    end
+
+    return options.values
+  end
+
+  def Map.alphanumeric_key_for(key)
+    return key if Numeric===key
+    key.to_s =~ %r/^\d+$/ ? Integer(key) : key
+  end
+
+  def alphanumeric_key_for(key)
+    Map.alphanumeric_key_for(key)
+  end
+
+  def Map.depth_first_each(enumerable, path = [], accum = [], &block)
+    Map.pairs_for(enumerable) do |key, val|
+      path.push(key)
+      if((val.is_a?(Hash) or val.is_a?(Array)) and not val.empty?)
+        Map.depth_first_each(val, path, accum)
+      else
+        accum << [path.dup, val]
+      end
+      path.pop()
+    end
+    if block
+      accum.each{|keys, val| block.call(keys, val)}
+    else
+      [path, accum]
+    end
+  end
+
+  def Map.pairs_for(enumerable, *args, &block)
+    if block.nil?
+      pairs, block = [], lambda{|*pair| pairs.push(pair)}
+    else
+      pairs = false
+    end
+
+    result =
+      case enumerable
+        when Hash
+          enumerable.each_pair(*args, &block)
+        when Array
+          enumerable.each_with_index(*args) do |val, key|
+            block.call(key, val)
+          end
+        else
+          enumerable.each_pair(*args, &block)
+      end
+
+    pairs ? pairs : result
+  end
+
+  def depth_first_each(*args, &block)
+    Map.depth_first_each(enumerable=self, *args, &block)
+  end
 end
 
 module Kernel

data/test/map_test.rb

@@ -204,6 +204,32 @@ Testing Map do
     assert{ o.is_a?(d) }
   end
 
+  testing 'that subclassing creates custom conversion methods' do
+    c = Class.new(Map) do
+      def self.name()
+        :C
+      end
+    end
+    assert{ c.conversion_methods.map{|x| x.to_s} == %w( to_c to_map ) }
+    o = c.new
+    assert{ o.respond_to?(:to_map) }
+    assert{ o.respond_to?(:to_c) }
+
+    assert{ o.update(:a => {:b => :c}) }
+    assert{ o[:a].class == c }
+  end
+
+  testing 'that custom conversion methods can be added' do
+    c = Class.new(Map)
+    o = c.new
+    foobar = {:k => :v}
+    def foobar.to_foobar() self end
+    c.add_conversion_method!('to_foobar')
+    assert{ c.conversion_methods.map{|x| x.to_s} == %w( to_foobar to_map ) }
+    o[:foobar] = foobar
+    assert{ o[:foobar] == foobar }
+  end
+
   testing 'that map supports basic option parsing for methods' do
     %w( options_for options opts ).each do |method|
       args = [0,1, {:k => :v, :a => false}]
@@ -223,6 +249,58 @@ Testing Map do
     end
   end
 
+  testing 'that maps can be converted to lists with numeric indexes' do
+    m = Map[0, :a, 1, :b, 2, :c]
+    assert{ m.to_list == [:a, :b, :c] }
+  end
+
+  testing 'that method missing hacks allow setting values, but not getting them until they are set' do
+    m = Map.new
+    assert{ (m.key rescue $!).is_a?(Exception) }
+    assert{ m.key = :val }
+    assert{ m[:key] == :val }
+    assert{ m.key == :val }
+  end
+
+  testing 'that maps support compound key/val setting' do
+    m = Map.new
+    assert{ m.set(:a, :b, :c, 42) }
+    assert{ m[:a][:b][:c] == 42 }
+    assert{ m.get(:a, :b, :c) == 42 }
+    assert{ m.set([:x, :y, :z] => 42.0, [:A, 2] => 'forty-two') }
+    assert{ m[:A].is_a?(Array) }
+    assert{ m[:A].size == 3}
+    assert{ m[:A][2] == 'forty-two' }
+    assert{ m[:x][:y].is_a?(Hash) }
+    assert{ m[:x][:y][:z] == 42.0 }
+  end
+
+  testing 'that maps support depth_first_each' do
+    m = Map.new
+    prefix = %w[ a b c ]
+    keys = []
+    n = 0.42
+
+    10.times do |i|
+      key = prefix + [i]
+      val = n
+      keys.push(key)
+      assert{ m.set(key => val) }
+      n *= 10
+    end
+
+    assert{ m.get(:a).is_a?(Hash) }
+    assert{ m.get(:a, :b).is_a?(Hash) }
+    assert{ m.get(:a, :b, :c).is_a?(Array) }
+
+    n = 0.42
+    m.depth_first_each do |key, val|
+      assert{ key == keys.shift }
+      assert{ val == n }
+      n *= 10
+    end
+  end
+
 protected
   def new_int_map(n = 1024)
     map = assert{ Map.new }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: map
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 15
   prerelease: false
   segments: 
-  - 1
-  - 7
+  - 2
   - 0
-  version: 1.7.0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Ara T. Howard
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-23 00:00:00 -07:00
+date: 2010-12-24 00:00:00 -07:00
 default_executable: 
 dependencies: []