pure-struct 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62640381beae69f1f6332211fa9569853d48822e84c6c243b81d49312f059cb6
-  data.tar.gz: 70cb2eeb0153967d2864594ebdf504ee31014f6c9e7da8d733eb1f6b7a51b1b0
+  metadata.gz: 8f67ccb48a2f07b33076622ac6493bbb6911097996551228b404a236d3bd8116
+  data.tar.gz: 7421eac80b3a68e526fbc76cb7b61c3a3fc0bf83494fdb6b2c41cab8be07505a
 SHA512:
-  metadata.gz: 407a0c254b2b8178e11626d73f64f6fc7ba31b1d27ba7e4157029073d543dba3fdf98e2ccf1c3a8ed97ba278b8f77ce729c736ff90cd2fd729e1994d425ab00e
-  data.tar.gz: 174c6340a217b17904fa37e44747929f8d87fa1a3aac81d1da1d546aa0ad33b570eb564b7e4503dd254ba1aa2e15d47dbe94cc7921b22e4ea3dae76af1191ea5
+  metadata.gz: b09942a08d7dec8df2ada8eb67c1be6045cdc1d3db7093b37dcc67501f579d48650846030f04aa5cb1a2b64b82b8a2b3836ef8db5f26b5050eae8ec2b760359b
+  data.tar.gz: cd27449d4554b02ac94c941637691a9309e2e3a7f2813ad8a2fd17c252c6fbef296ed51c00a57177beed89ba96c8d77cbf6f2cac6e54110b58a6b9d7e5b21ab5

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## 1.0.2
+
+- Ensure StructClass.inspect shows `(keyword_init: true)` (e.g. `Person(keyword_init: true) `)
+- Implement to_s (e.g. `#<struct Person full_name=nil, age=nil>` for `Person` class )
+- Fix issue with ability to handle cycles in to_s/inspect implementation (printing #<struct #<Class:0x00007ff874073590>:...> when self object is encountered within attributes)
+- Fix issue with ability to handle cycles in hash implementation, including Opal
+- Fix issue with ability to handle cycles in equality
+- Fix issue with ability to handle cycles in equivalence
+
 ## 1.0.1
 
 - Include `Enumerable` just as in native `Struct`

data/README.md

@@ -22,7 +22,13 @@ Run:
 Or add to [Gemfile](https://bundler.io/man/gemfile.5.html):
 
 ```ruby
-gem 'pure-struct', '~> 1.0.1'
+gem 'pure-struct', '~> 1.0.2'
+```
+
+If you want to use in [Opal](https://opalrb.com/) only inside [Rails](https://rubyonrails.org/), suffix with `require: false`:
+
+```ruby
+gem 'pure-struct', '~> 1.0.2', require: false
 ```
 
 And, run:

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/lib/pure-struct.rb

@@ -19,16 +19,48 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+# Native Ruby built-in Struct implementation aliased as NativeStruct (with Struct pointing to the new pure Ruby implementation)
 NativeStruct = Struct
 Object.send(:remove_const, :Struct) if Object.constants.include?(:Struct)
 
-# Optional re-implmentation of Struct in Pure Ruby (to get around JS issues in Opal Struct)
+# Pure Ruby re-implementation of Struct to ensure cross-Ruby functionality where needed (e.g. Opal)
+#
+# Struct class object instances store members in @members Array and member values in @member_values Hash
+#
+# API perfectly matches that of Native Ruby built-in Struct.
+#
+# Native Ruby built-in Struct implementation is aliased as NativeStruct
 class Struct
   include Enumerable
 
   class << self
+    alias __new__ new
+    send(:private, :__new__)
+    
+    def new(class_name_or_attribute, *attributes, keyword_init: false)
+      raise 'Arguments cannot be nil' if ARG_VALIDATION[class_name_or_attribute, *attributes]
+      class_name = CLASS_NAME_EXTRACTION[class_name_or_attribute]
+      attributes.unshift(class_name_or_attribute) if class_name.nil?
+      attributes = attributes.map(&:to_sym)
+      struct_class = Class.new(self, &CLASS_DEFINITION_FOR_ATTRIBUTES[attributes, keyword_init])
+      class_name.nil? ? struct_class : const_set(class_name, struct_class)
+    end
+    
+    private
+    
     CLASS_DEFINITION_FOR_ATTRIBUTES = lambda do |attributes, keyword_init|
       lambda do |defined_class|
+        defined_class.class_variable_set(:@@attributes, attributes)
+        defined_class.class_variable_set(:@@keyword_init, keyword_init)
+        
+        defined_class.singleton_class.define_method(:new) {|*args, &block| __new__(*args, &block)}
+        defined_class.singleton_class.alias_method(:__inspect__, :inspect)
+        defined_class.private_class_method :__inspect__
+        
+        defined_class.singleton_class.define_method(:inspect) do
+          "#{__inspect__}#{'(keyword_init: true)' if keyword_init}"
+        end
+              
         attributes.each do |attribute|
           define_method(attribute) do
             self[attribute]
@@ -38,74 +70,6 @@ class Struct
           end
         end
       
-        define_method(:members) do
-          (@members ||= attributes).clone
-        end
-        
-        def []=(attribute, value)
-          normalized_attribute = attribute.to_sym
-          raise NameError, "no member #{attribute} in struct" unless @members.include?(normalized_attribute)
-          @member_values[normalized_attribute] = value
-        end
-        
-        def [](attribute)
-          normalized_attribute = attribute.to_sym
-          raise NameError, "no member #{attribute} in struct" unless @members.include?(normalized_attribute)
-          @member_values[normalized_attribute]
-        end
-        
-        def each(&block)
-          to_a.each(&block)
-        end
-        
-        def each_pair(&block)
-          @member_values.each_pair(&block)
-        end
-        
-        def to_h
-          @member_values.clone
-        end
-        
-        def to_a
-          @member_values.values
-        end
-        
-        def size
-          @members.size
-        end
-        alias length size
-        
-        def dig(*args)
-          @member_values.dig(*args)
-        end
-        
-        def select(&block)
-          to_a.select(&block)
-        end
-        
-        def eql?(other)
-          instance_of?(other.class) &&
-            @members.all? { |key| self[key].eql?(other[key]) }
-        end
-        
-        def ==(other)
-          other = coerce(other).first if respond_to?(:coerce, true)
-          other.kind_of?(self.class) &&
-            @members.all? { |key| self[key] == other[key] }
-        end
-        
-        def hash
-          if RUBY_ENGINE == 'opal'
-            # Opal doesn't implement hash as Integer everywhere, returning strings as themselves,
-            # so build a String everywhere for now as the safest common denominator to be consistent.
-            self.class.hash.to_s +
-              to_a.each_with_index.map {|value, i| (i+1).to_s + value.hash.to_s}.reduce(:+)
-          else
-            self.class.hash +
-              to_a.each_with_index.map {|value, i| i+1 * value.hash}.sum
-          end
-        end
-                
         if keyword_init
           def initialize(struct_class_keyword_args = {})
             members
@@ -124,7 +88,9 @@ class Struct
             end
           end
         end
+                
       end
+      
     end
     
     ARG_VALIDATION = lambda do |class_name_or_attribute, *attributes|
@@ -132,22 +98,126 @@ class Struct
     end
     
     CLASS_NAME_EXTRACTION = lambda do |class_name_or_attribute|
-      if class_name_or_attribute.is_a?(String) && RUBY_ENGINE != 'opal'
-        raise NameError, "identifier name needs to be constant" unless class_name_or_attribute.match(/^[A-Z]/)
+      if class_name_or_attribute.is_a?(String) && (RUBY_ENGINE != 'opal' || class_name_or_attribute.match(/^[A-Z]/))
+        raise NameError, "identifier name needs to be constant" if RUBY_ENGINE != 'opal' && !class_name_or_attribute.match(/^[A-Z]/)
         class_name_or_attribute
       end
     end
-    
-    alias __new__ new
-    def new(class_name_or_attribute, *attributes, keyword_init: false)
-      raise 'Arguments cannot be nil' if ARG_VALIDATION[class_name_or_attribute, *attributes]
-      class_name = CLASS_NAME_EXTRACTION[class_name_or_attribute]
-      attributes.unshift(class_name_or_attribute) if class_name.nil?
-      attributes = attributes.map(&:to_sym)
-      struct_class = Class.new(self, &CLASS_DEFINITION_FOR_ATTRIBUTES[attributes, keyword_init])
-      struct_class.singleton_class.define_method(:new) {|*args, &block| __new__(*args, &block)}
-      class_name.nil? ? struct_class : const_set(class_name, struct_class)
+  
+  end
+
+  # Returns member symbols (strings in Opal) representing Struct attribute names
+  def members
+    (@members ||= self.class.class_variable_get(:@@attributes)).clone
+  end
+          
+  def []=(attribute, value)
+    normalized_attribute = attribute.to_sym
+    raise NameError, "no member #{attribute} in struct" unless @members.include?(normalized_attribute)
+    @member_values[normalized_attribute] = value
+  end
+  
+  def [](attribute)
+    normalized_attribute = attribute.to_sym
+    raise NameError, "no member #{attribute} in struct" unless @members.include?(normalized_attribute)
+    @member_values[normalized_attribute]
+  end
+  
+  # Iterates through each value
+  def each(&block)
+    to_a.each(&block)
+  end
+  
+  # Iterates through each member value pair
+  def each_pair(&block)
+    @member_values.each_pair(&block)
+  end
+  
+  # Returns member values Hash (includes member keys)
+  def to_h
+    @member_values.clone
+  end
+  
+  # Returns values Array (no member keys)
+  def to_a
+    @member_values.values
+  end
+  
+  # Original Object #inspect implementation
+  alias __inspect__ inspect
+  send(:private, :__inspect__)
+  
+  # Prints Struct member values including class name if set
+  #
+  # #inspect does the same thing
+  #
+  # __inspect__ aliases the original Object inspect implementation
+  def to_s
+    member_values_string = @member_values.map do |member, value|
+      if value.equal?(self)
+        value_class_string = self.class.send(:__inspect__).split.first
+        value_string = "#<struct #{value_class_string}:...>"
+      else
+        value_string = value.inspect
+      end
+      "#{member}=#{value_string}"
+    end.join(', ')
+    class_name_string = "#{self.class.name} " unless self.class.name.nil?
+    "#<struct #{class_name_string}#{member_values_string}>"
+  end
+  alias inspect to_s
+  
+  def size
+    @members.size
+  end
+  alias length size
+  
+  def dig(*args)
+    @member_values.dig(*args)
+  end
+  
+  # Selects values with block (only value is passed in as block arg)
+  def select(&block)
+    to_a.select(&block)
+  end
+  
+  def eql?(other)
+    instance_of?(other.class) &&
+      @members.all? { |key| (self[key].equal?(self) && other[key].equal?(self)) || self[key].eql?(other[key]) }
+  end
+  
+  def ==(other)
+    other = coerce(other).first if respond_to?(:coerce, true)
+    other.kind_of?(self.class) &&
+      @members.all? { |key| (self[key].equal?(self) && other[key].equal?(self)) || self[key] == other[key] }
+  end
+  
+  # Return compound hash value consisting of Struct class hash and all indexed value hashes
+  #
+  # Opal doesn't implement hash as Integer everywhere, returning strings as themselves,
+  # so this returns a String in Opal as a safe common denominator for all object types.
+  def hash
+    return __hash__opal__ if RUBY_ENGINE == 'opal'
+    class_hash = self.class.hash
+    indexed_values = to_a.each_with_index
+    value_hashes = indexed_values.map do |value, i|
+      value_hash = value.equal?(self) ? class_hash : value.hash
+      i+1 * value_hash
     end
-      
+    class_hash + value_hashes.sum
+  end
+
+  private
+  
+  def __hash__opal__
+    class_hash = self.class.hash
+    indexed_values = to_a.each_with_index
+    class_hash = class_hash.to_s
+    value_hashes = indexed_values.map do |value, i|
+      value_hash_string = value.equal?(self) ? class_hash : value.hash.to_s
+      (i+1).to_s + value_hash_string
+    end
+    class_hash + value_hashes.reduce(:+)
   end
+  
 end

data/pure-struct.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: pure-struct 1.0.1 ruby lib
+# stub: pure-struct 1.0.2 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "pure-struct".freeze
-  s.version = "1.0.1"
+  s.version = "1.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Andy Maleh".freeze]
-  s.date = "2021-01-09"
+  s.date = "2021-01-10"
   s.description = "Pure Ruby re-implementation of Struct to ensure cross-Ruby functionality where needed (e.g. Opal)".freeze
   s.email = "andy.am@gmail.com".freeze
   s.extra_rdoc_files = [
@@ -38,7 +38,7 @@ Gem::Specification.new do |s|
 
   if s.respond_to? :add_runtime_dependency then
     s.add_development_dependency(%q<rspec>.freeze, ["~> 3.5.0"])
-    s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
+    s.add_development_dependency(%q<rdoc>.freeze, [">= 6.3.0"])
     s.add_development_dependency(%q<bundler>.freeze, [">= 1.0"])
     s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
     s.add_development_dependency(%q<simplecov>.freeze, ["~> 0.16.0"])
@@ -46,7 +46,7 @@ Gem::Specification.new do |s|
     s.add_development_dependency(%q<puts_debuggerer>.freeze, [">= 0"])
   else
     s.add_dependency(%q<rspec>.freeze, ["~> 3.5.0"])
-    s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
+    s.add_dependency(%q<rdoc>.freeze, [">= 6.3.0"])
     s.add_dependency(%q<bundler>.freeze, [">= 1.0"])
     s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
     s.add_dependency(%q<simplecov>.freeze, ["~> 0.16.0"])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pure-struct
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-09 00:00:00.000000000 Z
+date: 2021-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -28,16 +28,16 @@ dependencies:
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: 6.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: 6.3.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement