vex 0.2

data/lib/vex/base/hash/easy_access.rb

@@ -0,0 +1,141 @@
+#
+# - allows to use hash.xx.yy where you would have to use
+# hash["xx"][:yy] etc.
+#
+# - supports 
+#
+#   hash.xx?
+#
+# as a shortcut for hash.key?(:xx) || hash.key?("xx")
+#
+# - does not support assignment, though; i.e.
+#
+#   hash.yy = zz
+#
+# will raise a NoMethodError.
+#
+class Hash
+  module EasyAccess
+    def self.extended(host)
+      host.instance_variable_set "@easy_accessible", true
+    end
+
+    def method_missing(sym, *args, &block)
+      return super if block_given?
+      
+      if args.length == 0 && sym.to_s =~ /^(.*)\?$/
+        !! EasyAccess.check(self, $1)
+      elsif args.length == 0
+        EasyAccess.fetch(self, sym)
+      elsif args.length == 1 && sym.to_s =~ /^(.*)\=$/
+        v = args.first 
+        v = v.dup if v.is_a?(Hash)
+        EasyAccess.set(self, $1, v)
+      else
+        super
+      end
+    end
+
+    def respond_to?(sym)
+      key = case sym.to_s
+      when /^(.*)[=\?]$/
+        $1
+      else
+        sym.to_s
+      end
+
+      EasyAccess.check(self, key) || super
+    end
+
+    def self.check_key(hash, key)
+      key if hash.key?(key)
+    end
+
+    def self.check(hash, key)
+      check_key(hash, key.to_s) || check_key(hash, key.to_sym)
+    end
+    
+    def self.fetch(hash, key)
+      if !(k = check(hash, key))
+        raise NoMethodError, "undefined key `#{key}' for #{self.inspect}"
+      end
+      
+      easy_access hash.fetch(k)
+    end
+
+    def self.set(hash, key, value)
+      k = check(hash, key) || key
+      hash[k] = value
+    end
+    
+    def self.easy_access(obj)
+      obj.easy_access! if obj.is_a?(Hash)
+      obj
+    end
+  end
+
+  def easy_access
+    dup.easy_access!
+  end
+  
+  def easy_access!
+    # extend always returns self
+    extend(EasyAccess)
+  end
+  
+  def easy_accessible?
+    @easy_accessible
+  end
+end
+
+module Hash::EasyAccess::Etest
+  def test_easy_access_hashes
+    h = { :a => { "b" => "ccc" }}
+    h1 = h.easy_access!
+    assert h.easy_accessible?
+    assert h1.easy_accessible?
+    
+    assert_equal("ccc", h.a.b)
+    assert h1.object_id == h.object_id
+
+    assert h.a?
+    assert !h.b?
+    assert h.a.b?
+    assert !h.a.c?
+  end
+
+  def test_easy_access_hashes_2
+    h = { :a => { "b" => "ccc" }}
+    h1 = h.easy_access
+    assert !h.easy_accessible?
+    assert h1.easy_accessible?
+    
+    assert_equal("ccc", h1.a.b)
+    assert h1.object_id != h.object_id
+
+    assert h1.a?
+    assert !h1.b?
+    assert h1.a.b?
+    assert !h1.a.c?
+  end
+
+  def test_easy_access_assigns
+    h = { :a => { "b" => "ccc" }}
+    h.easy_access!
+    
+    h.a = 2
+    
+    assert_equal({ :a => 2}, h)
+    
+    h.b = 2
+    assert_equal({ :a => 2, "b" => 2}, h)
+
+    v = { :c => { :d => 2 } }
+    assert !v.easy_accessible?
+    
+    h.b = v
+    assert_equal(2, h.b.c.d)
+    assert !v.easy_accessible?
+    assert h.b.easy_accessible?
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/hash/ensure_keys.rb

@@ -0,0 +1,18 @@
+module Hash::EnsureKeys
+  def keys?(*keys)
+    (keys - self.keys()).empty?
+  end
+end
+
+class Hash
+  include EnsureKeys
+end
+
+module Hash::EnsureKeys::Etest
+  def test_ensure_keys
+    h = { :a => "a" }
+    assert_equal true, h.keys?(:a)
+    assert_equal true, h.keys?
+    assert_equal false, h.keys?(:a, :b)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/hash/extract.rb

