simple-immutable 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b64e7bb0ef88ead17af2b5d1bca5ea4dc3a19c566a441ee8fe519afe7ac47c3
-  data.tar.gz: 4dedaf9317e816780dc86427b99a2b070a1ec46da22ca56446e8ceb120ba615a
+  metadata.gz: 4ecf8356b446062c2cc5eb9237759cb91eb8a91cba3f311b527f2c73aa675bd7
+  data.tar.gz: 2f6c6952068ff100208296f0715d7f8b444b34deb673c285c3fe24d34be38bf8
 SHA512:
-  metadata.gz: '0029d88bfa9788f39948eacc0707af394d2702b31800ec86ef83e76f9e1b4dbeb672ce619877a5f0e9f09da93b9b1edcdf3a0dc471c84b73fd1fd8415f168a6e'
-  data.tar.gz: abd71b228155f72f7953868cd445722c013b3ce9067d9ecc2075cd5c518a12905a0cd3ed768d7adec505291b53f6f383ce0fc6b63e2b1181ff0887f2fdf7c09c
+  metadata.gz: e71dff987fe8ee9853348389d6d1f262bda8355e88ef0dd8847585ce803adeae1de65c2153df6904bf4727fd32f4baddc3cef72bdd6e6b973126927938a07a9e
+  data.tar.gz: daf98517ec14374466755c6075a5ee2b009f63cb245f213b39d39c98915ff8597ba6a1ba7dfa961a1ada6785bde8720e907a19fa6dfda8b405ae7e7e893b8885

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,10 +1,11 @@
-default: test
+default: test rubocop
 
-.PHONY: test
+.PHONY: test rubocop release
 
 test:
-	ruby test/immutable_test.rb
-	ruby test/immutable_w_null_record_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.6
+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, null_record: nil)
+  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, null_record: null_record, max_depth: max_depth - 1 }
+      object.map { |obj| create obj, fallback: fallback, max_depth: max_depth - 1 }
     when Hash
-      new(object, null_record)
+      new(object, fallback)
     else
       object
     end
@@ -23,10 +26,10 @@ class Simple::Immutable
     case immutable
     when SELF
       hsh = immutable.instance_variable_get :@hsh
-      null_record = immutable.instance_variable_get :@null_record
+      fallback = immutable.instance_variable_get :@fallback
 
-      if null_record
-        null_record.merge(hsh)
+      if fallback
+        fallback.merge(hsh)
       else
         hsh
       end
@@ -39,14 +42,15 @@ class Simple::Immutable
 
   # adds to_json support.
   def as_json(opts)
-    @hsh.as_json(opts)
+    data = SELF.raw_data(self)
+    data.as_json(opts)
   end
 
   private
 
-  def initialize(hsh, null_record = nil)
+  def initialize(hsh, fallback = nil)
     @hsh = hsh
-    @null_record = null_record
+    @fallback = fallback
   end
 
   # rubycop:disable Lint/IneffectiveAccessModifier
@@ -64,32 +68,59 @@ class Simple::Immutable
   end
 
   def method_missing(sym, *args, &block)
-    if args.empty? && !block
-      value = SELF.fetch_symbol_or_string_from_hash(@hsh, sym) do
-        SELF.fetch_symbol_or_string_from_hash(@null_record, sym) do
-          # STDERR.puts "Missing attribute #{sym} for Immutable w/#{@hsh.inspect}"
-          super
-        end
-      end
+    raise ArgumentError, "Immutable: called attribute method with arguments" unless args.empty?
+    raise ArgumentError, "Immutable: called attribute method with arguments" if block
 
-      return SELF.create(value)
-    end
+    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]
 
-    super
+      # 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
 
+  # 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,19 +83,22 @@ 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
@@ -88,6 +107,6 @@ class Simple::Immutable::TestCase < Test::Unit::TestCase
     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_null_record_test.rb → immutable_w_fallback_test.rb}

@@ -3,7 +3,7 @@
 require "test-unit"
 require_relative "../lib/simple-immutable"
 
-class Simple::Immutable::WithNullRecordTestCase < Test::Unit::TestCase
+class Simple::Immutable::WithFallbackTestCase < Test::Unit::TestCase
   Immutable = ::Simple::Immutable
 
   def hsh
@@ -16,11 +16,11 @@ class Simple::Immutable::WithNullRecordTestCase < Test::Unit::TestCase
           name: "grandchildname"
         }
       },
-      "children": [
+      "children" => [
         "anna",
         "arthur",
         {
-          action: {
+          "action" => {
             keep_your_mouth_shut: true
           }
         }
@@ -28,7 +28,7 @@ class Simple::Immutable::WithNullRecordTestCase < Test::Unit::TestCase
     }
   end
 
-  def null_record
+  def fallback
     {
       foo: "foo-value",
       "bar" => "bar-value"
@@ -36,7 +36,7 @@ class Simple::Immutable::WithNullRecordTestCase < Test::Unit::TestCase
   end
 
   def immutable
-    Immutable.create hsh, null_record: null_record
+    Immutable.create hsh, fallback: fallback
   end
 
   def test_hash_access
@@ -44,20 +44,20 @@ class Simple::Immutable::WithNullRecordTestCase < Test::Unit::TestCase
     assert_equal "b-value", immutable.b
   end
 
-  def test_null_record_access
+  def test_fallback_access
     assert_equal "foo-value", immutable.foo
     assert_equal "bar-value", immutable.bar
   end
 
   def test_missing_keys
-    assert_raise(NoMethodError) do
+    assert_raise(NameError) do
       immutable.unknown
     end
   end
 
   def test_raw_data
-    # raw data does contain null_record
-    expected = hsh.merge(null_record)
+    # raw data does contain fallback
+    expected = hsh.merge(fallback)
     assert_equal(expected, Immutable.raw_data(immutable))
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: simple-immutable
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors:
 - radiospiel
 - mediapeers GmbH
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-13 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,13 +31,14 @@ files:
 - lib/simple/immutable.rb
 - scripts/release
 - scripts/release.rb
+- scripts/test
 - simple-immutable.gemspec
 - test/immutable_test.rb
-- test/immutable_w_null_record_test.rb
+- test/immutable_w_fallback_test.rb
 homepage: http://github.com/radiospiel/simple-immutable
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -53,9 +54,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.4
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Immutable ruby objects
 test_files:
 - test/immutable_test.rb
-- test/immutable_w_null_record_test.rb
+- test/immutable_w_fallback_test.rb