lab42_nhash 0.1.0.pre → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02be76a89cdf9ca8717dff56712bff2479224757
-  data.tar.gz: 419240c05de38a8552b5573ac2152b40714fd76c
+  metadata.gz: 083d1e07c143e83a9743bc203ab0386c0ca3d13d
+  data.tar.gz: 0c1017bc1a32a9ed99c26d2e83047e76b3a1dd11
 SHA512:
-  metadata.gz: b1937b9751c90dd02b23bd092c345d0b2f8844876c16476900487512b9603c5e121b7aed6113070487ac3b948e9cb29c7b8e8053f1f04b213689d5447984ea50
-  data.tar.gz: 188a2fba1f7034068c8d73b4e6847942b05c46bc2b1c56658631f149ffdb7ceef3c392f914cde35264ced0d78f1c5777abe87b39881a6f5718e82a44279df047
+  metadata.gz: 01108baa232347e7688bdc2c163f3e7c1e9870bd3156f5e8ead4497b594ba5803b1995c35d2e64847619c9a73578f5d6f414ca1ff478216cd85670077b6ae96c
+  data.tar.gz: acb2707844115bc986d0682a4aad72a181c8a2ffd001d0e84bf0797f9bbb6956c4def3bd8cd209b14c750adc616947f2deeb940f685beeaf66a2192f5a8f09af

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lab42_nhash (0.1.0.pre)
+    lab42_nhash (0.1.0)
       forwarder2 (~> 0.2)
       ruby_parser (~> 3.6)
 

data/demo/080-interpolation.md

@@ -29,9 +29,50 @@ However `get!/fetch!` are made from a completely different kind.
 
 ```ruby
     nh.get!(:sum).assert == '42'
-    nh.fetch!(:result).assert == 'the sum is 42'
+    nh.get!(:result).assert == 'the sum is 42'
 ```
 
+### Interpolation Context
 
+As could be seen in the example above, the context in which the `<% ... %>` body is evaluated is that
+of the `NHash` instance itself. However there is a possibility to provide any binding as a parameter
 
+```ruby
+    def get *args; 1 end
+    nh.push_binding binding
+    nh.get!(:sum).assert == '2'
+```
+
+Again this implements the _with_ pattern:
+
+```ruby
+    nh.pop_binding
+    nh.get!(:sum).assert == '42'
+    nh.with_binding binding do
+      get!(:sum).assert == '2'
+    end
+    nh.get!(:sum).assert == '42'
+```
+
+But an even more concise form is availaible, a single method called `get_with_binding` 
+
+```ruby
+    nh.get_with_binding(:sum, binding).assert = '2'
+    nh.get!(:sum).assert == '42'
+```
+
+### Block Form For Current Binding
+
+In order to replace the frequent use case:
+
+```ruby
+    nh.get_with_binding :sum, binding
+```
+
+with a more concise form a method acceting a block parameter, from which it can
+get the current binding can be used as follows:
+
+```ruby
+    nh.get_with_current{ :sum }.assert == '2'
+```
 

data/demo/090-compound-values.md

@@ -0,0 +1,50 @@
+
+# Lab42::NHash QED 
+
+## Compound Values
+
+All Scalar values will be left untouched, however, as shown earlier, subhashes are transformed into
+`NHash` instances and instances of `Enumerable` will get an `NHash::Enum` wrapper, that allows to
+maintain necessary context information.
+
+This demonstration will, well, demonstrate how that works and what we get from this additional layer
+of complexity:
+
+### A case of enumertion
+
+
+```ruby
+    nh = NHash.new(
+      a: 42,
+      entries: [
+        { value: '<%= get :a %>' },
+        '<%= get( :a ) * 2 %>',
+        21
+      ])
+      .with_indifferent_access
+
+```
+
+First thing to show is that indeed we get the `NHash::Enum` instance
+
+```ruby
+    entries = nh.get :entries
+    entries.assert.instance_of?( NHash::Enum )
+```
+
+And that we can use the result within the context of the original
+`NHash` instance, e.g. with indifferent access in our case:
+
+```ruby
+    entries[0].get('value').assert == '<%= get :a %>'
+```
+
+And that we can also use interpolation:
+
+```ruby
+ #   entries[0].get!(:value).assert == '42'
+```
+
+
+
+

