xkeys 0.0.1

data/lib/xkeys.rb

@@ -0,0 +1,137 @@
+# XKeys - Extended keys to facilitate fetching and storing in nested
+#	hash and array structures with Perl-ish auto-vivification.
+#
+# Synopsis:
+#  root = {}.extend XKeys::Hash
+#  root = [].extend XKeys::Auto
+#
+# Author:: Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
+# Copyright:: 2013 Brian Katzung and Kappa Computer Solutions, LLC
+# License:: MIT License
+
+module XKeys; end
+
+# Extended fetch and get ([])
+module XKeys::Get
+
+    # Perform an extended fetch using successive keys to traverse a tree
+    # of nested hashes and/or arrays.
+    #
+    #   xfetch([nil,] key1, ..., keyN [, :else => default_value])
+    #
+    #   An optional leading nil key is ignored (see []). If the specified
+    #   keys do not exist, the default value is returned (if provided) or
+    #   the standard exception (e.g. KeyError or IndexError) is raised.
+    def xfetch (*args)
+	if args[-1].is_a?(Hash) then options, last = args[-1], -2
+	else options, last = {}, -1
+	end
+	first = (args[0] == nil) ? 1 : 0
+	args[first..last].inject(self) do |node, key|
+	    begin node.fetch key
+	    rescue KeyError, IndexError
+		return options[:else] if options.has_key? :else
+		raise
+	    end
+	end
+    end
+
+    # Perform an extended get using successive keys to traverse a tree of
+    # nested hashes and/or arrays.
+    #
+    #   [key] returns the hash or array element (or range-based array slice)
+    #   as normal.
+    #
+    #   array[int1, int2] returns a length-based array slice as normal.
+    #   Prepend a nil key and/or append an option hash to force nested index
+    #   behavior for two integer array indexes: array[nil, index1, index2].
+    #
+    #   [[nil,] key1, ..., keyN[, option_hash]] traverses a tree of nested
+    #   hashes and/or arrays using xfetch. The optional leading nil key is
+    #   always ignored. In the absence of an option hash, the default is
+    #   :else => nil.
+    def [] (*args)
+	if args.count == 1 || (self.is_a?(Array) && args.count == 2 &&
+	  args[0].is_a?(Integer) && args[1].is_a?(Integer))
+	    # [key] or array[start, length]
+	    super *args
+	elsif args[-1].is_a?(Hash) then xfetch(*args)
+	else xfetch(*args, :else => nil)
+	end
+    end
+
+end
+
+# "Private" module for XKeys::Set_* common code
+module XKeys::Set_
+
+    # Common code for XKeys::Set_Hash and XKeys::Set_Auto
+    def _xset (*args)
+	if args.count == 2
+	    if self.is_a?(Array) && args[0] == nil
+		self << args[1]		# array[nil] = value
+	    else return false		# [key] = value ==> super *args
+	    end
+	else
+	    # root[key1, ..., keyN] = value
+	    (node, key) = args[1..-2].inject([self, args[0]]) do |node, key|
+		if yield key
+		    node[0][node[1]] ||= []
+		    [node[0][node[1]], key || node[0][node[1]].size]
+		else
+		    node[0][node[1]] ||= {}
+		    [node[0][node[1]], key]
+		end
+	    end
+	    if yield key then node[key || node.size] = args[-1]
+	    else node[key] = args[-1]
+	    end
+	end
+	true
+    end
+
+end
+
+# Extended set ([]=) with hash keys
+module XKeys::Set_Hash
+    include XKeys::Set_
+
+    # Auto-vivify nested hash trees using extended hash key/array index
+    # assignment syntax. Nil keys create nested arrays as needed. Other
+    # keys, including integer keys, create nested hashes as needed.
+    #
+    #   root[key1, ..., keyN] = value
+    def []= (*args)
+	super *args unless _xset(*args) { |key| key == nil }
+	args[-1]
+    end
+
+end
+
+# Extended set ([]=) with automatic selection of hash keys or array indexes
+module XKeys::Set_Auto
+    include XKeys::Set_
+
+    # Auto-vivify nested hash and/or array trees using extended hash
+    # key/array index assignment syntax. Nil keys and integer keys
+    # created nested arrays as needed. Other keys create nested hashes
+    # as needed.
+    #
+    #   root[key1, ..., keyN] = value
+    def []= (*args)
+	super *args unless
+	  _xset(*args) { |key| key == nil || key.is_a?(Integer) }
+	args[-1]
+    end
+
+end
+
+# Combined interfaces
+
+# XKeys::Hash combines XKeys::Get and XKeys::Set_Hash
+module XKeys::Hash; include XKeys::Get; include XKeys::Set_Hash; end
+
+# XKeys::Auto combines XKeys::Get and XKeys::Set_Auto
+module XKeys::Auto; include XKeys::Get; include XKeys::Set_Auto; end
+
+# END

