ryo.rb 0.5.5 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c611c0e990fe0cdfd09ede551e1b457e93af7765de379d64b5dbdf6495e2b766
-  data.tar.gz: 24406b552991b2459da63847ff4b65071eb2e03cd846956e4a030f506fd5b908
+  metadata.gz: fbd00dab052b65ba426cdaa4ac900adc2daca2e23d1cbe5919a19e31bce30e45
+  data.tar.gz: 6757fd8be13568acb58fa6e0e5ec3ff395ab56bb14354dd6bbd024665998ff1d
 SHA512:
-  metadata.gz: 28dca6bc48b5aab85c3e08698a60e460142114623b3f914db25bbe83fa767cdd70bcb8bb4bf68d07188cc884840d696cbba81b96683d10a690d939979e0f5dfc
-  data.tar.gz: 325e58af48dc0cc6e85344ecedc006b6b331a2011432bc76069c374288bd676d2d918eee9807ee0194e8d2e31c0fe1dcbeda38b9c6a0f8982a1ea26ca0588457
+  metadata.gz: 13896d019d82fdb27003ead6dd60a34a8f2c09efb2aa018b74f520d8dbc5c79e775d5637ba66e715089221aad160dc7a00477cd0a908777ed9e5098c8eccf552
+  data.tar.gz: 3bfc72a7632226f9b67899045869fbec25a505276d5d595c5f13dc7a288924a4510d1b5e7ec69c120bff981fae887684953e6a223e481920dbf77d880c3448d1

data/.github/workflows/specs.yml

@@ -19,5 +19,5 @@ jobs:
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
-    - run: bundle install
-    - run: rake ci
+    - run: ruby -S bundle install
+    - run: ruby -S bundle exec rake ci

data/.rubocop.yml

@@ -22,6 +22,8 @@ Style/LambdaCall:
   Enabled: false
 Lint/AssignmentInCondition:
   Enabled: false
+Style/ArgumentsForwarding:
+  Enabled: false
 
 ##
 # Disabled cops (rspec)

data/README.md

@@ -16,6 +16,7 @@ method seen in the example returns an instance of
 [Ryo::Object](https://0x1eef.github.io/x/ryo.rb/Ryo/Object.html):
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 point_x = Ryo(x: 5)
@@ -35,6 +36,7 @@ will bind its `self` to the Ryo object it is assigned to, and when the function
 is called it will have access to the properties of the Ryo object:
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 point_x = Ryo(x: 5)
@@ -56,6 +58,7 @@ The following example demonstrates
 accessed for the first time. It is similar to a Ryo function:
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 point_x = Ryo(x: Ryo.memo { 5 })
@@ -87,6 +90,7 @@ is not implemented directly on a Ryo object.
 A demonstration of [`Ryo.each`](https://0x1eef.github.io/x/ryo.rb/Ryo.html#each-class_method):
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 point = Ryo(x: 10, y: 20)
@@ -115,6 +119,7 @@ and it returns a new copy of a Ryo object and its prototypes.
 A demonstration of [`Ryo.map!`](http://0x1eef.github.io/x/ryo.rb/Ryo/Enumerable.html#map!-instance_method):
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 point_x = Ryo(x: 2)
@@ -148,6 +153,7 @@ demonstrates using the `ancestors` option with
 [`Ryo.find`](https://0x1eef.github.io/x/ryo.rb/Ryo.html#find-class_method):
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 point_x = Ryo(x: 5)
@@ -167,23 +173,28 @@ p Ryo.find(point) { |k,v| v == 5 }.x # => point_x.x
 The [`Ryo.from`](https://0x1eef.github.io/x/ryo.rb/Ryo.html#from-class_method) method has
 the same interface as the [`Ryo`](https://0x1eef.github.io/x/ryo.rb/top-level-namespace.html#Ryo-instance_method)
 method, but it is implemented to recursively walk a Hash object and create Ryo objects
-from other Hash objects found along the way. Recursion is not the default behavior
-because it has the potential to be slow when given a complex Hash object that's
-very large - otherwise there shouldn't be a noticeable performance impact.
+from other Hash objects found along the way.
 
 The following example demonstrates [`Ryo.from`](https://0x1eef.github.io/x/ryo.rb/Ryo.html#from-class_method):
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
-point = Ryo.from({
-  x: {to_i: 0},
-  y: {to_i: 10}
+person = Ryo.from({
+  name: "John",
+  age: 30,
+  address: {
+    street: "123 Main St",
+    city: "Anytown",
+    state: "AS",
+    zip: 12345
+  }
 })
-p [point.x.to_i, point.y.to_i]
+p [person.name, person.age, person.address.city]
 
 ##
-# [0, 10]
+# ["John", 30, "Anytown"]
 ```
 
 #### Ryo.from with an Array
@@ -194,17 +205,18 @@ An object that can't be turned into a Ryo object is left as-is. The following
 example demonstrates how that works in practice:
 
 ``` ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 points = Ryo.from([
-  {x: {to_i: 2}},
+  {x: 2},
   "foobar",
-  {y: {to_i: 4}}
+  {y: 4}
 ])
 
-p points[0].x.to_i
+p points[0].x
 p points[1]
-p points[2].y.to_i
+p points[2].y
 
 ##
 # 2
@@ -217,18 +229,17 @@ p points[2].y.to_i
 All methods that can create Ryo objects support turning a Struct, or OpenStruct object
 into a Ryo object. The following example demonstrates how
 [`Ryo.from`](https://0x1eef.github.io/x/ryo.rb/Ryo.html#from-class_method)
-can recursively turn an OpenStruct object into Ryo objects. The example also assigns
-a prototype to the Ryo object created from the OpenStruct:
+can recursively turn an OpenStruct object into Ryo objects:
 
 ``` ruby
+#!/usr/bin/env ruby
 require "ryo"
 require "ostruct"
 
 point = Ryo.from(
-  OpenStruct.new(x: {to_i: 5}),
-  Ryo.from(y: {to_i: 10})
+  OpenStruct.new(x: 5, y: 10)
 )
-p [point.x.to_i, point.y.to_i]
+p [point.x, point.y]
 
 ##
 # [5, 10]
@@ -246,6 +257,7 @@ with fewer methods. The following example demonstrates
 how to create an instance of [Ryo::BasicObject](https://0x1eef.github.io/x/ryo.rb/Ryo/BasicObject.html):
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 point_x = Ryo::BasicObject(x: 0)
@@ -265,6 +277,7 @@ it returns instance(s) of [Ryo::BasicObject](https://0x1eef.github.io/x/ryo.rb/R
 instead:
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 point = Ryo::BasicObject.from({
@@ -281,18 +294,21 @@ p [point.x.to_i, point.y.to_i]
 
 #### Resolution strategy
 
-When a property and method collide, Ryo tries to find the best resolution. Since Ryo properties
-don't accept arguments, and methods can - we are able to distinguish a property from a method in
-many cases.
-
-Consider this example, where a property collides with the `Kernel#then` method. This example
-would work the same for other methods that accept a block and/or arguments:
+When a property and method collide, Ryo tries to
+find the best resolution. Because Ryo properties don't
+accept arguments, and methods can - we can distinguish a
+method from a Ryo property by the presence or absence of
+an argument in at least some cases. Consider the following
+example, where a property collides with the `Kernel#then` method:
 
 ```ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 ryo = Ryo::Object(then: 12)
+# Resolves to Ryo property
 p ryo.then # => 12
+# Resolves to Kernel#then
 p ryo.then { 34 } # => 34
 ```
 
@@ -300,10 +316,12 @@ p ryo.then { 34 } # => 34
 
 #### Duck typing
 
-The documentation has used simple terms to describe the objects that Ryo works
-with: Hash and Array objects. But that doesn't quite capture the fact that Ryo
-uses duck typing: any object that implements `#each_pair` is similar to a Hash,
-and any object that implements `#each` is similar to an Array. Note that only
+The documentation has used simple terms to describe
+the objects that Ryo works with: Hash and Array objects.
+But that doesn't quite capture that Ryo is implemented with
+duck typing: any object that implements `#each_pair`
+could be used instead of a Hash, and any object that
+implements `#each` could be used instead of an Array. Note that only
 [Ryo.from](https://0x1eef.github.io/x/ryo.rb/Ryo.html#from-class_method),
 [Ryo::Object.from](https://0x1eef.github.io/x/ryo.rb/Ryo/Object.html#from-class_method)
 and
@@ -313,6 +331,7 @@ can handle Array-like objects.
 The following example implements `#each_pair`:
 
 ``` ruby
+#!/usr/bin/env ruby
 require "ryo"
 
 class Point

data/lib/ryo/basic_object.rb

@@ -10,33 +10,30 @@ class Ryo::BasicObject < BasicObject
   ##
   # @param props (see Ryo::Builder.build)
   # @param prototype (see Ryo::Builder.build)
-  #
   # @return [Ryo::BasicObject]
-  #  Returns an instance of {Ryo::BasicObject Ryo::BasicObject}.
+  #  Returns an instance of {Ryo::BasicObject Ryo::BasicObject}
   def self.create(props, prototype = nil)
     ::Ryo::Builder.build(self, props, prototype)
   end
 
   ##
-  # Creates a Ryo object by recursively walking a Hash object.
+  # Creates a Ryo object by recursively walking a Hash object
   #
   # @param props (see Ryo::Builder.recursive_build)
   # @param prototype (see Ryo::Builder.recursive_build)
-  #
   # @return [Ryo::BasicObject]
-  #  Returns an instance of {Ryo::BasicObject Ryo::BasicObject}.
+  #  Returns an instance of {Ryo::BasicObject Ryo::BasicObject}
   def self.from(props, prototype = nil)
     ::Ryo::Builder.recursive_build(self, props, prototype)
   end
 
   ##
-  # Duplicates the internals of a Ryo object.
+  # Duplicates the internals of a Ryo object
   #
   # @param [Ryo::BasicObject] ryo
-  #  A Ryo object.
-  #
+  #  A Ryo object
   # @return [Ryo::BasicObject]
-  #  Returns a Ryo object.
+  #  Returns a Ryo object
   def initialize_dup(ryo)
     ::Ryo.set_table_of(self, ::Ryo.table_of(ryo).dup)
     ::Ryo.extend!(self, ::Ryo)
@@ -50,9 +47,8 @@ end
 #
 # @param props (see Ryo::Builder.build)
 # @param prototype (see Ryo::Builder.build)
-#
 # @return [Ryo::BasicObject]
-#   Returns an instance of {Ryo::BasicObject Ryo::BasicObject}.
+#   Returns an instance of {Ryo::BasicObject Ryo::BasicObject}
 def Ryo.BasicObject(props, prototype = nil)
   Ryo::BasicObject.create(props, prototype)
 end

data/lib/ryo/builder.rb

@@ -1,29 +1,21 @@
 # frozen_string_literal: true
 
 ##
-# {Ryo::Builder Ryo::Builder} is a module that's used underneath Ryo's public
-# interface when creating instances of {Ryo::Object Ryo::Object}, and
-# {Ryo::BasicObject Ryo::BasicObject}. This module is not intended to be
-# used directly.
-#
+# The {Ryo::Builder Ryo::Builder} module is responsible for
+# the creation of instances of {Ryo::Object Ryo::Object},
+# and {Ryo::BasicObject Ryo::BasicObject}. This module is
+# not intended to be used directly.
 # @api private
 module Ryo::Builder
   ##
+  # @note
+  #  When "props" is given as a Ryo object, a duplicate Ryo object is
+  #  returned in its place
   # @param [<Ryo::Object, Ryo::BasicObject>] buildee
-  #  The class of the object to build.
-  #
-  # @param [<Hash, Ryo::Object, Ryo::BasicObject, #each_pair>] props
-  #  A Hash object, an object that implements "#each_pair", or a Ryo object.
-  #
+  # @param [<#each_pair>] props
   # @param [<Ryo::Object, Ryo::BasicObject>, nil] prototype
-  #  The prototype, or nil for none.
-  #
   # @return [<Ryo::Object, Ryo::BasicObject>]
-  #  Returns a Ryo object.
-  #
-  # @note
-  #  When "props" is given as a Ryo object, a duplicate Ryo object is
-  #  returned in its place.
+  #  Returns a Ryo object
   def self.build(buildee, props, prototype = nil)
     if Ryo.ryo?(props)
       build(buildee, Ryo.table_of(props), prototype || Ryo.prototype_of(props))
@@ -38,7 +30,8 @@ module Ryo::Builder
   end
 
   ##
-  # Creates a Ryo object by recursively walking a Hash object, or an Array of Hash objects.
+  # Creates a Ryo object by recursively walking a Hash object, or
+  # an Array of Hash objects
   #
   # @example
   #   objects = Ryo.from([{x: 0, y: 0}, "foo", {point: {x: 0, y: 0}}])
@@ -46,22 +39,13 @@ module Ryo::Builder
   #   objects[1]         # => "foo"
   #   objects[2].point.x # => 0
   #
-  # @param buildee (see Ryo::Builder.build)
-  #
-  # @param [<Hash, Ryo::Object, Ryo::BasicObject, Array, #each_pair, #each> ] props
-  #   A Hash object, a Ryo object, or an array composed of either Hash / Ryo objects.
-  #
-  # @param prototype (see Ryo::Builder.build)
-  #
+  # @note (see Ryo::Builder.build)
+  # @param (see Ryo::Builder.build)
   # @return (see Ryo::Builder.build)
-  #
-  # @note
-  #  When "props" is given as a Ryo object, a duplicate Ryo object is
-  #  returned in its place.
   def self.recursive_build(buildee, props, prototype = nil)
     if Ryo.ryo?(props)
       recursive_build(buildee, Ryo.table_of(props), prototype || Ryo.prototype_of(props))
-    elsif eachless?(props)
+    elsif !respond_to_each?(props)
       raise TypeError, "The provided object does not implement #each / #each_pair"
     elsif !props.respond_to?(:each_pair)
       map(props) do
@@ -75,32 +59,29 @@ module Ryo::Builder
     end
   end
 
-  ##
-  # @private
-  def self.map_value(buildee, value)
-    if Ryo.ryo?(value) || eachless?(value)
-      value
-    elsif value.respond_to?(:each_pair)
-      recursive_build(buildee, value)
-    elsif value.respond_to?(:each)
-      map(value) { map_value(buildee, _1) }
+  module Private
+    private
+
+    def map_value(buildee, value)
+      if Ryo.ryo?(value) || !respond_to_each?(value)
+        value
+      elsif value.respond_to?(:each_pair)
+        recursive_build(buildee, value)
+      elsif value.respond_to?(:each)
+        map(value) { map_value(buildee, _1) }
+      end
     end
-  end
-  private_class_method :map_value
 
-  ##
-  # @private
-  def self.eachless?(value)
-    !value.respond_to?(:each) && !value.respond_to?(:each_pair)
-  end
-  private_class_method :eachless?
+    def respond_to_each?(value)
+      value.respond_to?(:each) || value.respond_to?(:each_pair)
+    end
 
-  ##
-  # @private
-  def self.map(obj)
-    ary = []
-    obj.each { ary.push(yield(_1)) }
-    ary
+    def map(obj)
+      ary = []
+      obj.each { ary.push(yield(_1)) }
+      ary
+    end
   end
-  private_class_method :map
+  private_constant :Private
+  extend Private
 end

data/lib/ryo/enumerable.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
 ##
-# The {Ryo::Enumerable Ryo::Enumerable} module implements methods
-# for iterating through and performing operations on Ryo objects.
-# The methods implemented by this module are available as singleton
-# methods on the {Ryo} module.
+# The {Ryo::Enumerable Ryo::Enumerable} module provides methods
+# that are similar to Ruby's Enumerable module, and at the same
+# time - intentionally different.
+#
+# For example: {Ryo::Enumerable Ryo::Enumerable}
+# methods receive 'self' as an argument rather than from the
+# surrounding context. The methods implemented by this
+# module are available as singleton methods on the {Ryo Ryo}
+# module.
 module Ryo::Enumerable
   ##
-  # The {#each} methods iterates a Ryo object, and yields a key / value pair.
-  # When a block is not given, {#each} returns an Enumerator.
+  # The {#each} method iterates through a Ryo object, and
+  # yields two parameters: a key, and a value
   #
   # @example
   #  point_a = Ryo(x: 1, y: 2)
@@ -18,23 +23,19 @@ module Ryo::Enumerable
   #  # ["y", 2]
   #  # ["x", 1]
   #
-  # @param [Ryo::Object, Ryo::BasicObject] ryo
-  #  A Ryo object.
-  #
-  # @param ancestors (see #each_ryo)
-  #
+  # @param (see #each_ryo)
   # @return [<Enumerator, Array>]
-  #  Returns an Enumerator when a block is not given, otherwise returns an Array.
   def each(ryo, ancestors: nil)
     return enum_for(:each, ryo) unless block_given?
-    each_ryo(ryo, ancestors: ancestors) do |_, key, value|
+    each_ryo(ryo, ancestors:) do |_, key, value|
       yield(key, value)
     end
   end
 
   ##
-  # The {#each_ryo} method iterates through a Ryo object, and its prototypes.
-  # {#each_ryo} yields three parameters: a Ryo object, a key, and a value.
+  # The {#each_ryo} method iterates through a Ryo object,
+  # and its prototypes. {#each_ryo} yields three parameters:
+  # a Ryo object, a key, and a value
   #
   # @example
   #  point_a = Ryo(x: 1, y: 2)
@@ -45,15 +46,13 @@ module Ryo::Enumerable
   #  # [point_a, "y", 2]
   #
   # @param [<Ryo::BasicObject, Ryo::Object>] ryo
-  #  A Ryo object.
-  #
   # @param [Integer] ancestors
-  #   `ancestors` is an integer that determines how far up the prototype chain a
-  #   {Ryo::Enumerable Ryo::Enumerable}  method can go. 0 covers a Ryo object,
-  #   and none of the prototypes in its prototype chain. 1 covers a Ryo object,
-  #   and one of the prototypes in its prototype chain - and so on. The default
-  #   behavior is to traverse the entire prototype chain.
-  #
+  #  "ancestors" is an integer that defines the traversal depth
+  #  of a {Ryo::Enumerable Ryo::Enumerable} method. 0 covers a
+  #  Ryo object, and none of the prototypes in its prototype
+  #  chain. 1 covers a Ryo object, and one of the prototypes
+  #  in its prototype chain - and so on. The default covers
+  #  the entire prototype chain.
   # @return [<Ryo::BasicObject, Ryo::Object>]
   def each_ryo(ryo, ancestors: nil)
     proto_chain = [ryo, *prototype_chain_of(ryo)]
@@ -67,17 +66,19 @@ module Ryo::Enumerable
   end
 
   ##
-  # The {#map} method creates a copy of a Ryo object, and then performs a map operation
-  # on the copy and its prototypes.
+  # The {#map} method creates a copy of a Ryo object,
+  # and then performs a map operation on the copy and
+  # its prototypes
   #
-  # @param (see #map!)
-  # @return (see #map!)
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
   def map(ryo, ancestors: nil, &b)
-    map!(Ryo.dup(ryo), ancestors: ancestors, &b)
+    map!(Ryo.dup(ryo), ancestors:, &b)
   end
 
   ##
-  # The {#map!} method performs an in-place map operation on a Ryo object, and its prototypes.
+  # The {#map!} method performs an in-place map operation
+  # on a Ryo object, and its prototypes
   #
   # @example
   #  point = Ryo(x: 2, y: 4)
@@ -85,31 +86,28 @@ module Ryo::Enumerable
   #  [point.x, point.y]
   #  # => [4, 8]
   #
-  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
-  #  A Ryo object.
-  #
-  # @param ancestors (see #each_ryo)
-  #
+  # @param (see #each_ryo)
   # @return [<Ryo::Object, Ryo::BasicObject>]
   def map!(ryo, ancestors: nil)
-    each_ryo(ryo, ancestors: ancestors) do |ryo, key, value|
+    each_ryo(ryo, ancestors:) do |ryo, key, value|
       ryo[key] = yield(key, value)
     end
   end
 
   ##
-  # The {#select} method creates a copy of a Ryo object, and then performs a filter operation
-  # on the copy and its prototypes.
+  # The {#select} method creates a copy of a Ryo object, and
+  # then performs a filter operation on the copy and its
+  # prototypes
   #
-  # @param (see #select!)
-  # @return (see #select!)
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
   def select(ryo, ancestors: nil, &b)
-    select!(Ryo.dup(ryo), ancestors: ancestors, &b)
+    select!(Ryo.dup(ryo), ancestors:, &b)
   end
 
   ##
-  # The {#select!} method performs an in-place filter operation on a Ryo object, and
-  # its prototypes.
+  # The {#select!} method performs an in-place filter operation
+  # on a Ryo object, and its prototypes
   #
   # @example
   #  point_a = Ryo(x: 1, y: 2, z: 3)
@@ -118,31 +116,27 @@ module Ryo::Enumerable
   #  [point_b.x, point_b.y, point_b.z]
   #  # => [1, 2, nil]
   #
-  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
-  #  A Ryo object.
-  #
-  # @param ancestors (see #each_ryo)
-  #
+  # @param (see #each_ryo)
   # @return [<Ryo::Object, Ryo::BasicObject>]
   def select!(ryo, ancestors: nil)
-    each_ryo(ryo, ancestors: ancestors) do |ryo, key, value|
+    each_ryo(ryo, ancestors:) do |ryo, key, value|
       delete(ryo, key) unless yield(key, value)
     end
   end
 
   ##
-  # The {#reject} method creates a copy of a Ryo object, and then performs a filter operation
-  # on the copy and its prototypes.
+  # The {#reject} method creates a copy of a Ryo object, and then
+  # performs a filter operation on the copy and its prototypes
   #
-  # @param (see #reject!)
-  # @return (see #reject!)
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
   def reject(ryo, ancestors: nil, &b)
-    reject!(Ryo.dup(ryo), ancestors: ancestors, &b)
+    reject!(Ryo.dup(ryo), ancestors:, &b)
   end
 
   ##
-  # The {#reject!} method performs an in-place filter operation on a Ryo object, and
-  # its prototypes.
+  # The {#reject!} method performs an in-place filter operation
+  # on a Ryo object, and its prototypes
   #
   # @example
   #  point_a = Ryo(x: 1, y: 2, z: 3)
@@ -151,51 +145,39 @@ module Ryo::Enumerable
   #  [point_b.x, point_b.y, point_b.z]
   #  # => [1, 2, nil]
   #
-  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
-  #  A Ryo object.
-  #
-  # @param ancestors (see #each_ryo)
-  #
+  # @param (see #each_ryo)
   # @return [<Ryo::Object, Ryo::BasicObject>]
   def reject!(ryo, ancestors: nil)
-    each_ryo(ryo, ancestors: ancestors) do |ryo, key, value|
+    each_ryo(ryo, ancestors:) do |ryo, key, value|
       delete(ryo, key) if yield(key, value)
     end
   end
 
   ##
-  # The {#any?} method iterates through a Ryo object, and its prototypes - yielding a
-  # key / value pair to a block. If the block ever returns a truthy value, {#any?} will
-  # break from the iteration and return true - otherwise false will be returned.
-  #
-  # @param ancestors (see #each_ryo)
+  # @param (see #each_ryo)
   # @return [Boolean]
+  #  Returns true when the given block evaluates to
+  #  a truthy value for at least one iteration
   def any?(ryo, ancestors: nil)
-    each_ryo(ryo, ancestors: ancestors) do |_, key, value|
+    each_ryo(ryo, ancestors:) do |_, key, value|
       return true if yield(key, value)
     end
     false
   end
 
   ##
-  # The {#all?} method iterates through a Ryo object, and its prototypes - yielding a
-  # key / value pair to a block. If the block ever returns a falsey value, {#all?} will
-  # break from the iteration and return false - otherwise true will be returned.
-  #
-  # @param ancestors (see #each_ryo)
+  # @param (see #each_ryo)
   # @return [Boolean]
+  #  Returns true when the given block evaluates to a
+  #  truthy value for every iteration
   def all?(ryo, ancestors: nil)
-    each_ryo(ryo, ancestors: ancestors) do |_, key, value|
+    each_ryo(ryo, ancestors:) do |_, key, value|
       return false unless yield(key, value)
     end
     true
   end
 
   ##
-  # The {#find} method iterates through a Ryo object, and its prototypes - yielding a
-  # key / value pair to a block. If the block ever returns a truthy value, {#find} will
-  # break from the iteration and return a Ryo object - otherwise nil will be returned.
-  #
   # @example
   #  point_a = Ryo(x: 5)
   #  point_b = Ryo({y: 10}, point_a)
@@ -203,10 +185,11 @@ module Ryo::Enumerable
   #  ryo = Ryo.find(point_c) { |key, value| value == 5 }
   #  ryo == point_a # => true
   #
-  # @param ancestors (see #each_ryo)
+  # @param (see #each_ryo)
   # @return [<Ryo::Object, Ryo::BasicObject>, nil]
+  #  Returns a Ryo object, or nil
   def find(ryo, ancestors: nil)
-    each_ryo(ryo, ancestors: ancestors) do |ryo, key, value|
+    each_ryo(ryo, ancestors:) do |ryo, key, value|
       return ryo if yield(key, value)
     end
     nil