simple-immutable 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d55dfd0cc8370b9bb68d8c1923770bc248d2eb4a2a71fe89717585366e17da78
-  data.tar.gz: 50baec5315bdd9a6b6b9cfa389fa8cda388047b38f517f6ca7571d5a96de8926
+  metadata.gz: 4ecf8356b446062c2cc5eb9237759cb91eb8a91cba3f311b527f2c73aa675bd7
+  data.tar.gz: 2f6c6952068ff100208296f0715d7f8b444b34deb673c285c3fe24d34be38bf8
 SHA512:
-  metadata.gz: 59c0ce8e1ae74f98e4c8b13cf6d1642182f83440a2eb111b1df853748adc4a21635900011da503f00d02990b2a5895a54fcde1fc66001b2679ed3169a719db47
-  data.tar.gz: beb2b47f7096c2e3bf98a1b7bbf4c4a50360a992a4ae96a213512ce31ff1e00cf7106351fedc118846d0f9463c5f82ed04d8bad85bc79200106d1d32ea92965f
+  metadata.gz: e71dff987fe8ee9853348389d6d1f262bda8355e88ef0dd8847585ce803adeae1de65c2153df6904bf4727fd32f4baddc3cef72bdd6e6b973126927938a07a9e
+  data.tar.gz: daf98517ec14374466755c6075a5ee2b009f63cb245f213b39d39c98915ff8597ba6a1ba7dfa961a1ada6785bde8720e907a19fa6dfda8b405ae7e7e893b8885

data/.rubocop.yml

@@ -30,3 +30,6 @@ Style/NumericPredicate:
 
 Metrics/MethodLength:
   Max: 20
+
+Lint/IneffectiveAccessModifier:
+  Enabled: false

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in {gemname}.gemspec
 gemspec
 
-gem "rubocop", "~> 0.87.1"
+gem "rubocop", "~> 1.20"

data/Makefile

@@ -1,9 +1,11 @@
-default: test
+default: test rubocop
 
-.PHONY: test
+.PHONY: test rubocop release
 
 test:
-	ruby test/immutable_test.rb
+	scripts/test
+
+rubocop:
 	bin/rubocop
 
 release:

data/README.md

@@ -17,11 +17,11 @@ Turns a nested data structure into a immutable ruby object implementing dot and
             name: "grandchildname"
           }
         },
