resource-struct 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07376a21fe1fd7e877cdd8755e5a269e8336d1ac9906cf046e2aa39947938117
-  data.tar.gz: 070d252877489353d147fc93ee84d3ab0e74608f24d82d6d08163e9acd65c97f
+  metadata.gz: baaac467d70f8f08aed004cc989e61b19f1ba5c8af5d6c70e32157431ac5cce2
+  data.tar.gz: 640b07696f3f7332587859afdbe742fc6ea08e33fc6563d4e1ebc4d3430abb28
 SHA512:
-  metadata.gz: b72654d78fbdb3df534c058a4e1df047f0ed8c40a063dbfc77ff869b8123d370f34277878354fe5d537802637fec52490d89374428e1bd5a937455bf59b4f0a1
-  data.tar.gz: c3673ddd8220bc52a130ccfd5a512dd1f03dd3c7bfcadde3d28b075ba6b2619f2d8bfa346c853fbe20103ae35630cc6f8a6224bd6d67335a0a31ec63a16abfea
+  metadata.gz: c47966d7c7c3b96993594514eaaa21f879ad7c03f96a893d15255867491d990de7779dffb7c01dbf5189a2ac77992fd4f049a7601d4c5b42523a6b619fda27e9
+  data.tar.gz: 2a129ceadc0026557fca3e10834eca614f00f7415e282b39b7ea29473176cb8996ed67ef2b4682f45c45bd88e85b25745e00e0139928b7d5c01277420e949301

data/.rubocop.yml

@@ -15,6 +15,15 @@ Layout/LineLength:
 Metrics/MethodLength:
   Max: 20
 
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 15
+
 Naming/FileName:
   Enabled: true
   Exclude:

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [0.3.1] - 2022-01-05
+### Fix
+- Support nil meaning empty hash as first argument to `FlexStruct` and `StrictStruct`
+
+## [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
+
+## [0.2.0] - 2022-01-01
+### Changed
+- Indifferent access support for input hash (support for symbol-based hashes in initializer)
+
 ## [0.1.0] - 2021-12-14
 
 - Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    resource-struct (0.1.0)
+    resource-struct (0.3.1)
 
 GEM
   remote: https://rubygems.org/
@@ -48,6 +48,8 @@ GEM
 
 PLATFORMS
   x86_64-darwin-18
+  x86_64-darwin-19
+  x86_64-linux
 
 DEPENDENCIES
   rake (~> 13.0)
@@ -58,4 +60,4 @@ DEPENDENCIES
   rubocop-rspec
 
 BUNDLED WITH
-   2.2.33
+   2.3.4

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/bin/console

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require "bundler/setup"
-require "resource/struct"
+require "resource-struct"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

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.1.0"
+  VERSION = "0.3.1"
 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.1.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Alex Riedler
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-16 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:
@@ -55,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Ruby structs for resource responses

data/lib/resource_struct/firm_struct.rb

@@ -1,102 +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[___convert_key(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)
-      @hash == other.instance_variable_get(:@hash)
-    end
-
-    def [](key, *sub_keys)
-      ckey = ___convert_key(key)
-
-      result =
-        if @ro_struct.key?(ckey)
-          @ro_struct[ckey]
-        else
-          @ro_struct[ckey] = ___convert_value(@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?(___convert_key(key))
-    end
-
-    def ___convert_key(key)
-      key.is_a?(::Symbol) ? key.to_s : key
-    end
-  end
-end

data/lib/resource_struct/loose_struct.rb

@@ -1,99 +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[___convert_key(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)
-      @hash == other.instance_variable_get(:@hash)
-    end
-
-    def [](key, *sub_keys)
-      ckey = ___convert_key(key)
-
-      result =
-        if @ro_struct.key?(ckey)
-          @ro_struct[ckey]
-        else
-          @ro_struct[ckey] = ___convert_value(@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?(___convert_key(key))
-    end
-
-    def ___convert_key(key)
-      key.is_a?(::Symbol) ? key.to_s : key
-    end
-  end
-end