data/demo/100-hierarchies.md

@@ -0,0 +1,128 @@
+
+# Lab42::NHash QED
+
+## Hierarchies
+
+Hierarchies are chains of `NHash` instances that are *looked_up* if a `get` fails.
+
+As each instance can have mant hierarchies they hierarchy lookup consists of a Depth First Tree Search.
+
+Here is an example:
+
+```ruby
+    root = NHash.new( a: 1 ).with_indifferent_access
+     one = NHash.new( b: 2 ).with_indifferent_access
+     two = NHash.new( b: :never_found )
+      .with_indifferent_access
+      .add_hierarchy( 'c' => 3 )
+    three = NHash.new( c: :never_found )
+
+    root.add_hierarchies one, two, three
+```
+
+This constructed a tree like the following (denoting `:never_found` with a `*`)
+
+
+```
+#                             +------+
+#                             | a: 1 |
+#                             +------+
+#                               /|\
+#                              / | \
+#              +--------------.  |  .--------------+
+#              |                 |                 |
+#         +---------+       +---------+       +---------+
+#         | b:  2   +       +   b: *  +       +   c: *  +
+#         +---------+       +---------+       +---------+
+#                                |
+#                                |
+#                           +---------+
+#                           +   c: 3  +
+#                           +---------+
+```
+
+Therefore the following assertions hold:
+
+```ruby
+    root.get( :a ).assert == 1
+    root.get( :b ).assert == 2
+    root.get( :c ).assert == 3
+    KeyError.assert.raised? do
+      root.get :d
+    end
+```
+
+
+### Hierarchies and Lookup Chains
+
+At first sight these might be easily confused with _Lookup Chains_. However the difference is easy to explain:
+
+While a _lookup_ (or a _fallback_ for that matter) *always* operates on the same NHash hierarchie, meaning
+that we will never find anything outside our underling hash, or that of our parent in case of intepolation,
+the hierarchies define a lookup chain at an outer level.
+
+They allow us to define different datasets to be searched for the same key combinations. And they operate only
+if a key combination was not found.
+
+The concept is very easy to understand when demonstrated on an example, so what are we waiting for?
+
+```ruby
+    nh1 = NHash.new(
+      en: { '1' => :one, '2' => :two },
+      fr: {  '2' => :deux })
+      .with_indifferent_access
+
+```
+
+Let us at first demonstrate the lookup chain for a reminder.
+
+```ruby
+    nh1.push_prefix_lookup :fr, :en
+    nh1.with_prefix :de do
+      nh1.get( '.1' ).assert == :one
+    end
+```
+
+And now we add another `NHash` instance as a hierarchy:
+
+```ruby
+    nh1.add_hierarchy NHash.new(
+      de: { '0' => :null },
+      fr: { '1' => :un })
+      .with_indifferent_access
+```
+
+First of all let us demonstrate that the lookup chain takes precedence over the hierarchy search
+
+```ruby
+    nh1.with_prefix :fr do
+      get( '.1' ).assert == :one
+    end
+```
+
+However, this does not hold if we do not use prefixes and the hierarchy lookup will kick in instead:
+
+```ruby
+    nh1.get( 'fr.1' ).assert == :un
+```
+
+
+The same holds if prefix lookup fails, as in these cases:
+
+```ruby
+   nh1.get( 'de.0' ).assert == :null
+
+```
+
+If, however a hiearchy is used for a lookup, it does not inherite the other lookup strategies
+from its root, e.g. affix chains or fallbacks.
+
+```ruby
+  KeyError.assert.raised? do
+     nh1.with_prefix :de do
+       get( '.0' ).assert == :null
+     end
+  end
+```
+
+### Interpolation Context

data/lib/lab42/nhash/class_methods.rb

