doodle 0.2.2 → 0.2.3

data/lib/doodle/normalized_hash.rb

@@ -0,0 +1,356 @@
+# NormalizedHash - ensure hash keys and/or values are normalized to
+# particular type
+#
+# To use, derive a subclass from NormalizeKeyHash and provide you own
+# normalize_key(key) method
+#
+# See StringKeyHash and SymbolKeyHash for examples
+#
+# Sean O'Halpin, 2004..2009
+
+module ModNormalizedHash
+  module InstanceMethods
+    def initialize(arg = {}, &block)
+      if block_given?
+        original_block = block
+        # this is unfortunate
+        block = proc { |h, k|
+          #p [:block, h, k]
+          res = normalize_value(original_block[h, normalize_key(k)])
+          #p [:block_self, self, res]
+          each do |k, v|
+            #p [:init_block, k, v]
+            self[k] = normalize_value(v)
+          end
+          #p [:block_res, self, res]
+          res
+        }
+      end
+      if arg.is_a?(Hash)
+        super(&block)
+        update(arg)
+      else
+        super(arg, &block)
+      end
+    end
+
+    def default(k)
+      super(normalize_key(k))
+    end
+
+    def default=(value)
+      super(normalize_value(value))
+    end
+
+    def store(k,v)
+      super(normalize_key(k), normalize_value(v))
+    end
+
+    def fetch(k)
+      super(normalize_key(k))
+    end
+
+    # Note that invert returns a new +Hash+. This is by design. If you want the new hash to have the same properties as its source,
+    # use something like:
+    #
+    #   h = StringKeyHash.new(h.invert)
+    #
+    #     def invert
+    #       super
+    #     end
+
+    def delete(k)
+      super(normalize_key(k))
+    end
+
+    def [](k)
+      super(normalize_key(k))
+    end
+
+    def []=(k,v)
+      super(normalize_key(k), normalize_value(v))
+    end
+
+    def key?(k)
+      super(normalize_key(k))
+    end
+    alias :has_key? :key?
+    alias :member? :has_key?
+    alias :include? :has_key?
+
+    def has_value?(v)
+      super(normalize_value(v))
+    end
+    alias :value? :has_value?
+
+    def update(other, &block)
+      if block_given?
+        # {|key, oldval, newval| block}
+        super(other) { |key, oldval, newval|
+          normalize_value(block.call(key, oldval, newval))
+        }
+      else
+        other.each do |k,v|
+          store(k,v)
+        end
+      end
+    end
+    alias :merge! :update
+
+    def merge(other)
+      self.dup.update(other)
+    end
+
+    def values_at(*keys)
+      super(*keys.map{ |k| normalize_key(k)})
+    end
+    alias :indices :values_at # deprecated
+    alias :indexes :values_at # deprecated
+
+    def replace(other)
+      self.clear
+      update(other)
+    end
+
+    def index(value)
+      super(normalize_value(v))
+    end
+
+    # implemented in super
+    #   def clear
+    #     super
+    #   end
+
+    #   def default_proc
+    #     super
+    #   end
+
+    #   def delete_if(&block)
+    #     super
+    #   end
+
+    #   def each(&block)
+    #     super
+    #   end
+
+    #   def each_key(&block)
+    #     super
+    #   end
+
+    #   def each_pair(&block)
+    #     super
+    #   end
+
+    #   def each_value(&block)
+    #     super
+    #   end
+
+    #   def empty?
+    #     super
+    #   end
+
+    #   def invert
+    #     super
+    #   end
+
+    #   def keys
+    #     super
+    #   end
+
+    #   def length
+    #     super
+    #   end
+    #   alias :size :length
+
+    #   def rehash
+    #     super
+    #   end
+
+    #   def reject!(&block)
+    #     super
+    #   end
+
+    #   def shift
+    #     super
+    #   end
+
+    #   def to_hash
+    #     super
+    #   end
+
+    #   def values
+    #     super
+    #   end
+  end
+
+  module ClassMethods
+    def [](*args)
+      new(Hash[*args])
+    end
+  end
+
+  # in normal usage, these are the only methods you should need to override
+  module OverrideMethods
+    # override this method to normalize key, e.g. to normalize keys to
+    # strings:
+    #
+    #   def normalize_key(k)
+    #     k.to_s
+    #   end
+    def normalize_key(k)
+      k
+    end
+
+    # override this method to normalize value, e.g. to normalize
+    # values to strings:
+    #
+    #   def normalize_value(v)
+    #     v.to_s
+    #   end
+    def normalize_value(v)
+      v
+    end
+  end
+
+end
+
+# Note that some methods return a new +Hash+ not an object of your
+# subclass. This is by design (i.e. it's how ruby works). If you want
+# the new hash to have the same properties as its source, use
+# something like:
+#
+#   h = StringKeyHash.new(h.invert)
+#
+# The methods are:
+#
+#   invert => Hash
+#   select, reject => Hash in 1.9
+class NormalizedHash < Hash
+  include ModNormalizedHash::InstanceMethods
+  include ModNormalizedHash::OverrideMethods
+  extend ModNormalizedHash::ClassMethods
+end
+
+class SymbolKeyHash < NormalizedHash
+  def normalize_key(k)
+    k.to_s.to_sym
+  end
+end
+
+class StringKeyHash < NormalizedHash
+  def normalize_key(k)
+    #p [:normalizing, k]
+    k.to_s
+  end
+end
+
+class StringHash < StringKeyHash
+  def normalize_value(v)
+    v.to_s
+  end
+end
+
+module ModNormalizedHash
+  module ClassMethods
+    def MultiTypedHash(*klasses, &block)
+      typed_class = Class.new(NormalizedHash) do
+        # note: cannot take a block
+        if block_given?
+          define_method :normalize_value, &block
+        else
+          define_method :normalize_value do |v|
+            if !klasses.any?{ |klass| v.kind_of?(klass) }
+              raise TypeError, "#{self.class}: #{v.class}(#{v.inspect}) is not a kind of #{klasses.map{ |c| c.to_s }.join(', ')}", [caller[-1]]
+            end
+            v
+          end
+        end
+      end
+      typed_class
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'rubygems'
+  require 'assertion'
+  require 'date'
+
+  sh = StringKeyHash.new { |h,k| h[k] = 42 }
+  assert { sh[:a] == 42 }
+  assert { sh["a"] == 42 }
+  assert { sh.keys == ["a"] }
+
+  sh = StringKeyHash.new( { :a => 2 } )
+  assert { sh.keys == ["a"] }
+
+  yh = SymbolKeyHash.new { |h,k| h[k] = 42 }
+  assert { yh[:a] == 42 }
+  assert { yh["a"] == 42 }
+  assert { yh.keys == [:a] }
+
+  yh = SymbolKeyHash.new( { :a => 2 } )
+  assert { yh.keys == [:a] }
+
+  bh = StringKeyHash.new( { :a => 2 } ) { |h,k| h[k] = 42}
+  assert { bh[:b] == 42 }
+  assert { bh.keys.sort == ["a", "b"] }
+
+  sh = StringHash.new( { :a => 2 } ) { |h,k| h[k] = 42}
+  assert { sh[:b] == "42" }
+  assert { sh.keys.sort == ["a", "b"] }
+  assert { sh.values.sort == ["2", "42"] }
+
+  skh = SymbolKeyHash.new( { :a => 2 } ) { |h,k| h[k] = 42}
+  assert { skh.values == [2] }
+  skh['b'] = 42
+  assert { skh.key?(:a) && skh.key?(:b) }
+  #p skh.invert.keys
+  #p skh.invert
+  #p skh.invert.class
+  assert { skh.invert.keys == [2, 42] }
+  nskh = StringKeyHash.new(skh.invert)
+  #p nskh
+  assert { nskh.keys.sort == ["2", "42"] }
+  nsh = StringHash.new(skh.invert)
+  #p nsh
+  assert { nsh.keys.sort == ["2", "42"] }
+  assert { nsh.values.sort == ["a", "b"] }
+
+  StringIntegerHash = NormalizedHash::MultiTypedHash(String, Integer)
+
+  expect_ok { sih = StringIntegerHash[:a => 1, :b => "Hello"] }
+  expect_error(TypeError) { sih = StringIntegerHash[:a => 1, :b => Date.new] }
+
+  expect_ok {
+    sih = StringIntegerHash.new
+    sih[:a] = 1
+    sih[:b] = "hello"
+  }
+
+  expect_error(TypeError) {
+    sih = StringIntegerHash.new
+    sih[:c] = Date.new
+  }
+
+  ReverseStringHash = NormalizedHash::MultiTypedHash() do |v|
+    if v.kind_of?(String)
+      v.reverse
+    else
+      v
+    end
+  end
+
+  assert {
+    sih = ReverseStringHash[:a => 123, :b => "Hello"]
+    sih[:a] == 123 && sih[:b] == "Hello".reverse
+  }
+
+  assert {
+    sih = ReverseStringHash.new
+    sih[:a] = 123
+    sih[:b] = "Hello"
+    sih[:a] == 123 && sih[:b] == "Hello".reverse
+  }
+
+end

