resource-struct 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3435cd92f2c4374cfd84a3411fd5a9d42fdd80f3e9ef1a13b847d302ba3fd313
-  data.tar.gz: 79ffe2f000b766de16130742bfd1a087222bf2d6c9ebf70dc9b328f2cdeb3394
+  metadata.gz: 1c1790e36a2600fddc519f1f9fdd47a2bdf9f07003f7205f0584be5455867446
+  data.tar.gz: f916a4b4a6bb2c27d727d9914732c5a33ce35617246814bfbe8e9743150c89c1
 SHA512:
-  metadata.gz: 6c74aece00d81f98c1cd6bc7b42cd4d6fdf43a60493cd247bc30f949e844cc048b28853c33f73acc18bc3a2fa6ad70bbe9438ec3a7ab56086cc5f73ca0db3de7
-  data.tar.gz: 413595f3fc61327671dc6c499477f7208bd8d6095e7b429e276c5b9082b4dc670bab7b40424f7ef4d4bb2a7cc8850e40809010258c007916cab0cb6141e6566b
+  metadata.gz: c2db5d94ea2c816e8bb7a2279709380e43f6a7f0a1f1e7ceb3c027e1f07d5b5ffc308014eeef7ef44bd815ca8f9d9a43c46540af890a60c8f515e2e477536841
+  data.tar.gz: eb0426c1c8667be29487125496681cba12c2b25fabc68475675500ea997aec898639cd826ce2370f888f9d0ffca9427ad6e348de3713eeb9d67bed3e1b350605

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.3.0] - 2022-01-04
+### Feature
+- Support for `as_json` and `to_json`
+- Support for `#[]=`, allowing modification on LooseStruct
+- Support for `JSON.parse(STR, object_class: ResourceStruct::FlexStruct)`
+- Refactor common code between LooseStruct and FirmStruct into `ResourceStruct::Extension::IndifferentLookup`
+- No longer support wrong arity for method based access patterns
+- Rename `LooseStruct` -> `FlexStruct`; `FirmStruct` -> `StrictStruct`
+
 ## [0.2.1] - 2022-01-01
 ### Fix
 - Correct handling of #== operator on Structs with hashes

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    resource-struct (0.2.1)
+    resource-struct (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -49,6 +49,7 @@ GEM
 PLATFORMS
   x86_64-darwin-18
   x86_64-darwin-19
+  x86_64-linux
 
 DEPENDENCIES
   rake (~> 13.0)

data/README.md

@@ -1,8 +1,17 @@
-# Resource::Struct
+# ResourceStruct
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/resource/struct`. To experiment with that code, run `bin/console` for an interactive prompt.
+![Continous Integration](https://github.com/AlexRiedler/resource-struct/actions/workflows/default.yml/badge.svg)
 
-TODO: Delete this and the text above, and describe your gem
+This is a gem for working with JSON resources from a network source with indifferent and method based access.
+
+Instead of overriding Hash implementation, this wraps a Hash with indifferent access (by symbol or string keys).
+This makes it fast at runtime, while still providing the necessary lookup method of choice.
+
+There are two types `ResouceStruct::StrictStruct` and `ResourceStruct::FlexStruct`.
+
+`ResourceStruct::StrictStruct` provides a way of wrapping a Hash such that accesses to invalid keys will raise an exception through the method lookup method; it also is immutable.
+
+`ResouceStruct::FlexStruct` provides a way of wrapping a Hash such that it returns nil instead of raising an exception when the key is not present in the hash.
 
 ## Installation
 
@@ -22,7 +31,37 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### StrictStruct
+
+```ruby
+struct = ResourceStruct::StrictStruct.new({ "foo" => 1, "bar" => [{ "baz" => 2 }, 3] })
+struct.foo? # => true
+struct.brr? # => false
+struct.foo # => 1
+struct.bar # => [StrictStruct<{ "baz" => 2 }>, 3]
+struct.brr # => NoMethodError
+struct[:foo] # => 1
+struct[:brr] # => nil
+struct[:bar, 0, :baz] # => 2
+struct[:bar, 0, :brr] # => nil
+```
+
+### FlexStruct
+
+```ruby
+struct = ResourceStruct::FlexStruct.new({ "foo" => 1, "bar" => [{ "baz" => 2 }, 3] })
+
+struct.foo? # => true
+struct.brr? # => false
+struct.foo # => 1
+struct.bar # => [FlexStruct<{ "baz" => 2 }>, 3]
+struct.brr # => nil
+struct[:foo] # => 1
+struct[:brr] # => nil
+struct[:bar, 0, :baz] # => 2
+struct[:bar, 0, :brr] # => nil
+```
+
 
 ## Development
 

data/lib/resource_struct/extensions/indifferent_lookup.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module ResourceStruct
+  module Extensions
+    #
+    # Common code between FirmStruct and LooseStruct
+    #
+    module IndifferentLookup
+      extend Forwardable
+
+      def_delegators :@hash, :to_h, :to_hash, :to_s, :as_json, :to_json
+
+      def initialize(hash = {})
+        @hash = hash || {}
+        @ro_struct = {}
+
+        raise ::ArgumentError, "first argument must be a Hash, found #{hash.class.name}" unless hash.is_a?(Hash)
+      end
+
+      def inspect
+        "#{self.class.name}<#{@hash.inspect}>"
+      end
+
+      def ==(other)
+        other.is_a?(Hash) && ___all_keys_equal(other) ||
+          (other.is_a?(LooseStruct) || other.is_a?(FirmStruct)) &&
+            ___all_keys_equal(other.instance_variable_get(:@hash))
+      end
+
+      def dig(key, *sub_keys)
+        ckey = ___convert_key(key)
+
+        result =
+          if @ro_struct.key?(ckey)
+            @ro_struct[ckey]
+          elsif key.is_a?(String)
+            @ro_struct[ckey] = ___convert_value(@hash[key] || @hash[key.to_sym])
+          else
+            @ro_struct[ckey] = ___convert_value(@hash[key] || @hash[ckey])
+          end
+
+        return result if sub_keys.empty?
+
+        return unless result
+
+        raise TypeError, "#{result.class.name} does not have #dig method" unless result.respond_to?(:dig)
+
+        result.dig(*sub_keys)
+      end
+      alias [] dig
+
+      private
+
+      def ___convert_value(value)
+        case value
+        when ::Array
+          value.map { |v| ___convert_value(v) }.freeze
+        when Hash
+          self.class.new(value)
+        else
+          value
+        end
+      end
+
+      def ___key?(key)
+        @hash.key?(key) || @hash.key?(___convert_key(key))
+      end
+
+      def ___convert_key(key)
+        key.is_a?(::Symbol) ? key.to_s : key
+      end
+
+      def ___all_keys_equal(other)
+        return false unless @hash.count == other.count
+
+        @hash.reduce(true) do |acc, (k, _)|
+          value = self[k]
+          if other.key?(k)
+            acc && value == other[k]
+          elsif k.is_a?(String)
+            ck = k.to_sym
+            acc && other.key?(ck) && value == other[ck]
+          else
+            ck = ___convert_key(k)
+            acc && other.key?(ck) && value == other[ck]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resource_struct/flex_struct.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ResourceStruct
+  #
+  # FlexStruct provides a struct by which accessing undefined fields returns nil
+  #
+  # struct = FlexStruct.new({ "foo" => 1, "bar" => [{ "baz" => 2 }, 3] })
+  #
+  # struct.foo? # => true
+  # struct.brr? # => false
+  # struct.foo # => 1
+  # struct.bar # => [FlexStruct<{ "baz" => 2 }>, 3]
+  # struct.brr # => nil
+  # struct[:foo] # => 1
+  # struct[:brr] # => nil
+  # struct[:bar, 0, :baz] # => 2
+  # struct[:bar, 0, :brr] # => nil
+  #
+  class FlexStruct
+    include ::ResourceStruct::Extensions::IndifferentLookup
+
+    def []=(key, value)
+      ckey = ___convert_key(key)
+      @ro_struct.delete(ckey)
+
+      value = value.instance_variable_get(:@hash) if value.is_a?(FlexStruct) || value.is_a?(StrictStruct)
+
+      if @hash.key?(key)
+        @hash[key] = value
+      elsif key.is_a?(String) || key.is_a?(Symbol) && @hash.key?(key.to_sym)
+        @hash[key.to_sym] = value
+      else
+        @hash[key] = value
+      end
+    end
+
+    def method_missing(name, *args)
+      args_length = args.length
+      return self[name] if ___key?(name) && args_length.zero?
+      return !!self[name[...-1]] if name.end_with?("?") && args_length.zero?
+      return self[name[...-1]] = args.first if name.end_with?("=") && args_length == 1
+
+      nil
+    end
+
+    def respond_to_missing?(_name, _include_private = false)
+      true
+    end
+  end
+  LooseStruct = FlexStruct
+end

data/lib/resource_struct/strict_struct.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ResourceStruct
+  #
+  # StrictStruct provides a struct by which accessing undefined fields raises a MethodMissing error.
+  # This protects against accessing fields that are not present in API Responses.
+  #
+  # If you need to check whether a field exists in an api response, you can via name? methods.
+  #
+  # struct = StrictStruct.new({ "foo" => 1, "bar" => [{ "baz" => 2 }, 3] })
+  #
+  # struct.foo? # => true
+  # struct.brr? # => false
+  # struct.foo # => 1
+  # struct.bar # => [StrictStruct<{ "baz" => 2 }>, 3]
+  # struct.brr # => NoMethodError
+  # struct[:foo] # => 1
+  # struct[:brr] # => nil
+  # struct[:bar, 0, :baz] # => 2
+  # struct[:bar, 0, :brr] # => nil
+  #
+  class StrictStruct
+    include ::ResourceStruct::Extensions::IndifferentLookup
+
+    def method_missing(name, *args, &blk)
+      args_length = args.length
+      return self[name] if ___key?(name) && args_length.zero?
+      return !!self[name[...-1]] if name.end_with?("?") && args_length.zero?
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      ___key?(name) || name.end_with?("?") || super
+    end
+  end
+  FirmStruct = StrictStruct
+end

data/lib/resource_struct/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ResourceStruct
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/resource_struct.rb

@@ -2,9 +2,16 @@
 
 require_relative "resource_struct/version"
 
+#
+# ResourceStruct
+#
+# includes the factory method ResourceStruct.new(hash, opts)
+# for building the various types of structs provided by the library.
+#
 module ResourceStruct
   class Error < StandardError; end
 end
 
-require_relative "resource_struct/firm_struct"
-require_relative "resource_struct/loose_struct"
+require_relative "resource_struct/extensions/indifferent_lookup"
+require_relative "resource_struct/strict_struct"
+require_relative "resource_struct/flex_struct"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resource-struct
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Alex Riedler
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-01 00:00:00.000000000 Z
+date: 2022-01-05 00:00:00.000000000 Z
 dependencies: []
 description: Openstruct like access without all the headaches of Hash method overrides
   etc...
@@ -30,8 +30,9 @@ files:
 - bin/setup
 - lib/resource-struct.rb
 - lib/resource_struct.rb
-- lib/resource_struct/firm_struct.rb
-- lib/resource_struct/loose_struct.rb
+- lib/resource_struct/extensions/indifferent_lookup.rb
+- lib/resource_struct/flex_struct.rb
+- lib/resource_struct/strict_struct.rb
 - lib/resource_struct/version.rb
 homepage: https://github.com/AlexRiedler/resource-struct
 licenses:

data/lib/resource_struct/firm_struct.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module ResourceStruct
-  #
-  # FirmStruct provides a struct by which accessing undefined fields raises a MethodMissing error.
-  # This protects against accessing fields that are not present in API Responses.
-  #
-  # If you need to check whether a field exists in an api response, you can via name? methods.
-  #
-  # struct = FirmStruct.new({ "foo" => 1, "bar" => [{ "baz" => 2 }, 3] })
-  #
-  # struct.foo? # => true
-  # struct.brr? # => false
-  # struct.foo # => 1
-  # struct.bar # => [FirmStruct<{ "baz" => 2 }>, 3]
-  # struct.brr # => NoMethodError
-  # struct[:foo] # => 1
-  # struct[:brr] # => nil
-  # struct[:bar, 0, :baz] # => 2
-  # struct[:bar, 0, :brr] # => nil
-  #
-  class FirmStruct
-    def initialize(hash)
-      raise ::ArgumentError, "first argument must be a Hash, found #{hash.class.name}" unless hash.is_a?(Hash)
-
-      @hash = hash
-      @ro_struct = {}
-    end
-
-    def method_missing(name, *args, &blk)
-      return self[name] if ___key?(name)
-      return !!self[name[...-1]] if name.end_with?("?")
-
-      super
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      ___key?(name) || name.end_with?("?") || super
-    end
-
-    def to_h
-      @hash.to_h
-    end
-
-    def to_hash
-      @hash.to_hash
-    end
-
-    def inspect
-      "#{self.class.name}<#{@hash.inspect}>"
-    end
-
-    def to_s
-      @hash.to_s
-    end
-
-    def ==(other)
-      other.is_a?(Hash) && ___all_keys_equal(other) ||
-        (other.is_a?(LooseStruct) || other.is_a?(FirmStruct)) && ___all_keys_equal(other.instance_variable_get(:@hash))
-    end
-
-    def dig(key, *sub_keys)
-      ckey = ___convert_key(key)
-
-      result =
-        if @ro_struct.key?(ckey)
-          @ro_struct[ckey]
-        elsif key.is_a?(String)
-          @ro_struct[ckey] = ___convert_value(@hash[key] || @hash[key.to_sym])
-        else
-          @ro_struct[ckey] = ___convert_value(@hash[key] || @hash[ckey])
-        end
-
-      return result if sub_keys.empty?
-
-      return unless result
-
-      raise TypeError, "#{result.class.name} does not have #dig method" unless result.respond_to?(:dig)
-
-      result.dig(*sub_keys)
-    end
-    alias [] dig
-
-    private
-
-    def ___convert_value(value)
-      case value
-      when ::Array
-        value.map { |v| ___convert_value(v) }.freeze
-      when Hash
-        self.class.new(value)
-      else
-        value
-      end
-    end
-
-    def ___key?(key)
-      @hash.key?(key) || @hash.key?(___convert_key(key))
-    end
-
-    def ___convert_key(key)
-      key.is_a?(::Symbol) ? key.to_s : key
-    end
-
-    def ___all_keys_equal(other)
-      return false unless @hash.count == other.count
-
-      @hash.reduce(true) do |acc, (k, _)|
-        value = self[k]
-        if other.key?(k)
-          acc && value == other[k]
-        elsif k.is_a?(String)
-          ck = k.to_sym
-          acc && other.key?(ck) && value == other[ck]
-        else
-          ck = ___convert_key(k)
-          acc && other.key?(ck) && value == other[ck]
-        end
-      end
-    end
-  end
-end

data/lib/resource_struct/loose_struct.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module ResourceStruct
-  #
-  # LooseStruct provides a struct by which accessing undefined fields returns nil
-  #
-  # struct = LooseStruct.new({ "foo" => 1, "bar" => [{ "baz" => 2 }, 3] })
-  #
-  # struct.foo? # => true
-  # struct.brr? # => false
-  # struct.foo # => 1
-  # struct.bar # => [LooseStruct<{ "baz" => 2 }>, 3]
-  # struct.brr # => nil
-  # struct[:foo] # => 1
-  # struct[:brr] # => nil
-  # struct[:bar, 0, :baz] # => 2
-  # struct[:bar, 0, :brr] # => nil
-  #
-  class LooseStruct
-    def initialize(hash)
-      raise ::ArgumentError, "first argument must be a Hash, found #{hash.class.name}" unless hash.is_a?(Hash)
-
-      @hash = hash
-      @ro_struct = {}
-    end
-
-    def method_missing(name, *_args)
-      return self[name] if ___key?(name)
-      return !!self[name[...-1]] if name.end_with?("?")
-
-      nil
-    end
-
-    def respond_to_missing?(_name, _include_private = false)
-      true
-    end
-
-    def to_h
-      @hash.to_h
-    end
-
-    def to_hash
-      @hash.to_hash
-    end
-
-    def inspect
-      "#{self.class.name}<#{@hash.inspect}>"
-    end
-
-    def to_s
-      @hash.to_s
-    end
-
-    def ==(other)
-      other.is_a?(Hash) && ___all_keys_equal(other) ||
-        (other.is_a?(LooseStruct) || other.is_a?(FirmStruct)) && ___all_keys_equal(other.instance_variable_get(:@hash))
-    end
-
-    def dig(key, *sub_keys)
-      ckey = ___convert_key(key)
-
-      result =
-        if @ro_struct.key?(ckey)
-          @ro_struct[ckey]
-        elsif key.is_a?(String)
-          @ro_struct[ckey] = ___convert_value(@hash[key] || @hash[key.to_sym])
-        else
-          @ro_struct[ckey] = ___convert_value(@hash[key] || @hash[ckey])
-        end
-
-      return result if sub_keys.empty?
-
-      return unless result
-
-      raise TypeError, "#{result.class.name} does not have #dig method" unless result.respond_to?(:dig)
-
-      result.dig(*sub_keys)
-    end
-    alias [] dig
-
-    private
-
-    def ___convert_value(value)
-      case value
-      when ::Array
-        value.map { |v| ___convert_value(v) }.freeze
-      when Hash
-        self.class.new(value)
-      else
-        value
-      end
-    end
-
-    def ___key?(key)
-      @hash.key?(key) || @hash.key?(___convert_key(key))
-    end
-
-    def ___convert_key(key)
-      key.is_a?(::Symbol) ? key.to_s : key
-    end
-
-    def ___all_keys_equal(other)
-      return false unless @hash.count == other.count
-
-      @hash.reduce(true) do |acc, (k, _)|
-        value = self[k]
-        if other.key?(k)
-          acc && value == other[k]
-        elsif k.is_a?(String)
-          ck = k.to_sym
-          acc && other.key?(ck) && value == other[ck]
-        else
-          ck = ___convert_key(k)
-          acc && other.key?(ck) && value == other[ck]
-        end
-      end
-    end
-  end
-end