@@ -0,0 +1,71 @@
+module Hash::Extract
+  def extract(*args)
+    extract_mapped(:[], *args)
+  end
+
+  # i.e. extract_and_delete
+  def extract!(*args)
+    extract_mapped(:delete, *args)
+  end
+
+  private
+
+  def extract_mapped(sym, *args)
+    translate = args.extract_options!
+
+    hash = args.inject({}) do |hash, k|
+      hash.update k => self.send(sym, k) if has_key?(k)
+      hash
+    end
+
+    translate.inject(hash) do |hash, (k, v)|
+      if has_key?(k)
+        value = self.send(sym, k) 
+        hash.update v => value unless v.nil?
+      end
+      hash
+    end
+  end
+end
+
+class Hash
+  include Extract
+end
+
+module Hash::Extract::Etest
+  def test_extract
+    h = { :a => "1", :b => "2" }
+    assert_equal(h.extract(:a, :c), {:a => "1"})
+  end
+
+  def orig
+    { 1 => 2, 3 => 4, 5 => 6}
+  end
+
+  def test_extract_w_delete!
+    h = orig
+    assert_equal ({1=>2}), h.extract!(1, 2, 3 => nil)
+    assert_equal ({5 => 6}), h
+  end
+
+  def test_extract!
+    h = orig
+    assert_equal ({1=>2, 3 => 4}), h.extract!(1, 2, 3)
+    assert_equal ({5 => 6}), h
+
+    h = orig
+    assert_equal ({1=>2, :a => 4}), h.extract!(1, 2, 3 => :a)
+    assert_equal ({5 => 6}), h
+  end
+
+  def test_extract2
+    assert_nothing_raised {  
+      h = orig.freeze
+      assert_equal ({1=>2, 3 => 4}), h.extract(1, 2, 3)
+      assert_equal orig, h
+
+      assert_equal ({1=>2, :a => 4}), h.extract(1, 2, 3 => :a)
+      assert_equal orig, h
+    }
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/hash/extras.rb

@@ -0,0 +1,62 @@
+module Hash::Extras
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+  
+  module ClassMethods
+    def create(keys, values)
+      self[*keys.zip(values).flatten]
+    end
+  end
+
+  # compare 
+  def hmap(&block)
+    self.inject({}) { |h, i|
+      h.update i[0] => yield(i[0], i[1])
+      h
+    }
+  end
+
+  def delete_all(*args)
+    args.inject([]) do |array, arg|
+      array << delete(arg)
+    end
+  end  
+
+  def select_entries(*args)
+    args.inject([]) do |array, arg|
+      array << self[arg]
+    end
+  end  
+end
+
+class Hash
+  include Extras
+end
+
+module Hash::Extras::Etest
+  def test_create
+    h = Hash.create([:a, :b], ["aa", "bb"])
+    
+    assert_equal({ :a => "aa", :b => "bb"}, h)
+  end
+  
+  def test_hmap
+    h = { 1 => "a", 2 => "b" }
+    assert_equal({ 1 => "a", 2 => "bb"}, h.hmap do |k,v| v * k end)
+  end
+  
+  def test_delete_all
+    h = { 1 => "a", 2 => "b" }
+    assert_equal([ "a", nil ], h.delete_all(1, 3))
+    assert_equal({ 2 => "b"}, h)
+  end
+  
+  def test_select
+    h = { 1 => "a", 2 => "b" }
+    h_orig = h.dup
+    
+    assert_equal([ "a", nil ], h.select_entries(1, 3))
+    assert_equal(h_orig, h)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/hash/inspect.rb

@@ -0,0 +1,17 @@
+
+class Hash
+  def inspect
+    "{" + to_a.sort_by do |k, v|
+      k.to_s
+    end.map do |k,v| 
+      "#{k.inspect} => #{v.inspect}" 
+    end.join(", ") + "}"
+  end
+end
+
+module Hash::Etest
+  def test_inspect
+    h = {"b" => 2, :a => 2}
+    assert_equal('{:a => 2, "b" => 2}', h.inspect)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/hash/simple_access_methods.rb