data/lib/doodle/ordered-hash.rb

@@ -0,0 +1,8 @@
+if RUBY_VERSION < '1.9.0'
+  require 'molic_orderedhash'  # TODO: replace this with own (required functions only) version
+else
+  # 1.9+ hashes are ordered by default
+  class Doodle
+    OrderedHash = ::Hash
+  end
+end

data/lib/doodle/singleton.rb

@@ -0,0 +1,23 @@
+class Doodle
+  # provides more direct access to the singleton class and a way to
+  # treat singletons, Modules and Classes equally in a meta context
+  module Singleton
+    # return the 'singleton class' of an object, optionally executing
+    # a block argument in the (module/class) context of that object
+    def singleton_class(&block)
+      sc = class << self; self; end
+      sc.module_eval(&block) if block_given?
+      sc
+    end
+    # evaluate in class context of self, whether Class, Module or singleton
+    def sc_eval(*args, &block)
+      if self.kind_of?(Module)
+        klass = self
+      else
+        klass = self.singleton_class
+      end
+      klass.module_eval(*args, &block)
+    end
+  end
+
+end

data/lib/doodle/smoke-and-mirrors.rb

@@ -0,0 +1,23 @@
+class Doodle
+
+  # what it says on the tin :) various hacks to hide @__doodle__ variable
+  module SmokeAndMirrors
+
+    # redefine instance_variables to ignore our private @__doodle__ variable
+    # (hack to fool yaml and anything else that queries instance_variables)
+    meth = Object.instance_method(:instance_variables)
+    define_method :instance_variables do
+      meth.bind(self).call.reject{ |x| x.to_s =~ /@__doodle__/}
+    end
+
+    # hide @__doodle__ from inspect
+    def inspect
+      super.gsub(/\s*@__doodle__=,/,'').gsub(/,?\s*@__doodle__=/,'')
+    end
+
+    # fix for pp
+    def pretty_print(q)
+      q.pp_object(self)
+    end
+  end
+end

