leto 1.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 539f52438c18bb93115734b5c3c9dd5f8678886d392357c4fdca658b43d95357
-  data.tar.gz: bbe092a276d3241d39857cb81e8fb748108b15e67cbc0e421b7390545b8a066a
+  metadata.gz: 0ed0d190b234b4976a219ba5b50a3e9cb4f394be7b1a27aa2f1d7bdfe93887b0
+  data.tar.gz: eafafd24510514cf7ba4e59cdf1a967c7464d175b8ceed1f3cafa2e78fffcc1e
 SHA512:
-  metadata.gz: 9a0e610d258c35cf044c0118ccc10dff918edc8495df7448c058dbe6ad3201e540952fa67ac14e065229e1dd961788936e1343d30254743f47319609b5b4e169
-  data.tar.gz: c7e0fa4e9be9c2c0da092a7dbb88c78b9b11a12d8fb4f9d34e2ed97794ab2f26282c1fe31b04db5c70039198e675d2770ab0a7ae52edcb28049e7568c6c7bc56
+  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,5 +1,23 @@
 ## [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 getting paths by calling `::call` with a two-arg block
+
+### Added
+
+- `::deep_dup`
+- `::trace`
+- support for older Rubies
+
 ## [1.0.0] - 2023-02-24
 
 - Initial release

data/Gemfile

@@ -6,9 +6,10 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake", "~> 13.0"
-
 gem "rspec", "~> 3.0"
 
-gem "rubocop", "~> 1.21"
-
-gem "relaxed-rubocop"
+if RUBY_VERSION.to_f >= 3.0
+  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:
@@ -50,8 +52,8 @@ Leto.call(object) { |el| p el }
 Leto.call(object).to_a
 # => [[{:a=>["b", ["c".."d"]]}], {:a=>["b", ["c".."d"]]}, :a, ...]
 
-# all (sub-)objects have a path:
-Leto.call(object) { |el, path| puts "#{el.inspect.ljust(23)} @#{path}" }
+# Leto::trace behaves like ::call, but also yields each (sub-)object's path:
+Leto.trace(object) { |el, path| puts "#{el.inspect.ljust(23)} @#{path}" }
 # prints:
 #
 # [{:a=>["b", "c".."d"]}] @#<Leto::Path [{:a=>["b", "c".."d"]}]>
@@ -64,7 +66,7 @@ Leto.call(object) { |el, path| puts "#{el.inspect.ljust(23)} @#{path}" }
 # "d"                     @#<Leto::Path [{:a=>["b", "c".."d"]}][0][:a][1].end>
 
 # paths can be looked up with Leto::Path#resolve or Leto::dig
-path = Leto.call(object).map { |_el, path| path }.last # => #<Leto::Path...>
+path = Leto.trace(object).map { |_el, path| path }.last # => #<Leto::Path...>
 path.resolve # => "d"
 Leto.dig(object, path) # => "d"
 Leto.dig(object, [[:[], 0], [:[], :a], [:[], 1], [:end]]) # => "d"
@@ -72,17 +74,19 @@ Leto.dig(object, [[:[], 0], [:[], :a], [:[], 1], [:end]]) # => "d"
 
 ### Included utility methods
 
