ryo.rb 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c611c0e990fe0cdfd09ede551e1b457e93af7765de379d64b5dbdf6495e2b766
-  data.tar.gz: 24406b552991b2459da63847ff4b65071eb2e03cd846956e4a030f506fd5b908
+  metadata.gz: ae979c4fc47c5c25d26b0c215807a7ebd867dc5abd596277dda692c36c5c3445
+  data.tar.gz: 3cf89103180d9d6280698b93520eb80dc9af2e3ff4cbebb84c54b1089bed12e6
 SHA512:
-  metadata.gz: 28dca6bc48b5aab85c3e08698a60e460142114623b3f914db25bbe83fa767cdd70bcb8bb4bf68d07188cc884840d696cbba81b96683d10a690d939979e0f5dfc
-  data.tar.gz: 325e58af48dc0cc6e85344ecedc006b6b331a2011432bc76069c374288bd676d2d918eee9807ee0194e8d2e31c0fe1dcbeda38b9c6a0f8982a1ea26ca0588457
+  metadata.gz: 795a2ab471038483d47fa39103996ec756da3437098b27091bb3b6e1f6534202ebc508e33f8d38bda4dfee8ae835465947da0c8adb2c13805480f13b4f54f4fe
+  data.tar.gz: edd4fd919629134e9479a91469084dbbdaf5507ce6aef91b7e1779720bff76ad1aec675dd31de42a05c7a8375d4c0ca27ce5aba260059b18fa526ec755bc7a0a

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)
@@ -174,6 +180,7 @@ very large - otherwise there shouldn't be a noticeable performance impact.
 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({
@@ -194,6 +201,7 @@ 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([
@@ -221,6 +229,7 @@ can recursively turn an OpenStruct object into Ryo objects. The example also ass
 a prototype to the Ryo object created from the OpenStruct:
 
 ``` ruby
+#!/usr/bin/env ruby
 require "ryo"
 require "ostruct"
 
@@ -246,6 +255,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 +275,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 +292,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. Since Ryo properties don't
+accept arguments, and methods can - we are able to
+distinguish a method from a Ryo property by the presence
+or absence of an argument. 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 +314,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 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
 [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 +329,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

data/lib/ryo/object.rb

@@ -10,19 +10,17 @@ class Ryo::Object
   ##
   # @param props (see Ryo::Builder.build)
   # @param prototype (see Ryo::Builder.build)
-  #
   # @return [Ryo::Object]
-  #  Returns an instance of {Ryo::Object Ryo::Object}.
+  #  Returns an instance of {Ryo::Object Ryo::Object}
   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::Object]
   #  Returns an instance of {Ryo::Object Ryo::Object}.
   def self.from(props, prototype = nil)
@@ -30,13 +28,12 @@ class Ryo::Object
   end
 
   ##
-  # Duplicates the internals of a Ryo object.
+  # Duplicates the internals of a Ryo object
   #
   # @param [Ryo::Object] ryo
-  #  A Ryo object.
-  #
+  #  A Ryo object
   # @return [Ryo::Object]
-  #  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::Object]
-#   Returns an instance of {Ryo::Object Ryo::Object}.
+#   Returns an instance of {Ryo::Object Ryo::Object}
 def Ryo.Object(props, prototype = nil)
   Ryo::Object.create(props, prototype)
 end