data/test/01get.rb

@@ -0,0 +1,60 @@
+require 'minitest/autorun'
+require 'xkeys'
+
+class TestXK < MiniTest::Unit::TestCase
+
+    def test_hash_get
+	h = { :a => 'a', :b => { :c => 'bc' },
+	  :d => { :e => { :f => 'def' }}}.extend XKeys::Get
+
+	assert_respond_to(h, :xfetch)
+	assert_respond_to(h, :[])
+
+	assert_equal('a', h.xfetch(:a), 'h.xfetch :a')
+	assert_equal({ :c => 'bc' }, h.xfetch(:b), 'h.xfetch :b')
+	assert_equal('bc', h.xfetch(:b, :c), 'h.xfetch :b, :c')
+
+	assert_equal(false, h.xfetch(:b, :d, :else => false),
+	  'h.xfetch :b, :d, :else => false')
+	assert_raises(KeyError, 'h.xfetch :b, :d') { h.xfetch :b, :d }
+
+	assert_equal('a', h[:a], 'h[:a]')
+	assert_equal({ :c => 'bc' }, h[:b], 'h[:b]')
+	assert_equal('bc', h[:b, :c], 'h[:b, :c]')
+
+	assert_equal(false, h[:b, :d, :else=>false], 'h[:b, :d, :else=>false]')
+	assert_equal(nil, h[:b, :d], 'h[:b, :d]')
+	assert_raises(KeyError, 'h[:b, :d, {}]') { h[:b, :d, {}] }
+    end
+
+    def test_array_get
+	a = [ '0', [ '1.0' ], [ '2.0', [ '2.1.0', '2.1.1' ]]].extend XKeys::Get
+
+	assert_respond_to(a, :xfetch)
+	assert_respond_to(a, :[])
+
+	assert_equal('0', a.xfetch(0), 'a.xfetch 0')
+	assert_equal('1.0', a.xfetch(1, 0), 'a.xfetch 1, 0')
+	assert_equal('1.0', a.xfetch(nil, 1, 0), 'a.xfetch nil, 1, 0')
+	assert_equal('1.0', a.xfetch(1, 0, {}), 'a.xfetch 1, 0, {}')
+	assert_equal('2.1.1', a.xfetch(2, 1, 1), 'a.xfetch 2, 1, 1')
+
+	assert_equal(false, a.xfetch(1, 1, :else => false),
+	  'a.xfetch 1, 1, :else => false')
+	assert_raises(IndexError, 'a.xfetch 1, 1') { a.xfetch 1, 1 }
+
+	assert_equal('0', a[0], 'a[0]')
+	assert_equal([['1.0']], a[1, 1], 'a[1, 1]')
+	assert_equal('1.0', a[nil, 1, 0], 'a[nil, 1, 0]')
+	assert_equal('1.0', a[1, 0, {}], 'a[1, 0, {}]')
+	assert_equal('1.0', a[nil, 1, 0, {}], 'a[nil, 1, 0, {}]')
+	assert_equal('2.1.1', a[2, 1, 1], 'a[2, 1, 1]')
+
+	assert_equal(false, a[1, 1, :else=>false], 'a[1, 1, :else=>false]')
+	assert_equal(nil, a[nil, 1, 1], 'a[nil, 1, 1]')
+	assert_raises(IndexError, 'a[1, 1, {}]') { a[1, 1, {}] }
+    end
+
+end
+
+# END

data/test/02hash.rb