@@ -0,0 +1,74 @@
+class Hash
+  def with_simple_access
+    Deprecation.report "Hash#with_simple_access", "Hash#easy_access"
+    easy_access!
+  end
+end
+
+module Hash::SimpleAccessMethods; end
+
+module Hash::SimpleAccessMethods::Etest
+  def test_simple_access
+    h = { :a => "aa", :b => "bb", "c" => "cc" }
+    Deprecation.quiet do
+      h.with_simple_access
+    end
+    
+    assert_equal("aa", h.a)
+    assert_equal("bb", h.b)
+    assert_equal("cc", h.c)
+  end
+
+  def test_missing_methods
+    h = { :a => "aa", :b => "bb", "c" => "cc" }
+    Deprecation.quiet do
+      h.with_simple_access
+    end
+    assert_raise(NoMethodError) {  h.x }
+    assert_raise(NoMethodError) {  h.a(1) }
+  end
+
+  def test_assignments
+    h = { :a => "aa", :b => "bb", "c" => "cc" }
+    Deprecation.quiet do
+      h.with_simple_access
+    end
+    
+    h.a = 2
+    assert_equal(2, h.a)
+  end
+
+  def test_respond_to
+    h = { :a => "aa", :b => "bb", "c" => "cc" }
+    Deprecation.quiet do
+      h.with_simple_access
+    end
+
+    assert(h.respond_to?(:a))
+    assert(h.respond_to?(:b))
+    assert(h.respond_to?(:c))
+    assert(h.respond_to?(:"a="))
+
+    assert(h.respond_to?("a="))
+    assert(h.respond_to?("a"))
+
+    assert(h.respond_to?("c="))
+    assert(h.respond_to?("c"))
+
+    # inherited methods
+    assert(h.respond_to?("keys"))
+
+    # inherited methods
+    assert(!h.respond_to?("unknown_key"))
+    assert(!h.respond_to?("unknown_key="))
+  end
+
+  def test_simple_access_deep
+    h = { :a => { :b => "bb" } }
+    Deprecation.quiet do
+      h.with_simple_access
+    end
+
+    assert_equal("bb", h.a.b)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/invalid_argument/invalid_argument.rb

@@ -0,0 +1,97 @@
+def ArgumentError.message(default_text, *args)
+  msg = args.first.is_a?(String) ? args.shift : default_text
+
+  case args.length
+  when 0 then msg
+  when 1 then "#{msg}: #{args.first.inspect}"
+  else        "#{msg}: #{args.inspect}"
+  end
+end
+
+class InvalidArgument < ArgumentError
+  def initialize(*args)
+    super ArgumentError.message("Invalid argument", *args)
+  end
+end
+
+def invalid_argument!(*args)
+  raise InvalidArgument.new(*args)
+end
+
+class MissingOptions < ArgumentError
+  def initialize(*args)
+    super ArgumentError.message("Missing options", *args)
+  end
+end
+
+def missing_options!(*args)
+  raise MissingOptions.new(*args)
+end
+
+class MissingImplementation < ArgumentError
+  def initialize(*args)
+    super ArgumentError.message("Missing options", *args)
+  end
+end
+
+class Module
+  def not_implemented(*args)
+    class_eval args.map { |arg| "def #{arg}(*args); not_implemented!; end\n" }.join
+  end
+end
+
+class Object
+  def not_implemented!
+    raise MissingImplementation.new "#{self.class}##{caller_method_name}"
+  end
+
+  private
+  
+  def caller_method_name
+    parse_caller(caller(2).first).last || "unknown"
+  end
+
+  def parse_caller(at)
+    if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+      file = Regexp.last_match[1]
+      line = Regexp.last_match[2].to_i
+      method = Regexp.last_match[3]
+      [file, line, method]
+    end
+  end
+end
+
+module Module::Etest
+  class X
+    not_implemented :a, :b
+
+    def c(x)
+      invalid_argument! "This is strange" unless x == 0
+    end
+
+    def d(x)
+      missing_options! :a, :b unless x.keys?(:a, :b)
+    end
+  end
+  
+  def test_missing
+    assert_raise(MissingImplementation) { X.new.a }
+    assert_raise(MissingImplementation) { X.new.a 1, 2 }
+  end
+
+  def test_missing_options
+    assert_raises_kind_of(ArgumentError) {
+      X.new.d :a => "b", :c => "d"
+    }
+  end
+
+  def test_invalid_argument
+    assert_raises_kind_of(ArgumentError) { 
+      X.new.c 1
+    }
+    
+    assert_nothing_raised {  
+      X.new.c 0
+    }
+  end
+end if VEX_TEST == "base"