leto 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 539f52438c18bb93115734b5c3c9dd5f8678886d392357c4fdca658b43d95357
-  data.tar.gz: bbe092a276d3241d39857cb81e8fb748108b15e67cbc0e421b7390545b8a066a
+  metadata.gz: 2926017bd4fc2ec078b89e6d39157ed7e79e48693e82628665c3435c5c39b4f4
+  data.tar.gz: f8736c1e1e0a5e7a7b6c93d8c48c7393b6d554906245c5fcc71d05aa3d200789
 SHA512:
-  metadata.gz: 9a0e610d258c35cf044c0118ccc10dff918edc8495df7448c058dbe6ad3201e540952fa67ac14e065229e1dd961788936e1343d30254743f47319609b5b4e169
-  data.tar.gz: c7e0fa4e9be9c2c0da092a7dbb88c78b9b11a12d8fb4f9d34e2ed97794ab2f26282c1fe31b04db5c70039198e675d2770ab0a7ae52edcb28049e7568c6c7bc56
+  metadata.gz: 1b13efbac9e6e200a43067a57b219a5128d69eea06a4a41a8fe2bd88d49932d0a10a60b38807443133300b86aaa9d3d75045e0bc340057d6d16564647b68c8ba
+  data.tar.gz: 476318c70ed5d9a1df6ab4abc67a9d3dad35a003585d34ec4bdc743f6990823db6dc5c3430a244ed12bc3c454cbb5a8e1937dc2ada58568c8a38ce1e018cbbb9

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [2.0.0] - 2023-02-27
+
+### Changed
+
+- removed support for gettings 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

@@ -9,6 +9,8 @@ gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 
-gem "rubocop", "~> 1.21"
+if RUBY_VERSION.to_f >= 3.0
+  gem "rubocop", "~> 1.21"
 
-gem "relaxed-rubocop"
+  gem "relaxed-rubocop"
+end

data/README.md

@@ -50,8 +50,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 +64,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 +72,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` or `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,20 +1,22 @@
 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)
+
+    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)
 
     seen[obj] = true
+    depth += 1
 
     path ? block.call(obj, path) : block.call(obj)
 
@@ -22,43 +24,58 @@ module Leto
       traverse(
         obj.instance_variable_get(ivar_name),
         path&.+([[:instance_variable_get, ivar_name]]),
-        seen, block
+        depth, max_depth, seen, block
       )
     end
 
     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)
+        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]]),
-          seen, block
+          depth, max_depth, seen, block
         )
       end
       obj.constants.each do |const_name|
         traverse(
           obj.const_get(const_name),
           path&.+([[:const_get, const_name]]),
-          seen, block
+          depth, max_depth, seen, block
         )
       end
     when Range
-      traverse(obj.begin, path&.+([[:begin]]), seen, block)
-      traverse(obj.end,   path&.+([[:end]]), seen, block)
+      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]]), seen, block)
+        traverse(obj[member], path&.+([[:[], member]]), depth, max_depth, seen, block)
       end
     when Enumerable
       obj.each_with_index do |el, idx|
-        traverse(el, path&.+([[:[], idx]]), seen, block)
+        traverse(el, path&.+([[:[], idx]]), depth, max_depth, seen, block)
       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)
+      hash
+    end
+  end
 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,6 +20,23 @@ 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))
+
+    trace(obj, max_depth: 1).each_with_object(obj.dup) do |(el, path), copy|
+      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 :begin
+        return Range.new(deep_dup(obj.begin), deep_dup(obj.end), obj.exclude_end?)
+      end
+    end
+  end
+
   def self.shared_mutable_state?(obj1, obj2)
     shared_mutables(obj1, obj2).any?
   end
@@ -37,12 +54,11 @@ module Leto
   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|
+    obj2_els_with_path = trace(obj2).to_a
+    trace(obj1).each_with_object([]) do |(el1, path1), acc|
       next if filter && !filter.call(el1)
 
-      objects_with_path2.reject do |el2, path2|
+      obj2_els_with_path.reject do |el2, path2|
         acc << [el1, path1, path2] if el1.equal?(el2)
       end
     end
@@ -56,9 +72,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.0.0"
 end

metadata

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