@@ -0,0 +1,19 @@
+require_relative 'enum'
+module Lab42
+  class NHash
+    module ClassMethods
+
+      def from_value value, options={}
+        case value
+        when Hash
+          Lab42::NHash.new( value ).import_options options
+        when Enumerable
+          Lab42::NHash::Enum.new value, options
+        else
+          value
+        end
+      end
+    end # module ClassMethods
+    extend ClassMethods
+  end # class NHash
+end # module Lab42

data/lib/lab42/nhash/enum.rb

@@ -0,0 +1,37 @@
+require 'forwarder'
+
+module Lab42
+  class NHash
+    class Enum
+      extend Forwarder
+      forward :each, to: :@enum
+      forward :first, to_object: :self, as: :[], with: 0
+      forward :first!, to_object: :self, as: :fetch!, with: 0
+      forward :last, to_object: :self, as: :[], with: -1 
+      forward :last!, to_object: :self, as: :fetch!, with: -1 
+      
+      include Enumerable
+
+      attr_reader :parent
+
+      def [] idx
+        Lab42::NHash.from_value @enum[idx], @options
+      end
+
+      def fetch! idx
+        result = self[ idx ]
+        return result unless String === result
+
+        ERB.new( result ).result @parent.current_binding
+      end
+
+      private
+      def initialize enum, options
+        @enum    = enum
+        @parent  = options[:parent]
+        @options = options
+      end
+
+    end # class Enum
+  end # class NHash
+end # module Lab42

data/lib/lab42/nhash/hierarchies.rb

@@ -0,0 +1,30 @@
+module Lab42
+  class NHash
+    module Hierarchy
+      def add_hierarchy a_hierarchy={}
+        a_hierarchy = self.class.new a_hierarchy if Hash === a_hierarchy
+        raise ArgumentError, 'not an NHash instance' unless self.class === a_hierarchy
+        @hierarchies << a_hierarchy
+        self
+      end
+      def add_hierarchies *some_hierarchies
+        some_hierarchies.each do | a_hierarchy |
+          add_hierarchy a_hierarchy
+        end
+        self
+      end
+
+      def get_form_hierarchies keyexpr, keyexc
+        @hierarchies.each do | h |
+          begin
+            return h.get keyexpr
+          rescue KeyError
+          end
+        end
+        raise KeyError, keyexc
+      end
+    end # module Hierarchy
+
+    include Hierarchy
+  end # class NHash
+end # module Lab42

data/lib/lab42/nhash/interpolation.rb

@@ -5,14 +5,39 @@ module Lab42
     module Interpolation
       def get! *args, &blk
         result = get( *args, &blk )
-        return result unless String === result
         _expand_result result
       end
       alias_method :fetch!, :get!
 
+      def get_with_binding key, a_binding, *rst, &blk
+        with_binding a_binding do
+          get!( key, *rst, &blk )
+        end
+      end
+
+      def get_with_current &blk
+        with_binding blk.binding do
+          get! blk.()
+        end
+      end
+
+      def with_binding a_binding, &blk
+        push_binding a_binding
+        _invoke blk, self
+      ensure
+        pop_binding
+      end
+
+      def current_binding
+        @binding_stack.last || ( root? ? binding : parent.current_binding )
+      end
+
+      def root?
+        parent == self || parent.nil?
+      end
       private
-      def _expand_result result
-        ERB.new( result ).result( binding )
+      def _expand_result value
+        ERB.new( value ).result( current_binding )
       end
       
     end # module Interpolation

data/lib/lab42/nhash/version.rb

@@ -1,5 +1,5 @@
 module Lab42
   class NHash
-    VERSION = '0.1.0.pre'
+    VERSION = '0.1.0'
   end # class NHash
 end # module Lab42

data/lib/lab42/nhash.rb

@@ -1,38 +1,60 @@
+require 'forwarder'
+
+require_relative './nhash/class_methods'
+
 require_relative './nhash/exceptions'
 require_relative './nhash/invocation'
 require_relative './nhash/affixes'
 require_relative './nhash/fallbacks'
 require_relative './nhash/lookup_chains'
 require_relative './nhash/interpolation'