@@ -0,0 +1,38 @@
+require 'minitest/autorun'
+require 'xkeys'
+
+class TestXK < MiniTest::Unit::TestCase
+
+    def test_hash_set_hash
+	h = {}.extend XKeys::Set_Hash
+
+	assert_respond_to(h, :[]=)
+
+	h[:a] = 'a'
+	assert_equal({ :a => 'a' }, h, "h[:a] = 'a'")
+
+	h.clear; h[:a, :b] = 'ab'
+	assert_equal({ :a => { :b => 'ab' }}, h, "h[:a, :b] = 'ab'")
+
+	h.clear; h[1, 2] = '12'
+	assert_equal({ 1 => { 2 => '12' }}, h, "h[1, 2] = '12'")
+    end
+
+    def test_array_set_hash
+	a = [].extend XKeys::Set_Hash
+
+	assert_respond_to(a, :[]=)
+
+	a[0] = '0'
+	assert_equal(['0'], a, "a[0] = '0'")
+
+	a.clear; a[0, :a] = '0:a'
+	assert_equal([ { :a => '0:a' } ], a, "a[0, :a] = '0:a'")
+
+	a.clear; a[0, 1] = '01'
+	assert_equal([ { 1 => '01' } ], a, "a[0, 1] = '01'")
+    end
+
+end
+
+# END

data/test/03auto.rb

@@ -0,0 +1,38 @@
+require 'minitest/autorun'
+require 'xkeys'
+
+class TestXK < MiniTest::Unit::TestCase
+
+    def test_hash_set_auto
+	h = {}.extend XKeys::Set_Auto
+
+	assert_respond_to(h, :[]=)
+
+	h[:a] = 'a'
+	assert_equal({ :a => 'a' }, h, "h[:a] = 'a'")
+
+	h.clear; h[:a, :b] = 'ab'
+	assert_equal({ :a => { :b => 'ab' }}, h, "h[:a, :b] = 'ab'")
+
+	h.clear; h[1, 2] = '12'
+	assert_equal({ 1 => [ nil, nil, '12' ]}, h, "h[1, 2] = '12'")
+    end
+
+    def test_array_set_auto
+	a = [].extend XKeys::Set_Auto
+
+	assert_respond_to(a, :[]=)
+
+	a[0] = '0'
+	assert_equal(['0'], a, "a[0] = '0'")
+
+	a.clear; a[0, :a] = '0:a'
+	assert_equal([ { :a => '0:a' } ], a, "a[0, :a] = '0:a'")
+
+	a.clear; a[0, 1] = '01'
+	assert_equal([ [ nil, '01' ] ], a, "a[0, 1] = '01'")
+    end
+
+end
+
+# END

data/test/04mod_combos.rb

@@ -0,0 +1,20 @@
+require 'minitest/autorun'
+require 'xkeys'
+
+class TestXK < MiniTest::Unit::TestCase
+
+    def test_hash
+	a = [].extend XKeys::Hash
+	assert_kind_of(XKeys::Get, a, 'Hash => Get')
+	assert_kind_of(XKeys::Set_Hash, a, 'Hash => Set_Hash')
+    end
+
+    def test_auto
+	a = [].extend XKeys::Auto
+	assert_kind_of(XKeys::Get, a, 'Auto => Get')
+	assert_kind_of(XKeys::Set_Auto, a, 'Auto => Set_Auto')
+    end
+
+end
+
+# END

data/test/run_tests.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+export RUBYLIB=../lib
+
+# Run the specified tests (or all of them)
+for t in ${*:-[0-9]*.rb}
+do ruby $t
+done

data/xkeys.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name         = "xkeys"
+  s.version      = "0.0.1"
+  s.authors      = ["Brian Katzung"]
+  s.email        = ["briank@kappacs.com"]
+  s.homepage     = "http://rubygems.org/gems/xkeys"
+  s.summary      = "Extended keys to facilitate fetching and storing in nested hash and array structures with Perl-ish auto-vivification."
+  s.description  = "Extended keys to facilitate fetching and storing in nested hash and array structures with Perl-ish auto-vivification."
+  s.license      = "MIT"
+ 
+  s.files        = Dir.glob("lib/**/*") + %w{xkeys.gemspec}
+  s.test_files   = Dir.glob("test/**/*")
+  s.require_path = 'lib'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: xkeys
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brian Katzung
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-07-08 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Extended keys to facilitate fetching and storing in nested hash and array structures with Perl-ish auto-vivification.
+email: 
+- briank@kappacs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/xkeys.rb
+- xkeys.gemspec
+- test/03auto.rb
+- test/01get.rb
+- test/run_tests.sh
+- test/04mod_combos.rb
+- test/02hash.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/xkeys
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Extended keys to facilitate fetching and storing in nested hash and array structures with Perl-ish auto-vivification.
+test_files: 
+- test/03auto.rb
+- test/01get.rb
+- test/run_tests.sh
+- test/04mod_combos.rb
+- test/02hash.rb