data/lib/doodle/to_hash.rb

@@ -0,0 +1,17 @@
+require 'yaml'
+class Doodle
+  module ToHash
+    # create 'pure' hash of scalars only from attributes - hacky but works (kinda)
+    def to_hash
+      Doodle::Utils.symbolize_keys!(YAML::load(to_yaml.gsub(/!ruby\/object:.*$/, '')) || { }, true)
+      #begin
+      #  YAML::load(to_yaml.gsub(/!ruby\/object:.*$/, '')) || { }
+      #rescue Object => e
+      #  doodle.attributes.inject({}) {|hash, (name, attribute)| hash[name] = send(name); hash}
+      #end
+    end
+    def to_string_hash
+      Doodle::Utils.stringify_keys!(YAML::load(to_yaml.gsub(/!ruby\/object:.*$/, '')) || { }, true)
+    end
+  end
+end

data/lib/doodle/utils.rb

@@ -1,13 +1,175 @@
-# doodle/utils.rb
-# - not part of main lib but useful tidbits
-# Sean O'Halpin, 2008-04-17
-require 'pp'
-
-def try(&block)
-  begin
-    block.call
-  rescue Exception => e
-    e
+# Set of utility functions to avoid monkeypatching base classes
+class Doodle
+  # Set of utility functions to avoid monkeypatching base classes
+  module Utils
+    module ClassMethods
+
+      # unnest arrays by one level of nesting, e.g. [1, [[2], 3]] =>
+      # [1, [2], 3].
+      def flatten_first_level(enum)
+        enum.inject([]) {|arr, i|
+          if i.kind_of?(Array)
+            arr.push(*i)
+          else
+            arr.push(i)
+          end
+        }
+      end
+
+      # convert a CamelCasedWord to a snake_cased_word
+      # based on version in facets/string/case.rb, line 80
+      def snake_case(camel_cased_word)
+        # if all caps, just downcase it
+        if camel_cased_word =~ /^[A-Z]+$/
+          camel_cased_word.downcase
+        else
+          camel_cased_word.to_s.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+        end
+      end
+      alias :snakecase :snake_case
+
+      # resolve a constant of the form Some::Class::Or::Module -
+      # doesn't work with constants defined in anonymous
+      # classes/modules
+      def const_resolve(constant)
+        constant.to_s.split(/::/).reject{|x| x.empty?}.inject(Object) { |prev, this| prev.const_get(this) }
+      end
+
+      # deep copy of object (unlike shallow copy dup or clone)
+      def deep_copy(obj)
+        ::Marshal.load(::Marshal.dump(obj))
+      end
+
+      # normalize hash keys using method (e.g. +:to_sym+, +:to_s+)
+      #
+      # [+hash+] target hash to update
+      # [+recursive+] recurse into child hashes if +true+ (default is not to recurse)
+      # [+method+] method to apply to key (default is +:to_sym+)
+      def normalize_keys!(hash, recursive = false, method = :to_sym)
+        if hash.kind_of?(Hash)
+          hash.keys.each do |key|
+            normalized_key = key.respond_to?(method) ? key.send(method) : key
+            v = hash.delete(key)
+            if recursive
+              if v.kind_of?(Hash)
+                v = normalize_keys!(v, recursive, method)
+              elsif v.kind_of?(Array)
+                v = v.map{ |x| normalize_keys!(x, recursive, method) }
+              end
+            end
+            hash[normalized_key] = v
+          end
+        end
+        hash
+      end
+
+      # normalize hash keys using method (e.g. :to_sym, :to_s)
+      # - returns copy of hash
+      # - optionally recurse into child hashes
+      # see #normalize_keys! for details
+      def normalize_keys(hash, recursive = false, method = :to_sym)
+        if recursive
+          h = deep_copy(hash)
+        else
+          h = hash.dup
+        end
+        normalize_keys!(h, recursive, method)
+      end
+
+      # convert keys to symbols
+      # - updates target hash in place
+      # - optionally recurse into child hashes
+      def symbolize_keys!(hash, recursive = false)
+        normalize_keys!(hash, recursive, :to_sym)
+      end
+
+      # convert keys to symbols
+      # - returns copy of hash
+      # - optionally recurse into child hashes
+      def symbolize_keys(hash, recursive = false)
+        normalize_keys(hash, recursive, :to_sym)
+      end
+
+      # convert keys to strings
+      # - updates target hash in place
+      # - optionally recurse into child hashes
+      def stringify_keys!(hash, recursive = false)
+        normalize_keys!(hash, recursive, :to_s)
+      end
+
+      # convert keys to strings
+      # - returns copy of hash
+      # - optionally recurse into child hashes
+      def stringify_keys(hash, recursive = false)
+        normalize_keys(hash, recursive, :to_s)
+      end
+
+      # simple (!) pluralization - if you want fancier, override this method
+      def pluralize(string)
+        s = string.to_s
+        if s =~ /s$/
+          s + 'es'
+        else
+          s + 's'
+        end
+      end
+
+      # caller
+      def doodle_caller
+        if $DEBUG
+          caller
+        else
+          [caller[-1]]
+        end
+      end
+
+      # execute block - catch any exceptions and return as value
+      def try(&block)
+        begin
+          block.call
+        rescue Exception => e
+          e
+        end
+      end
+
+      # normalize a name to contain only those characters which are
+      # valid for a Ruby constant
+      def normalize_const(const)
+        const.to_s.gsub(/[^A-Za-z_0-9]/, '')
+      end
+
+      # lookup a constant along the module nesting path
+      def const_lookup(const, context = self)
+        #p [:const_lookup, const, context]
+        const = Utils.normalize_const(const)
+        result = nil
+        if !context.kind_of?(Module)
+          context = context.class
+        end
+        klasses = context.to_s.split(/::/)
+        #p klasses
+
+        path = []
+        0.upto(klasses.size - 1) do |i|
+          path << Doodle::Utils.const_resolve(klasses[0..i].join('::'))
+        end
+        path = (path.reverse + context.ancestors).flatten
+        #p [:const, context, path]
+        path.each do |ctx|
+          #p [:checking, ctx]
+          if ctx.const_defined?(const)
+            result = ctx.const_get(const)
+            break
+          end
+        end
+        if result.nil?
+          raise NameError, "Uninitialized constant #{const} in context #{context}"
+        else
+          result
+        end
+      end
+    end
+    extend ClassMethods
+    include ClassMethods
   end
 end
-