leto 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2926017bd4fc2ec078b89e6d39157ed7e79e48693e82628665c3435c5c39b4f4
-  data.tar.gz: f8736c1e1e0a5e7a7b6c93d8c48c7393b6d554906245c5fcc71d05aa3d200789
+  metadata.gz: 0ed0d190b234b4976a219ba5b50a3e9cb4f394be7b1a27aa2f1d7bdfe93887b0
+  data.tar.gz: eafafd24510514cf7ba4e59cdf1a967c7464d175b8ceed1f3cafa2e78fffcc1e
 SHA512:
-  metadata.gz: 1b13efbac9e6e200a43067a57b219a5128d69eea06a4a41a8fe2bd88d49932d0a10a60b38807443133300b86aaa9d3d75045e0bc340057d6d16564647b68c8ba
-  data.tar.gz: 476318c70ed5d9a1df6ab4abc67a9d3dad35a003585d34ec4bdc743f6990823db6dc5c3430a244ed12bc3c454cbb5a8e1937dc2ada58568c8a38ce1e018cbbb9
+  metadata.gz: 79b0be7884c86be4a14977e5aaae6147da85b857f632013bd82f9fe95addf28a4014ea7adeba1c75dfc63b9988ab7426c622cb79bc2c2886dca04be246ee2db5
+  data.tar.gz: 961a19be85b69aac0763828648c09100af4a9f84eff07a45e2b9c0c247c84e5b7ae9647a9bd4a7de791eb7cd0f0342b91f82d2cd50a85286425e4a8f915bd2fe

data/.rubocop.yml

@@ -21,8 +21,14 @@ Lint/AmbiguousBlockAssociation:
 Lint/AmbiguousOperatorPrecedence:
   Enabled: false
 
+Style/DocumentDynamicEvalDefinition:
+  Enabled: false
+
 Style/FetchEnvVar:
   Enabled: false
 
 Style/FrozenStringLiteralComment:
   Enabled: false
+
+Style/SymbolProc:
+  Enabled: false

data/CHANGELOG.md

@@ -1,10 +1,16 @@
 ## [Unreleased]
 
+## [2.1.0] - 2023-05-20
+
+### Added
+
+- `::call`, `::trace` and `::deep_dup` support for Data feature of Ruby 3.2
+
 ## [2.0.0] - 2023-02-27
 
 ### Changed
 
-- removed support for gettings paths by calling `::call` with a two-arg block
+- removed support for getting paths by calling `::call` with a two-arg block
 
 ### Added
 

data/Gemfile

@@ -6,11 +6,10 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake", "~> 13.0"
-
 gem "rspec", "~> 3.0"
 
 if RUBY_VERSION.to_f >= 3.0
-  gem "rubocop", "~> 1.21"
-
   gem "relaxed-rubocop"
+  gem "rubocop", "~> 1.21"
+  gem "simplecov-cobertura"
 end

data/README.md