+require_relative './nhash/enum'
+require_relative './nhash/hierarchies'
 
 module Lab42
   class NHash
 
-    attr_reader :hashy
+    extend Forwarder
+    forward :pop_binding, to: :@binding_stack, as: :pop
+    forward :push_binding, to: :@binding_stack, as: :push
+
+    attr_reader :hashy, :parent
+
+    def export_options
+      { indifferent_access: @indifferent_access,
+        binding_stack: @binding_stack.dup,
+        parent: @parent
+      }
+    end
 
     def get keyexpr, *default, &defblock
       keys = keyexpr.to_s.split( '.' )
       keys = complete_keys keys.reject(&:empty?), use_prefix: keys.first.empty?, use_suffix: keyexpr[-1] == '.'
       found = @indifferent_access ? _get_indiff( keys ) : _get( keys )
-      case found
-      when Hash
-        self.class.new( found ).import_options export_options
-      else
-        found
-      end
+      self.class.from_value found, export_options
     rescue KeyError => k
-      return fallback keyexpr, k if default.empty? && defblock.nil?
+      return fallback_or_hierarchy keyexpr, k if default.empty? && defblock.nil?
       default.empty? ? defblock.(keyexpr) : default.first
     end
     alias_method :fetch, :get
 
+    def fallback_or_hierarchy keyexpr, keyexc
+      fallback keyexpr, keyexc
+    rescue KeyError => k
+      get_form_hierarchies keyexpr, k
+    end
+
     def import_options options
       @indifferent_access = options[:indifferent_access]
+      @binding_stack      = options[:binding_stack] || []
+      @parent             = options[:parent]
       self
     end
 
     def with_indifferent_access
-      self.class.new( @hashy ).import_options indifferent_access: true
+      self.class.new( @hashy ).tap do |rv|
+        rv.instance_variable_set :@indifferent_access, true
+      end
     end
 
     private
@@ -56,21 +78,24 @@ module Lab42
         partial_hash.fetch( key_element ){ partial_hash.fetch key_element.to_sym }
       end
     end
-    def export_options
-      { indifferent_access: @indifferent_access }
-    end
 
-    def initialize hashy
-      @hashy = hashy
+    def initialize hashy={}
+      @hashy  = hashy
       init_options
     end
 
     def init_options
+      @parent = self
+
       @indifferent_access       = false
       @suffix_stack             = []
       @prefix_stack             = []
+      @binding_stack            = []
+
       @fallbacks                = []
       @current_fallback_pointer = 0
+
+      @hierarchies              = []
     end
   end # class NHash
 end # module Lab42

data/spec/integration/hierarchie_and_lookup_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe NHash do
+  context 'Hierarchy and Lookup' do 
+
+    let :level2 do
+      described_class.new(
+        en: { '2' => :two },
+        fr: { '1' => :un, '3' => :trois })
+      .with_indifferent_access
+    end 
+
+    subject do
+      described_class.new(
+        en: { '1' => :one }
+      )
+      .with_indifferent_access
+    end
+
+    before do
+      subject.push_prefix_lookup :en
+      level2.push_prefix_lookup :fr, :en
+      subject.add_hierarchy level2
+    end
+
+    it 'finds with prefix lookup in the root' do
+      subject.with_prefix :fr do | s |
+        expect( s.get '.1' ).to eq :one
+      end
+    end
+    it 'finds in the hierarchy' do
+      expect( subject.get 'fr.3' ).to eq :trois
+    end
+    it 'finds it in the hierarchy if local lookup fails' do
+      subject.with_prefix :fr do | s |
+        expect( s.get '.3' ).to eq :trois
+      end
+      
+    end
+    it 'finds in the hierarchy with lookup' do
+      subject.with_prefix :fr do | s |
+        expect( s.get '.2' ).to eq :two
+      end
+    end
+
+  end # context 'Hierarchy and Lookup'
+end # describe NHash