-- `Leto.deep_freeze(obj)`
+- [`Leto.deep_freeze(obj)`](https://github.com/search?q=deep_freeze+repo%3Ajaynetics%2Fleto+path%3Alib%2Fleto%2Futils.rb&type=code)
   - similar to the version above, but avoids freezing Modules and unfreezables
-- `Leto.deep_print(obj)`
+- [`Leto.deep_print(obj)`](https://github.com/search?q=deep_print+repo%3Ajaynetics%2Fleto+path%3Alib%2Fleto%2Futils.rb&type=code)
   - for debugging - prints more information than `pretty_print` does by default
-- `Leto.deep_eql?(obj1, obj2)`
+- [`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.shared_mutable_state?(obj1, obj2)`
+- [`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`](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)`
+- [`Leto.shared_mutables(obj1, obj2)`](https://github.com/search?q=shared_mutables+repo%3Ajaynetics%2Fleto+path%3Alib%2Fleto%2Futils.rb&type=code)
   - useful for debugging or verifying that a `#dup` implementation is sane
-- `Leto.shared_objects(obj1, obj2)`
+- [`Leto.shared_objects(obj1, obj2)`](https://github.com/search?q=shared_objects+repo%3Ajaynetics%2Fleto+path%3Alib%2Fleto%2Futils.rb&type=code)
   - returns all objects shared by `obj1` and `obj2`, whether mutable or not
 
 ## Benchmarks

data/Rakefile

@@ -5,8 +5,10 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-task default: %i[spec rubocop]
+if RUBY_VERSION.to_f >= 3.0
+  require "rubocop/rake_task"
+  RuboCop::RakeTask.new
+  task default: %i[spec rubocop]
+else
+  task default: %i[spec]
+end

data/leto.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Generic object traverser"
   spec.homepage = "https://github.com/jaynetics/leto"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.required_ruby_version = ">= 2.3.0"
 
   spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
   spec.metadata["homepage_uri"] = spec.homepage

data/lib/leto/call.rb

@@ -1,64 +1,92 @@
 module Leto
-  LEAKY_PROCESS_TMS = RUBY_VERSION.to_f <= 2.7
+  def self.call(obj, max_depth: nil, path: nil, &block)
+    block_given? or return enum_for(__method__, obj, max_depth: max_depth, path: path)
 
-  def self.call(obj, &block)
-    return enum_for(__method__, obj) unless block_given?
-
-    seen = {}.tap(&:compare_by_identity)
-    seen[Process::Tms] = true if LEAKY_PROCESS_TMS
-    path = block.arity == 2 ? Path.new(start: obj) : nil
-    traverse(obj, path, seen, block)
+    traverse(obj, path, 0, max_depth, build_seen_hash, block)
     obj
   end
 
-  def self.traverse(obj, path, seen, block)
-    return if seen[obj]
+  def self.trace(obj, max_depth: nil, path: nil, &block)
+    block_given? or return enum_for(__method__, obj, max_depth: max_depth, path: path)
 
-    seen[obj] = true
+    call(obj, max_depth: max_depth, path: path || Path.new(start: obj), &block)
+  end
 
-    path ? block.call(obj, path) : block.call(obj)
+  instance_eval <<-RUBY, __FILE__, __LINE__ + 1
 
-    obj.instance_variables.each do |ivar_name|
-      traverse(
-        obj.instance_variable_get(ivar_name),
-        path&.+([[:instance_variable_get, ivar_name]]),
-        seen, block
-      )
-    end
+  private
 
-    case obj
-    when Hash
-      obj.keys.each_with_index do |k, i|
-        traverse(k, path&.+([[:keys], [:[], i]]), seen, block)
-        traverse(obj[k], path&.+([[:[], k]]), 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]]),
-          seen, block
-        )
-      end
-      obj.constants.each do |const_name|
+    def traverse(obj, path, depth, max_depth, seen, block)
+      return if seen[obj] || max_depth&.<(depth)
+
+      seen[obj] = true
+      depth += 1
+
+      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]]),
-          seen, block
+          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]]), seen, block)
-      traverse(obj.end,   path&.+([[:end]]), seen, block)
-    when Struct
-      obj.members.each do |member|
-        traverse(obj[member], path&.+([[:[], member]]), seen, block)
-      end
-    when Enumerable
-      obj.each_with_index do |el, idx|
-        traverse(el, path&.+([[:[], idx]]), 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
+
+    # ignore leaky constants in old rubies
+    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
+  RUBY
 end

data/lib/leto/path.rb

@@ -14,6 +14,11 @@ module Leto
       steps.each(&block)
     end
 
+    def size
+      steps.size
+    end
+    alias count size
+
     def +(other)
       self.class.new(start: start, steps: steps + other.to_a)
     end
@@ -21,8 +26,6 @@ module Leto
     def resolve
       steps.inject(start) do |obj, (method, *args)|
         obj&.send(method, *args) or break obj
-      rescue StandardError => e
-        warn "#{__method__}: #{e.class} #{e.message}"
       end
     end
 

data/lib/leto/utils.rb

@@ -8,7 +8,7 @@ module Leto
   end
 
   def self.deep_print(obj, print_method: :inspect, indent: 4, show_path: true)
-    call(obj) do |el, path|
+    trace(obj) do |el, path|
       puts "#{' ' * path.count * indent}#{el.send(print_method)}" \
            "#{"  @ #{path.inspect}" if show_path}" \
            [0..78]
@@ -20,8 +20,31 @@ module Leto
     call(obj1).to_a == call(obj2).to_a
   end
 
+  def self.deep_dup(obj, include_modules: false)
+    return obj if IMMUTABLE_CLASSES.include?(obj.class) || !duplicable?(obj) ||
+                  (!include_modules && obj.is_a?(Module))
+
+    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.:
@@ -33,17 +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)
-    objects_with_path1 = call(obj1).map { |el, path| [el, path] }
-    objects_with_path2 = call(obj2).map { |el, path| [el, path] }
-    objects_with_path1.each.with_object([]) do |(el1, path1), acc|
+    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 do |el1, path1|
       next if filter && !filter.call(el1)
 
-      objects_with_path2.reject do |el2, path2|
-        acc << [el1, path1, path2] if el1.equal?(el2)
+      obj2_els_with_path.reject do |el2, path2|
+        yield(el1, path1, path2) if el1.equal?(el2)
       end
     end
   end
@@ -56,9 +84,26 @@ module Leto
   IMMUTABLE_CLASSES = [
     FalseClass,
     Float,
-    Integer,
+    if defined?(Integer)
+      Integer
+    else
+      Fixnum # rubocop:disable Lint/UnifiedInteger for Ruby < 2.4
+    end,
     NilClass,
     Symbol,
     TrueClass,
   ].freeze
+
+  def self.duplicable?(obj)
+    !NON_DUPLICABLE_CLASSES.include?(obj.class) && obj.respond_to?(:dup)
+  end
+  private_class_method :duplicable?
+
+  require 'singleton'
+
+  NON_DUPLICABLE_CLASSES = [
+    Method,
+    Singleton,
+    UnboundMethod
+  ].freeze
 end

data/lib/leto/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leto
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-24 00:00:00.000000000 Z
+date: 2023-05-20 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -46,14 +46,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !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