@@ -1,7 +1,8 @@
 # Leto
 
 [![Gem Version](https://badge.fury.io/rb/leto.svg)](http://badge.fury.io/rb/leto)
-[![Build Status](https://github.com/jaynetics/leto/workflows/tests/badge.svg)](https://github.com/jaynetics/leto/actions)
+[![Build Status](https://github.com/jaynetics/leto/actions/workflows/tests.yml/badge.svg)](https://github.com/jaynetics/leto/actions)
+[![Coverage](https://codecov.io/gh/jaynetics/leto/branch/main/graph/badge.svg?token=0993K9I8VC)](https://codecov.io/gh/jaynetics/leto)
 
 A generic object traverser for Ruby (named after the Greek [childbearing goddess Leto](https://www.theoi.com/Titan/TitanisLeto.html)).
 
@@ -12,6 +13,7 @@ Takes an object and recursively yields:
 - Hash keys and values
 - Enumerable members
 - Struct members
+- [Data](https://docs.ruby-lang.org/en/3.2/Data.html) members
 - Range begins and ends
 
 This makes stuff like deep-freezing fairly easy to implement:
@@ -79,7 +81,7 @@ Leto.dig(object, [[:[], 0], [:[], :a], [:[], 1], [:end]]) # => "d"
 - [`Leto.deep_eql?(obj1, obj2)`](https://github.com/search?q=deep_eql+repo%3Ajaynetics%2Fleto+path%3Alib%2Fleto%2Futils.rb&type=code)
   - stricter version of `#eql?` that takes all ivars into consideration
 - [`Leto.deep_dup(obj)`](https://github.com/search?q=deep_dup+repo%3Ajaynetics%2Fleto+path%3Alib%2Fleto%2Futils.rb&type=code)
-  - more thorough than `active_support` or `deep_dup` gems, e.g. dups ivars
+  - more thorough than [`active_support`](https://www.rubydoc.info/search/gems/activesupport?q=deep_dup) or [`deep_dup`](https://github.com/ollie/deep_dup) gems, e.g. dups ivars
 - [`Leto.shared_mutable_state?(obj1, obj2)`](https://github.com/search?q=shared_mutable_state+repo%3Ajaynetics%2Fleto+path%3Alib%2Fleto%2Futils.rb&type=code)
   - useful for debugging or verifying that a `#dup` implementation is sane
 - [`Leto.shared_mutables(obj1, obj2)`](https://github.com/search?q=shared_mutables+repo%3Ajaynetics%2Fleto+path%3Alib%2Fleto%2Futils.rb&type=code)

data/lib/leto/call.rb

@@ -12,70 +12,81 @@ module Leto
     call(obj, max_depth: max_depth, path: path || Path.new(start: obj), &block)
   end
 
-  def self.traverse(obj, path, depth, max_depth, seen, block)
-    return if seen[obj] || max_depth&.<(depth)
+  instance_eval <<-RUBY, __FILE__, __LINE__ + 1
 
-    seen[obj] = true
-    depth += 1
+  private
 
-    path ? block.call(obj, path) : block.call(obj)
+    def traverse(obj, path, depth, max_depth, seen, block)
+      return if seen[obj] || max_depth&.<(depth)
 
-    obj.instance_variables.each do |ivar_name|
-      traverse(
-        obj.instance_variable_get(ivar_name),
-        path&.+([[:instance_variable_get, ivar_name]]),
-        depth, max_depth, seen, block
-      )
-    end
+      seen[obj] = true
+      depth += 1
 
-    case obj
-    when Hash
-      obj.keys.each_with_index do |k, i|
-        traverse(k, path&.+([[:keys], [:[], i]]), depth, max_depth, seen, block)
-        traverse(obj[k], path&.+([[:[], k]]), depth, max_depth, seen, block)
-      end
-    when Module
-      obj.class_variables.each do |cvar_name|
-        traverse(
-          obj.class_variable_get(cvar_name),
-          path&.+([[:class_variable_get, cvar_name]]),
-          depth, max_depth, seen, block
-        )
-      end
-      obj.constants.each do |const_name|
+      path ? block.call(obj, path) : block.call(obj)
+
+      obj.instance_variables.each do |ivar_name|
         traverse(
-          obj.const_get(const_name),
-          path&.+([[:const_get, const_name]]),
+          obj.instance_variable_get(ivar_name),
+          path&.+([[:instance_variable_get, ivar_name]]),
           depth, max_depth, seen, block
         )
       end
-    when Range
-      traverse(obj.begin, path&.+([[:begin]]), depth, max_depth, seen, block)
-      traverse(obj.end,   path&.+([[:end]]), depth, max_depth, seen, block)
-    when Struct
-      obj.members.each do |member|
-        traverse(obj[member], path&.+([[:[], member]]), depth, max_depth, seen, block)
-      end
-    when Enumerable
-      obj.each_with_index do |el, idx|
-        traverse(el, path&.+([[:[], idx]]), depth, max_depth, seen, block)
+
+      case obj
+      when Hash
+        obj.keys.each_with_index do |k, i|
+          traverse(k, path&.+([[:keys], [:[], i]]), depth, max_depth, seen, block)
+          traverse(obj[k], path&.+([[:[], k]]), depth, max_depth, seen, block)
+        end
+      when Module
+        obj.class_variables.each do |cvar_name|
+          traverse(
+            obj.class_variable_get(cvar_name),
+            path&.+([[:class_variable_get, cvar_name]]),
+            depth, max_depth, seen, block
+          )
+        end
+        obj.constants.each do |const_name|
+          traverse(
+            obj.const_get(const_name),
+            path&.+([[:const_get, const_name]]),
+            depth, max_depth, seen, block
+          )
+        end
+      when Range
+        traverse(obj.begin, path&.+([[:begin]]), depth, max_depth, seen, block)
+        traverse(obj.end,   path&.+([[:end]]), depth, max_depth, seen, block)
+      when Struct
+        obj.members.each do |member|
+          traverse(obj[member], path&.+([[:[], member]]), depth, max_depth, seen, block)
+        end
+      when Enumerable
+        obj.each_with_index do |el, idx|
+          traverse(el, path&.+([[:[], idx]]), depth, max_depth, seen, block)
+        end
+      #{
+        defined?(Data) && Data.respond_to?(:define) && <<-DATA_FEATURE_RUBY
+        when Data
+          obj.members.each do |member|
+            traverse(
+              obj.send(member),
+              path&.+([[:send, member]]),
+              depth, max_depth, seen, block
+            )
+          end
+        DATA_FEATURE_RUBY
+      }
       end
     end
-  end
-  private_class_method :traverse
 
-  if RUBY_VERSION.to_f > 2.7
-    def self.build_seen_hash
-      {}.tap(&:compare_by_identity)
-    end
-  else
     # ignore leaky constants in old rubies
-    def self.build_seen_hash
-      hash = {}.tap(&:compare_by_identity)
-      hash[::Etc::Group] = true if defined?(::Etc::Group)
-      hash[::Etc::Passwd] = true if defined?(::Etc::Passwd)
-      hash[::Process::Tms] = true if defined?(::Process::Tms)
+    def build_seen_hash
+      hash = {}
+      hash.compare_by_identity
+      #{'hash[::Etc::Group] = true' if defined?(::Etc::Group)}
+      #{'hash[::Etc::Passwd] = true' if defined?(::Etc::Passwd)}
+      #{'hash[::Process::Tms] = true' if defined?(::Process::Tms)}
       hash
     end
-  end
+  RUBY
 end

data/lib/leto/utils.rb

@@ -24,21 +24,27 @@ module Leto
     return obj if IMMUTABLE_CLASSES.include?(obj.class) || !duplicable?(obj) ||
                   (!include_modules && obj.is_a?(Module))
 
-    trace(obj, max_depth: 1).each_with_object(obj.dup) do |(el, path), copy|
+    copy = obj.dup
+
+    trace(obj, max_depth: 1).each do |el, path|
       method, *args = path.steps[0]
       case method
       when :instance_variable_get
         copy.instance_variable_set(*args, deep_dup(el, include_modules: include_modules))
       when :[]
         copy[*args] = deep_dup(el, include_modules: include_modules)
+      when :send # Data
+        copy = copy.with(args[0] => deep_dup(el, include_modules: include_modules))
       when :begin
         return Range.new(deep_dup(obj.begin), deep_dup(obj.end), obj.exclude_end?)
       end
     end
+
+    copy
   end
 
   def self.shared_mutable_state?(obj1, obj2)
-    shared_mutables(obj1, obj2).any?
+    each_shared_object(obj1, obj2, filter: method(:mutable?)).any?
   end
 
   # returns [[shared_object, path1, path2], ...], e.g.:
@@ -50,16 +56,22 @@ module Leto
   #   ["bar", [[:[], 1]], [[:[], 0]]]
   # ]
   def self.shared_mutables(obj1, obj2)
-    shared_objects(obj1, obj2, filter: method(:mutable?))
+    each_shared_object(obj1, obj2, filter: method(:mutable?)).to_a
   end
 
   def self.shared_objects(obj1, obj2, filter: nil)
+    each_shared_object(obj1, obj2, filter: filter).to_a
+  end
+
+  def self.each_shared_object(obj1, obj2, filter: nil)
+    block_given? or return enum_for(__method__, obj1, obj2, filter: filter)
+
     obj2_els_with_path = trace(obj2).to_a
-    trace(obj1).each_with_object([]) do |(el1, path1), acc|
+    trace(obj1).each do |el1, path1|
       next if filter && !filter.call(el1)
 
       obj2_els_with_path.reject do |el2, path2|
-        acc << [el1, path1, path2] if el1.equal?(el2)
+        yield(el1, path1, path2) if el1.equal?(el2)
       end
     end
   end

data/lib/leto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leto
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leto
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-27 00:00:00.000000000 Z
+date: 2023-05-20 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -53,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
 summary: Generic object traverser