lab42_diggy_methods 0.1.0 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a830d7be026a2a9d2d71c16d0a1c0b515e2ddcbc43b6a9511dc1746cc5f1bd37
-  data.tar.gz: 51b16cbf743a665c67fd3a3e5856139bc2aea48e860daef4d41274efb66b4842
+  metadata.gz: d8cbaf0bd7f78a40b8b5a1583c0bf075877e7158c04c7f7295661e497cfbc42d
+  data.tar.gz: 425adc58abfa6e92a3d1e4a599db1b5f39df7da1aa4f40b025e25c71b48a86ad
 SHA512:
-  metadata.gz: 5cc260531aea413f7cbb7d80b87e8e6580a297852a9c8caf8bfc0b2195d9e9dabc826aa80d6367f8b70906427aa57de45ea1210994d791234c9d00188aa1ffac
-  data.tar.gz: 33fd3fec59836489cb4e66a9192055c30d37aa1bbfc264984409c844f409d2458e08be1325b81a3568b8f7ff015115ea58f9fd9a906b9d129806339deb395779
+  metadata.gz: 331c2a205746618e0e868b110da0128296ab63b5f8047a1935f0fee27cf22a0b25d8da7760324f8e350f984a8044378ff194f7853d7152a2c3b7d76c6f29da3b
+  data.tar.gz: 577292e722386233c97d435cf6bfbac4fbcb3111179facf7dda176c45638dae6d962d8141d1af9f8363b38e2d64c971a9f50a1e9fcf2d1b7ed5191eeabd544a1

data/README.md

@@ -48,9 +48,19 @@ Then we can access its fields as follows
   expect(diggy.b.d.e).to eq(3)
 ```
 
+And we can use a shortcut for `key.__data__` by using `key!`A
+```ruby
+    expect(diggy.b.d!).to eq(e: 3)
+```
+
+And that works for leave nodes too of course
+```ruby
+    expect(diggy.a!).to eq(1)
+```
+
 And in case of missing keys
 ```ruby
-    expect{ diggy.b.d.f }.to raise_error(KeyError, "key not found: :f")
+    expect{ diggy.b.d.f }.to raise_error(KeyError, "key not found: b.d.f")
 ```
 
 If we access unknown keys we get the usual `KeyError` error, however we must not pass, nonhashable data
@@ -60,6 +70,45 @@ But if we pass an array
     expect{ Diggy([:a]) }.to raise_error(ArgumentError)
 ```
 
+### Context: Using in ERB
+
+In order to take advantage of this syntax we want to pass the binding of a `Diggy` object to `ERB`
+
+Given an `ERB` template
+```ruby
+    require 'erb'
+    let(:template_text) { "<%= data.person.name %>" }
+```
+
+And a `Lab42::DiggyMethod` instance
+```ruby
+    let(:data) { Diggy(data: {person: {name: "YHS"}}) }
+```
+
+Then we can pass the binding to the template
+```ruby
+    expect(ERB.new(template_text).result(data.__binding__)).to eq("YHS")
+```
+
+### Context: Iteration
+
+If an element in a diggy object is an array we descend
+
+Given yet another diggy™
+```ruby
+    let(:diggy) { Diggy(a: [b: 1, c: 2]) }
+```
+
+Then we get an enumerator
+```ruby
+    expect(diggy.a).to be_an(Array)
+```
+
+And we can use it to iterate
+```ruby
+    expect(diggy.a.first.b).to eq(1)
+```
+
 # LICENSE
 
 Copyright 2022 Robert Dober robert.dober@gmail.com

data/lib/lab42/diggy_methods/version.rb

@@ -2,6 +2,7 @@
 
 module Lab42
   class DiggyMethods
-    VERSION = "0.1.0"
+    VERSION = "0.1.4"
   end
 end
+#  SPDX-License-Identifier: Apache-2.0

data/lib/lab42/diggy_methods.rb

@@ -3,15 +3,18 @@
 require_relative 'diggy_methods/kernel'
 module Lab42
   class DiggyMethods
-    attr_reader :data
+
+    # Expose for ERB
+    def __binding__; binding end
 
     # In case data has key :data (often the case)
     def __data__; @data end
 
     private
 
-    def initialize(a=nil, **data_)
+    def initialize(a=nil, __key_chain__: [], **data_)
       @data = _make_data_from_args(a, data_)
+      @keychain = __key_chain__
     end
 
     def _make_data_from_args(a, data_)
@@ -35,14 +38,35 @@ module Lab42
       raise ArgumentError, "positional argument must be a hash or respond to to_h if present"
     end
 
-    def method_missing(name)
-      found = data.fetch(name)
+    def method_missing(name, *)
+      if name.to_s.end_with?"!"
+        @data.fetch(name.to_s.sub(/!\z/, "").to_sym)
+      else
+        _method_missing_try_descend(name)
+      end
+    end
+
+    def _make_diggy_array(found)
+      found.map { self.class.new(_1) }
+    end
+
+    def _maybe_make_diggy(found)
       if found.respond_to?(:to_h)
-        self.class.new(**found)
+        self.class.new(**found, __key_chain__: @keychain)
       else
         found
       end
     end
+
+    def _method_missing_try_descend(name)
+      @keychain << name
+      found = @data.fetch(name) { raise KeyError, "key not found: #{@keychain.join(".")}" }
+      if Array === found
+        _make_diggy_array(found)
+      else
+        _maybe_make_diggy(found)
+      end
+    end
   end
 end
 #  SPDX-License-Identifier: Apache-2.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_diggy_methods
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Robert Dober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-31 00:00:00.000000000 Z
+date: 2022-02-02 00:00:00.000000000 Z
 dependencies: []
 description: |
   Create an instance of me with a Hash and access the (nested) values