data/spec/regression_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe NHash, :regression do 
+  subject do
+    NHash.new( 
+                 sum: '<%= get("a")+get("b") %>',
+                 a: 41,
+                 b: 1,
+                 result: 'the sum is <%= get! :sum %>'
+                )
+  .with_indifferent_access
+  end
+
+  it 'works (debugging)' do
+    expect( subject.fetch! :result ).to eq 'the sum is 42'
+  end
+
+end # describe NHash

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
-require_relative "../lib/lab42/nhash/auto_import"
+# require_relative "../lib/lab42/nhash/auto_import"
+require 'lab42/nhash/auto_import'
 
 PROJECT_ROOT = File.expand_path "../..", __FILE__
 Dir[File.join(PROJECT_ROOT,"spec/support/**/*.rb")].each {|f| require f}

data/spec/unit/compound/enum_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe NHash::Enum do
+  subject do
+    nh = NHash.new(
+      a: 42,
+      entries: [
+        { val: '<%= get :a %>' },
+        '<%= get(:a) * 2 %>',
+        21
+      ] )
+      .with_indifferent_access
+  end
+  let(:enum){ subject.get :entries }
+
+  it 'is returned for arrays' do
+    expect( subject.get :entries ).to be_instance_of described_class
+  end
+
+  context 'behaves like an array' do
+    it 'for #[]' do
+      expect( enum[2] ).to eq 21
+    end
+    it 'for #first' do
+      expect( enum.first.get :val ).to eq '<%= get :a %>'
+    end
+    it 'for #last' do
+      expect( enum.last ).to eq 21
+    end
+  end # context :behaves
+
+  context 'preservers the context' do
+    it 'evaluates with indifferent access' do
+      expect( enum.first.get('val') ).to eq '<%= get :a %>'
+    end
+
+    it 'interpolates in the context of the original object' do
+      expect( enum.first.get!('val') ).to eq '42'
+    end
+  end # context 'preservers the context'
+end

data/spec/unit/compound/nhash_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe NHash do 
+  context :compound do
+    subject do
+      NHash.new( 
+                a: 42,
+                b: { a: 41 })
+        .with_indifferent_access
+    end
+    it 'gets scalars' do
+      expect( subject.get :a ).to eq 42
+    end
+    it '... or not' do
+      expect( subject.get :b ).to be_instance_of described_class
+    end
+  end # context :compound
+end # describe NHash

data/spec/unit/hierarchies/base_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe NHash do 
+  context :hierarchies do 
+    subject do
+      described_class.new( a: 1 )
+        .with_indifferent_access
+        .add_hierarchy(
+          described_class.new( b: 2 )
+          .with_indifferent_access
+        )
+    end
+    it 'finds key in base instance' do
+      expect( subject.get :a ).to eq 1
+    end
+    it 'finds key in first hierarchy' do
+      expect( subject.get :b ).to eq 2
+    end
+    it 'still raises KeyError or returns default values if key is not in any hierarchy' do
+      expect( ->{
+        subject.get :c
+      } ).to raise_error KeyError
+      expect( subject.get :c, 42 ).to eq 42
+      expect( subject.get( :c ){ 42 } ).to eq 42
+    end
+
+    context 'implicit' do 
+      it 'convertion of hashes in add_hierarchy' do
+        n = NHash.new().add_hierarchy
+        expect( n.instance_variable_get( :@hierarchies ).first ).to be_instance_of described_class
+      end
+    end # context 'implicit creation'
+  end # context :hierarchies
+end # describe NHash

