resource-struct 0.2.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9513a73bc3c6331f8174bd02c30c72fcbc655fb2e00c8d88cb1cd80fa3c60ae
-  data.tar.gz: 3d1355e235d443b74098434f453a482d090790a25f57c65ce8a57f931813863a
+  metadata.gz: a61800df441acd7f512f708b4830412edf391047be95e29e8c3e002d8684caf4
+  data.tar.gz: dc26ed248afa3f648cc4369225bb402eccf28d74f9770ff1a8f39de088009897
 SHA512:
-  metadata.gz: 88f21e99bce0cf3620cf0644f240176af22bd64f99a51781c293cd407467062cbe784d50274115e4214443801f34d10c79858a27910e9bf54556356e5e95d753
-  data.tar.gz: bfa0b4576f987a5a5a7d39d62abcc7ac4f00fd6f2d27c8bb20d124fbf092914bab0212c8c4987451a86d47e3c06d31ab3452c777f0f25cb29a128e6ca048e3cf
+  metadata.gz: cd6e55f3a2cd859a37e6fef45485c322f83c8bcbfb6e1df97f4d69e594d77ddbff42668a07bec7438aa0483382e52d26f4ede84162be611cf98ca40b0be3b8b3
+  data.tar.gz: 4ff5a6edcb9dd6e07c4c3c5744d6e56aaefc14593d3acf6cd7fa9aeee25210656595d7ba926f3e0884265328604b01f5eba35ece222233f248244097813b2beb

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [0.3.2] - 2022-01-05
+### Fix
+- Support for proper marshalling of object
+
+## [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)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    resource-struct (0.2.0)
+    resource-struct (0.3.2)
 
 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/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,104 @@
+# 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
+
+      def marshal_dump
+        {
+          data: @hash
+        }
+      end
+
+      def marshal_load(obj)
+        @ro_struct = {}
+        @hash = obj[:data]
+      end
+
+      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.0"
+  VERSION = "0.3.2"
 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.0
+  version: 0.3.2
 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,118 +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, v)|
-        if other.key?(k)
-          acc && other[k] == v
-        else
-          ck = ___convert_key(k)
-          acc && other.key?(ck) && other[ck] == v
-        end
-      end
-    end
-  end
-end

data/lib/resource_struct/loose_struct.rb

@@ -1,115 +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, v)|
-        if other.key?(k)
-          acc && other[k] == v
-        else
-          ck = ___convert_key(k)
-          acc && other.key?(ck) && other[ck] == v
-        end
-      end
-    end
-  end
-end