simple-immutable 1.0.5 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 573eb118f7b46e8ecf7b89a0932cc1eba443a06d43572b2364c86a4d9ea1138d
-  data.tar.gz: 535879ee9c6697d0d106c809c56f92b84adb0e431bd5329acaf6fb33669cdb49
+  metadata.gz: 5816a5f9400fa98154de17883d4198c56e2355fcad70063c535ee2574d9cb47c
+  data.tar.gz: 975f96b46d5a8ff3d4f918e49b14554eb9146b6bc5c3485918cf471a9f78a6ff
 SHA512:
-  metadata.gz: '0475929a5809411bb352e8d1e7e87edbdf9301b6a6da44267a06993b60eed5939a46dacddf27d2eb5391e5bb707cba160bb9096116e4232bea584c7f2f373453'
-  data.tar.gz: b920bc63f731e455d53c4ff93fdcf8f9ca8dd6254505bd42340749bbdfda6b77a2bc61cd7a51aa351b2c0a8907064e17e954eb07cbecf65424946ac3f737249d
+  metadata.gz: 469829ef61658e63f55b4a6c3e776ab963253af632be7656c4c79ac1a6ecd28803b99fd8851565eac840751194bfb7a7b7a407045b5925927fd0bb035fc00ea3
+  data.tar.gz: 6e27e82d85e7069a38a70474d0f3fc7172efe0b9f18a94e3ae1f186e059abeeb72ae61f8e5be64f91f6c8830bb5058eb4e5992bba6379055e33c699018e4bb16

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.5
+1.1.1

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
@@ -32,41 +42,85 @@ 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)
+  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
 
+  # 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/simple-immutable.gemspec

@@ -21,5 +21,5 @@ Gem::Specification.new do |gem|
   # executables are used for development purposes only
   gem.executables   = []
 
-  gem.required_ruby_version = '~> 2.3'
+  gem.required_ruby_version = '>= 2.5'
 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.5
+  version: 1.1.1
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-23 00:00:00.000000000 Z
+date: 2022-07-24 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: {}
@@ -42,18 +44,19 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !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