data/spec/unit/hierarchies/tree_form_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe NHash do 
+  describe :hierarchies do 
+    context 'tree form' do 
+
+      let(:ints){
+        described_class.new( twelve: 'i12' )
+        .with_indifferent_access
+      }
+
+      let(:odds){
+        described_class.new(
+          one: 'o1', three: 'o3')
+        .with_indifferent_access
+      }
+
+      let(:evens){
+        described_class.new( four: 'e4' )
+        .with_indifferent_access
+      }
+
+      let(:fizzes){
+        described_class.new( three: 'f3' )
+        .with_indifferent_access
+      }
+
+      before do
+        odds.add_hierarchy ints
+        fizzes.add_hierarchy evens
+        subject.add_hierarchies fizzes, odds
+      end
+
+      subject do
+        described_class
+          .new( zero: '0' )
+          .with_indifferent_access
+      end
+
+      context 'no impact at root level' do 
+        it 'for root' do
+          expect( subject.get(:zero) ).to eq '0'
+        end
+        it 'for hierarchies accessed as root' do
+          expect( odds.get :three ).to eq 'o3'
+        end
+      end # context 'no impact at root level'
+
+      context 'hierarchy chains' do 
+        it 'finds them at the next level' do
+          expect( subject.get( :one ) ).to eq( 'o1' )
+        end
+        it 'according to the the FIFO principle' do
+          expect( subject.get( :three ) ).to eq( 'f3' )
+        end
+        it 'or on later levels' do
+          expect( subject.get( :four ) ).to eq( 'e4' )
+          expect( subject.get( :twelve ) ).to eq( 'i12' )
+        end
+      end # context 'hierarchy chains'
+
+      context 'eventually we still might' do 
+        it 'convert to default values' do
+          expect( subject.get( :hundred, 100 ) ).to eq 100
+          expect( subject.get( :hundred ){ 100 } ).to eq 100
+        end
+        it 'or even raise a KeyError' do
+          expect( ->{ subject.get :hundred } ).to raise_error KeyError
+        end
+      end # context 'eventually we still might'
+    end # context 'tree form'
+  end # describe :hierarchies
+end # describe NHash

data/spec/unit/interpolation/binding_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe NHash do 
+
+  context :Interpolation do 
+    context :binding do 
+
+      # get for local binding
+      def get *args; 1 end
+
+      let(:b){
+        Class.new do
+          def get *args; 2 end
+          def b; binding end
+        end.new
+      }
+
+      subject do
+        NHash.new( 
+                  a: 1,
+                  b: 42,
+                  sum: %{<%= get(:a) + get(:b) %>} )
+        .with_indifferent_access
+      end
+
+      it "evaluates in the instance's binding" do
+        expect( subject.get! :sum ).to eq "43"
+      end
+
+      it 'can be evaluated in the current binding' do
+        subject.push_binding binding
+        expect( subject.get! :sum ).to eq '2'
+      end
+
+      it 'can be evaluated in any binding' do
+        subject.push_binding b.b
+        expect( subject.get! :sum ).to eq '4'
+      end
+
+      context :with_binding do 
+        it 'is temporary' do
+          outside = subject.get! :sum
+          inside  = subject.with_binding binding do
+            get! :sum
+          end
+          outside += subject.get! :sum
+
+          expect( outside + inside ).to eq '43432'
+        end
+      end # context :with_binding
+
+      context :get_with_binding do 
+        it 'is also temporary' do
+          outside = subject.get! :sum
+          inside  = subject.get_with_binding :sum, binding
+          outside += subject.get! :sum
+          expect( outside + inside ).to eq '43432'
+        end
+      end # context :get_with_binding
+
+      context :get_with_current do 
+        it 'evaluates with the current binding' do
+          expect( subject.get_with_current{ :sum } ).to eq '2'
+        end
+      end # context :get_with_current
+
+    end # context :binding
+  end # context :Interpolation
+
+end # describe NHash

data/spec/unit/interpolation/enum_binding_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe NHash do 
+  context :Interpolation do 
+    context :enum_binding do 
+      subject do
+        NHash.new(
+          a: 31,
+          entries:
+            [ 'a: <%= get(:a) %>',
+              { b: '<%= get(:a) + 11 %>' }])
+        .with_indifferent_access
+      end 
+      
+      it 'retains the binding from the parent in subhashes' do
+        expect( subject.get( :entries ).last!.get!(:b) ).to eq "42"
+        expect( subject.get( :entries ).fetch!(1).get!(:b) ).to eq "42"
+      end
+
+      it 'even in flat enum entries' do
+        expect( subject.get( :entries ).first! ).to eq 'a: 31'
+        expect( subject.get( :entries ).fetch!(0) ).to eq 'a: 31'
+      end
+    end # context :enum_binding
+  end # context :Interpolation
+end # describe NHash
+