-        "children": [
+        "children" => [
           "anna",
           "arthur",
           {
-            action: {
+            "action" => {
               keep_your_mouth_shut: true
             }
           }
@@ -36,3 +36,14 @@ Turns a nested data structure into a immutable ruby object implementing dot and
     imm.children.foo                            # NoMethodError (undefined method `foo' for #<Array:0x00007fb90f1be390>)
     imm.children.first.foo                      # NoMethodError (undefined method `foo' for "anna":String)
 
+If an attribute is not defined in the immutable (or in any sub-immutable) we raise a NameError
+
+    imm.unknown                                 # NameError (unknown immutable attribute 'unknown')
+
+One can check for an attribute by appending a "?". If the attribute is not defined this returns +nil+ instead of raising an error.
+
+    imm.a?                                      # 'a-value'
+    imm.unknown?                                # nil
+    imm.foo?.bar?                               # also nil
+
+When building an immutable one can provide a "fallback" hash in addition to the returned hash. If a key does not exist in the passed in data it will be fetched from the "fallback" data. This is rarely useful, but can provide effectove optimization in some cases.

data/VERSION

@@ -1 +1 @@
-1.0.3
+1.1.0

data/lib/simple/immutable.rb

@@ -6,14 +6,17 @@ class Simple::Immutable
 
   # turns an object, which can be a hash or array of hashes, arrays, and scalars
   # into an object which you can use to access with dot methods.
-  def self.create(object, max_depth = 8)
+  def self.create(object, max_depth: 8, null_record: nil, fallback: nil)
+    # Note that null_record is deprecated.
+    fallback ||= null_record
+
     case object
     when Array
       raise ArgumentError, "Object nested too deep (or inner loop?)" if max_depth < 0
 
-      object.map { |obj| create obj, max_depth - 1 }
+      object.map { |obj| create obj, fallback: fallback, max_depth: max_depth - 1 }
     when Hash
-      new(object)
+      new(object, fallback)
     else
       object
     end
@@ -22,7 +25,14 @@ class Simple::Immutable
   def self.raw_data(immutable)
     case immutable
     when SELF
-      immutable.instance_variable_get :@hsh
+      hsh = immutable.instance_variable_get :@hsh
+      fallback = immutable.instance_variable_get :@fallback
+
+      if fallback
+        fallback.merge(hsh)
+      else
+        hsh
+      end
     when Array
       immutable.map { |e| raw_data(e) }
     else
@@ -30,39 +40,88 @@ class Simple::Immutable
     end
   end
 
+  # adds to_json support.
+  def as_json(opts)
+    data = SELF.raw_data(self)
+    data.as_json(opts)
+  end
+
   private
 
-  def initialize(hsh)
+  def initialize(hsh, fallback = nil)
     @hsh = hsh
+    @fallback = fallback
   end
 
-  def method_missing(sym, *args, &block)
-    if args.empty? && !block
-      begin
-        value = @hsh.fetch(sym.to_sym) { @hsh.fetch(sym.to_s) }
-        return SELF.create(value)
-      rescue KeyError
-        # STDERR.puts "Missing attribute #{sym} for Immutable w/#{@hsh.inspect}"
-        nil
+  # rubycop:disable Lint/IneffectiveAccessModifier
+
+  # fetches key from a hsh, regardless of it being a Symbol or a String.
+  # Yields the block if the key cannot be found.
+  def self.fetch_symbol_or_string_from_hash(hsh, key, &block)
+    if hsh
+      hsh.fetch(key.to_sym) do
+        hsh.fetch(key.to_s, &block)
       end
+    else
+      yield
     end
+  end
 
-    super
+  def method_missing(sym, *args, &block)
+    raise ArgumentError, "Immutable: called attribute method with arguments" unless args.empty?
+    raise ArgumentError, "Immutable: called attribute method with arguments" if block
+
+    if sym.end_with?("?")
+      # If the symbol ends in "?" we do not raise a NameError, but instead
+      # returns nil if the attribute is not known.
+      sym = sym[0...-1]
+
+      # Note that sym is now a String. However, we are String/Symbol agnostic
+      # (in fetch_symbol_or_string_from_hash), so this is ok.
+      fetch_attribute!(sym, raise_when_missing: false)
+    else
+      fetch_attribute!(sym, raise_when_missing: true)
+    end
   end
 
   public
 
+  def fetch_attribute!(sym, raise_when_missing:)
+    value = SELF.fetch_symbol_or_string_from_hash(@hsh, sym) do
+      SELF.fetch_symbol_or_string_from_hash(@fallback, sym) do
+        raise NameError, "unknown immutable attribute '#{sym}'" if raise_when_missing
+
+        nil
+      end
+    end
+
+    SELF.create(value)
+  end
+
   def inspect
-    "<#{self.class.name}: #{@hsh.inspect}>"
+    if @fallback
+      "<#{self.class.name}: #{@hsh.inspect}, w/fallback: #{@fallback.inspect}>"
+    else
+      "<#{self.class.name}: #{@hsh.inspect}>"
+    end
   end
 
   def respond_to_missing?(method_name, include_private = false)
-    @hsh.key?(method_name.to_sym) ||
-      @hsh.key?(method_name.to_s) ||
-      super
+    return true if method_name.end_with?("?")
+
+    key = method_name.to_sym
+    return true if @hsh.key?(key)
+    return true if @fallback&.key?(key)
+
+    key = method_name.to_s
+    return true if @hsh.key?(key)
+    return true if @fallback&.key?(key)
+
+    super
   end
 
-  def respond_to?(sym)
+  # rubocop:disable Style/OptionalBooleanParameter
+  def respond_to?(sym, include_all = false)
     super || @hsh.key?(sym.to_s) || @hsh.key?(sym.to_sym)
   end
 

data/scripts/test

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+Dir.glob("test/**/*_test.rb").sort.each do |file|
+  load file
+end

data/test/immutable_test.rb

@@ -16,11 +16,11 @@ class Simple::Immutable::TestCase < Test::Unit::TestCase
           name: "grandchildname"
         }
       },
-      "children": [
+      "children" => [
         "anna",
         "arthur",
         {
-          action: {
+          "action" => {
             keep_your_mouth_shut: true
           }
         }
@@ -60,6 +60,22 @@ class Simple::Immutable::TestCase < Test::Unit::TestCase
     assert_equal true, immutable.children[2].action.keep_your_mouth_shut
   end
 
+  def test_child_access_w_question_mark
+    child = immutable.child?
+    assert_kind_of(Immutable, child)
+    assert_equal "childname", immutable.child.name?
+    assert_equal "grandchildname", immutable.child?.grandchild?.name?
+  end
+
+  def test_array_access_w_question_mark
+    assert_kind_of(Array, immutable.children?)
+    assert_equal 3, immutable.children?.length
+    assert_equal "anna", immutable.children?[0]
+
+    assert_kind_of(Immutable, immutable.children?[2])
+    assert_equal true, immutable.children[2].action?.keep_your_mouth_shut?
+  end
+
   def test_base_class
     assert_nothing_raised do
       immutable.object_id
@@ -67,28 +83,30 @@ class Simple::Immutable::TestCase < Test::Unit::TestCase
   end
 
   def test_missing_keys
-    assert_raise(NoMethodError) do
+    assert_raise(NameError) do
       immutable.foo
     end
   end
 
   def test_skip_when_args_or_block
-    # raise NoMethodError when called with arguments
-    assert_raise(NoMethodError) do
+    # raise ArgumentError when called with arguments
+    assert_raise(ArgumentError) do
       immutable.a(1, 2, 3)
     end
+    assert_raise(ArgumentError) do
+      immutable.a(one: 1)
+    end
 
-    # raise NoMethodError when called with a block argument
-    assert_raise(NoMethodError) do
+    # raise ArgumentError when called with a block argument
+    assert_raise(ArgumentError) do
       immutable.a { :dummy }
     end
   end
 
   def test_raw_data
-    immutable = Immutable.create(hsh)
     expected  = hsh
 
     assert_equal(expected, Immutable.raw_data(immutable))
-    assert_equal(expected[:children], Immutable.raw_data(immutable.children))
+    assert_equal(expected["children"], Immutable.raw_data(immutable.children))
   end
 end

data/test/immutable_w_fallback_test.rb

@@ -0,0 +1,63 @@
+# rubocop:disable Metrics/AbcSize
+
+require "test-unit"
+require_relative "../lib/simple-immutable"
+
+class Simple::Immutable::WithFallbackTestCase < Test::Unit::TestCase
+  Immutable = ::Simple::Immutable
+
+  def hsh
+    {
+      a: "a-value",
+      "b": "b-value",
+      "child": {
+        name: "childname",
+        grandchild: {
+          name: "grandchildname"
+        }
+      },
+      "children" => [
+        "anna",
+        "arthur",
+        {
+          "action" => {
+            keep_your_mouth_shut: true
+          }
+        }
+      ]
+    }
+  end
+
+  def fallback
+    {
+      foo: "foo-value",
+      "bar" => "bar-value"
+    }
+  end
+
+  def immutable
+    Immutable.create hsh, fallback: fallback
+  end
+
+  def test_hash_access
+    assert_equal "a-value", immutable.a
+    assert_equal "b-value", immutable.b
+  end
+
+  def test_fallback_access
+    assert_equal "foo-value", immutable.foo
+    assert_equal "bar-value", immutable.bar
+  end
+
+  def test_missing_keys
+    assert_raise(NameError) do
+      immutable.unknown
+    end
+  end
+
+  def test_raw_data
+    # raw data does contain fallback
+    expected = hsh.merge(fallback)
+    assert_equal(expected, Immutable.raw_data(immutable))
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-immutable
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-08 00:00:00.000000000 Z
+date: 2021-10-06 00:00:00.000000000 Z
 dependencies: []
 description: Immutable ruby objects implementing dot and [] accessors.
 email: eno@radiospiel.org
@@ -31,8 +31,10 @@ files:
 - lib/simple/immutable.rb
 - scripts/release
 - scripts/release.rb
+- scripts/test
 - simple-immutable.gemspec
 - test/immutable_test.rb
+- test/immutable_w_fallback_test.rb
 homepage: http://github.com/radiospiel/simple-immutable
 licenses: []
 metadata: {}
@@ -51,9 +53,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Immutable ruby objects
 test_files:
 - test/immutable_test.rb
+- test/immutable_w_fallback_test.rb