data/spec/unit/parentship_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe NHash do 
+  context :parentship do
+    subject do
+      NHash.new(
+        a: 42,
+        b: { c: 43 },
+        d: [ 1, {e: 44} ]
+      )
+      .with_indifferent_access
+    end
+
+    it 'new instance is its own parent' do
+      expect( subject.parent ).to eq subject
+    end
+
+    it 'a subhashes parent is the whole nhash instance' do
+      expect( subject.get( :b ).parent ).to eq subject
+    end
+
+    it "an enum's parent too" do
+      expect( subject.get( :d ).parent ).to eq subject
+    end
+
+    it "and an enum's subhash also" do
+      expect( subject.get( :d )[1].parent ).to eq subject
+    end
+  end # context :parentship
+end # describe NHash

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_nhash
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre
+  version: 0.1.0
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-12 00:00:00.000000000 Z
+date: 2014-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: forwarder2
@@ -141,23 +141,37 @@ files:
 - demo/030-lookup-chains.md
 - demo/060-fallback.md
 - demo/080-interpolation.md
+- demo/090-compound-values.md
+- demo/100-hierarchies.md
 - demo/applique/require_ae.rb
 - demo/applique/require_nhash.rb
 - lab42_nhash.gemspec
 - lib/lab42/nhash.rb
 - lib/lab42/nhash/affixes.rb
 - lib/lab42/nhash/auto_import.rb
+- lib/lab42/nhash/class_methods.rb
+- lib/lab42/nhash/enum.rb
 - lib/lab42/nhash/exceptions.rb
 - lib/lab42/nhash/fallbacks.rb
+- lib/lab42/nhash/hierarchies.rb
 - lib/lab42/nhash/interpolation.rb
 - lib/lab42/nhash/invocation.rb
 - lib/lab42/nhash/lookup_chains.rb
 - lib/lab42/nhash/version.rb
+- spec/integration/hierarchie_and_lookup_spec.rb
+- spec/regression_spec.rb
 - spec/spec_helper.rb
 - spec/unit/afixes/affix_spec.rb
 - spec/unit/afixes/prefix_spec.rb
 - spec/unit/afixes/suffix_spec.rb
+- spec/unit/compound/enum_spec.rb
+- spec/unit/compound/nhash_spec.rb
 - spec/unit/fallback/fallback_spec.rb
+- spec/unit/hierarchies/base_spec.rb
+- spec/unit/hierarchies/tree_form_spec.rb
+- spec/unit/interpolation/binding_spec.rb
+- spec/unit/interpolation/enum_binding_spec.rb
+- spec/unit/parentship_spec.rb
 homepage: https://github.com/RobertDober/lab42_nested_hash
 licenses:
 - MIT
@@ -190,10 +204,21 @@ test_files:
 - demo/030-lookup-chains.md
 - demo/060-fallback.md
 - demo/080-interpolation.md
+- demo/090-compound-values.md
+- demo/100-hierarchies.md
 - demo/applique/require_ae.rb
 - demo/applique/require_nhash.rb
+- spec/integration/hierarchie_and_lookup_spec.rb
+- spec/regression_spec.rb
 - spec/spec_helper.rb
 - spec/unit/afixes/affix_spec.rb
 - spec/unit/afixes/prefix_spec.rb
 - spec/unit/afixes/suffix_spec.rb
+- spec/unit/compound/enum_spec.rb
+- spec/unit/compound/nhash_spec.rb
 - spec/unit/fallback/fallback_spec.rb
+- spec/unit/hierarchies/base_spec.rb
+- spec/unit/hierarchies/tree_form_spec.rb
+- spec/unit/interpolation/binding_spec.rb
+- spec/unit/interpolation/enum_binding_spec.rb
+- spec/unit/parentship_spec.rb