ryo.rb 0.4.4

data/lib/ryo/reflect.rb

@@ -0,0 +1,379 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::Reflect Ryo::Reflect} module implements equivalents
+# from JavaScript's [`Relfect` object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect),
+# and equivalents for some of the static methods on JavaScript's
+# [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) constructor.
+#
+# This module also implements Ryo-specific reflection features as well. The
+# instance methods of this module are available as singleton methods
+# on the {Ryo Ryo} module.
+module Ryo::Reflect
+  extend self
+
+  ##
+  # @group JavaScript equivalents (Reflect)
+
+  ##
+  # Equivalent to JavaScript's `Reflect.getPrototypeOf`.
+  #
+  # @param [Ryo] ryo
+  #  A Ryo object.
+  #
+  # @return [Ryo, nil]
+  #  Returns the prototype of the *ryo* object.
+  def prototype_of(ryo)
+    kernel(:instance_variable_get)
+      .bind_call(ryo, :@_proto)
+  end
+
+  ##
+  # Equivalent to JavaScript's `Reflect.setPrototypeOf`.
+  #
+  # @param [Ryo] ryo
+  #  A Ryo object.
+  #
+  # @param [Ryo] prototype
+  #  The prototype to assign to *ryo*.
+  #
+  # @return [nil]
+  def set_prototype_of(ryo, prototype)
+    kernel(:instance_variable_set)
+      .bind_call(ryo, :@_proto, prototype)
+    nil
+  end
+
+  ##
+  # Equivalent to JavaScript's `Reflect.defineProperty`.
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [<String, #to_s>] property
+  #  The name of the property.
+  #
+  # @param [Object, BasicObject] value
+  #  The value of the property.
+  #
+  # @return [void]
+  def define_property(ryo, property, value)
+    table, property = table_of(ryo), property.to_s
+    kernel(:tap).bind_call(value) { _1.bind!(ryo) if function?(_1) }
+    table[property] = value
+    # Define setter
+    if !setter_defined?(ryo, property) && property[-1] != "?"
+      define_method!(ryo, "#{property}=") { ryo[property] = _1 }
+    end
+    # Define getter
+    return if getter_defined?(ryo, property)
+    define_method!(ryo, property) { |*args, &b|
+      (args.empty? && b.nil?) ? ryo[property] :
+                              super(*args, &b)
+    }
+    nil
+  end
+
+  ##
+  # Equivalent to JavaScript's `Reflect.ownKeys`, and
+  # JavaScript's `Object.keys`.
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @return [Array<String>]
+  #  Returns the properties defined on a Ryo object.
+  def properties_of(ryo)
+    table_of(ryo).keys
+  end
+
+  # @endgroup
+
+  ##
+  # @group JavaScript equivalents (Object)
+
+  ##
+  # Equivalent to JavaScript's `Object.hasOwn`,
+  # and `Object.prototype.hasOwnProperty`.
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [<String, #to_s>] property
+  #  A property name.
+  #
+  # @return [Boolean]
+  #  Returns true when **property** is a member of a Ryo object.
+  def property?(ryo, property)
+    table_of(ryo).key?(property.to_s)
+  end
+
+  ##
+  # Equivalent to JavaScript's `Object.assign`.
+  #
+  #
+  # @param [Ryo, Hash, #to_hash] target
+  #  The target object.
+  #
+  # @param [Ryo, Hash, #to_hash] sources
+  #  A variable number of source objects that
+  #  will be merged into the target object.
+  #
+  # @return [Ryo]
+  #  Returns the modified target object.
+  def assign(target, *sources)
+    sources.each do |source|
+      to_hash(source).each { target[_1.to_s] = _2 }
+    end
+    target
+  end
+  # @endgroup
+
+  ##
+  # @group Ryo-specific
+
+  ##
+  # The {#delete!} method deletes a property from a Ryo object,
+  # and from the prototypes in its prototype chain.
+  #
+  # @see Ryo::Keywords#delete
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [<String, #to_s>] property
+  #  A property name.
+  #
+  # @return [void]
+  def delete!(ryo, property)
+    [ryo, *prototype_chain_of(ryo)].each do
+      Ryo.delete(_1, property.to_s)
+    end
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @return [Array<Ryo::Object, Ryo::BasicObject>]
+  #  Returns the prototype chain of a Ryo object.
+  def prototype_chain_of(ryo)
+    prototypes = []
+    loop do
+      ryo = prototype_of(ryo)
+      break unless ryo
+      prototypes.push(ryo)
+    end
+    prototypes
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [Boolean] recursive
+  #  When true, nested Ryo objects are replaced by
+  #  their table as well.
+  #
+  # @return [Hash]
+  #  Returns the table of a Ryo object.
+  def table_of(ryo, recursive: false)
+    table = kernel(:instance_variable_get).bind_call(ryo, :@_table)
+    if recursive
+      table.each do |key, value|
+        if ryo?(value)
+          table[key] = table_of(value, recursive:)
+        end
+      end
+    end
+    table
+  end
+
+  ##
+  # Sets the table of a Ryo object.
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [Hash] table
+  #  The table to assign to a Ryo object.
+  #
+  # @return [nil]
+  def set_table_of(ryo, table)
+    kernel(:instance_variable_set)
+      .bind_call(ryo, :@_table, table)
+    nil
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [<String, Symbol>] method
+  #  The name of a method.
+  #
+  # @param [::Object, ::BasicObject] args
+  #  Zero or more arguments to call **method** with.
+  #
+  # @param [Proc] b
+  #  An optional block to pass to **method**.
+  #
+  # @return [::Object, ::BasicObject]
+  #  Returns the return value of the method call.
+  def call_method(ryo, method, *args, &b)
+    kernel(:__send__)
+      .bind_call(ryo, method, *args, &b)
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @return [Class]
+  #  Returns the class of a Ryo object.
+  def class_of(ryo)
+    kernel(:class).bind_call(ryo)
+  end
+
+  ##
+  # @param [Ryo::Function, Object, BasicObject] obj
+  #  An object.
+  #
+  # @return [Boolean]
+  #  Returns true when the given object is a Ryo function.
+  def function?(obj)
+    Ryo::Function === obj
+  end
+
+  ##
+  # @param [Ryo::Function, Object, BasicObject] obj
+  #  An object.
+  #
+  # @return [Boolean]
+  #  Returns true when the given object is an instance
+  #  of {Ryo::Lazy Ryo::Lazy}.
+  def lazy?(obj)
+    Ryo::Lazy === obj
+  end
+
+  ##
+  # @example
+  #  Ryo.ryo?(Ryo::Object(x: 5, y: 12))       # => true
+  #  Ryo.ryo?(Ryo::BasicObject(x: 10, y: 20)) # => true
+  #  Ryo.ryo?(Object.new) # => false
+  #
+  # @param [Object, BasicObject] obj
+  #  An object.
+  #
+  # @return [Boolean]
+  #  Returns true when the given object is a Ryo object.
+  def ryo?(obj)
+    Ryo === obj
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo1
+  #  A Ryo object.
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo2
+  #  A Ryo object.
+  #
+  # @return [Boolean]
+  #  Returns true when two Ryo objects are the same object.
+  def equal?(ryo1, ryo2)
+    kernel(:equal?).bind_call(ryo1, ryo2)
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @return [String]
+  #  Returns a String representation of a Ryo object.
+  def inspect_object(ryo)
+    format(
+      "#<Ryo object=%{object} proto=%{proto} table=%{table}>",
+      object: Object.instance_method(:to_s).bind_call(ryo),
+      proto: prototype_of(ryo).inspect,
+      table: table_of(ryo).inspect
+    )
+  end
+  # @endgroup
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [<String, Symbol>] method
+  #  The name of the method.
+  #
+  # @param [Proc] b
+  #  The method's body.
+  #
+  # @private
+  private def define_method!(ryo, method, &b)
+    kernel(:define_singleton_method)
+      .bind_call(ryo, method, &b)
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [<String, #to_s>] property
+  #  The name of the property.
+  #
+  # @return [Boolean]
+  #  Returns true when the property has been
+  #  defined with a getter method.
+  #
+  # @private
+  private def getter_defined?(ryo, property)
+    kernel(:method)
+      .bind_call(ryo, property)
+      .source_location
+      &.dig(0) == __FILE__
+  end
+
+  ##
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [<String, #to_s>] property
+  #  The name of the property.
+  #
+  # @return [Boolean]
+  #  Returns true when the property has been
+  #  defined with a setter method.
+  #
+  # @private
+  private def setter_defined?(ryo, property)
+    getter_defined?(ryo, "#{property}=")
+  end
+
+  ##
+  # @private
+  private def merge!(obj1, obj2)
+    obj1, obj2 = to_hash(obj1), to_hash(obj2)
+    obj2.each { obj1[_1.to_s] = _2 }
+    obj1
+  end
+
+  ##
+  # @private
+  private def to_hash(obj)
+    if ryo?(obj)
+      table_of(obj)
+    else
+      Hash.try_convert(obj)
+    end
+  end
+
+  ##
+  # @private
+  def kernel(name)
+    Module.instance_method(name)
+  end
+  # @endgroup
+end

data/lib/ryo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ryo
+  VERSION = "0.4.4"
+end

data/lib/ryo.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo Ryo} module implements most of its behavior as singleton methods
+# that are inherited from the {Ryo::Reflect Ryo::Reflect}, and
+# {Ryo::Keywords Ryo:Keywords} modules.
+#
+# @example
+#   # Ryo.delete
+#   point = Ryo(x: 0, y: 0)
+#   Ryo.delete(point, "x")
+#   point.x # => nil
+#
+#   # Ryo.assign
+#   point = Ryo.assign(Ryo({}), {x: 0}, {y: 0})
+#   point.x # => 0
+module Ryo
+  require_relative "ryo/reflect"
+  require_relative "ryo/keywords"
+  require_relative "ryo/builder"
+  require_relative "ryo/basic_object"
+  require_relative "ryo/object"
+  require_relative "ryo/function"
+  require_relative "ryo/lazy"
+  require_relative "ryo/enumerable"
+
+  extend Ryo::Reflect
+  extend Ryo::Keywords
+  extend Ryo::Enumerable
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @param [Module] mod
+  #  A module to extend a Ryo object with.
+  #
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  #  Returns a Ryo object extended by **mod**.
+  def self.extend!(ryo, mod)
+    kernel(:extend).bind_call(ryo, mod)
+  end
+
+  ##
+  # Duplicates a Ryo object, and its prototype(s).
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  #  Returns a duplicated Ryo object.
+  def self.dup(ryo)
+    duplicate = extend!(
+      kernel(:dup).bind_call(ryo),
+      self
+    )
+    if proto = prototype_of(duplicate)
+      set_prototype_of(duplicate, dup(proto))
+    end
+    duplicate
+  end
+
+  ##
+  # Creates a lazy Ryo value.
+  #
+  # @param [Proc] b
+  #  A proc that is evaluated when a property is first accessed.
+  #
+  # @return [Ryo::Lazy]
+  #  Returns an instance of {Ryo::Lazy Ryo::Lazy}.
+  def self.lazy(&b)
+    Ryo::Lazy.new(&b)
+  end
+
+  ##
+  # Creates a Ryo object by recursively walking a Hash object.
+  #
+  # @param props (see Ryo::Builder.build)
+  # @param prototype (see Ryo::Builder.build)
+  #
+  # @return [Ryo::Object]
+  #  Returns an instance of {Ryo::Object Ryo::Object}.
+  def self.from(props, prototype = nil)
+    Ryo::Object.from(props, prototype)
+  end
+
+  ##
+  # Returns the prototype of self, or "nil" if self has no prototype.
+  #
+  # @return [<Ryo::Object, Ryo::BasicObject>, nil]
+  def __proto__
+    @_proto
+  end
+
+  ##
+  # @param [String] property
+  #  A property name.
+  #
+  # @return [<Object, BasicObject>, nil]
+  #  Returns the value at **property**, or nil.
+  #
+  # @note
+  #  This method will first try to read **property** from self, and if
+  #  it is not found on self the chain of prototypes will be traversed
+  #  through instead.
+  def [](property)
+    property = property.to_s
+    if Ryo.property?(self, property)
+      v = @_table[property]
+      Ryo.lazy?(v) ? self[property] = v.call : v
+    else
+      return unless @_proto
+      Ryo.call_method(@_proto, property)
+    end
+  end
+
+  ##
+  # Assigns a property to self.
+  #
+  # @param [String] property
+  #  A property name.
+  #
+  # @param [<Object,BasicObject>] value
+  #  The value.
+  #
+  # @return [void]
+  def []=(property, value)
+    Ryo.define_property(self, property.to_s, value)
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>, Hash, #to_h] other
+  #  An object to compare against.
+  #
+  # @return [Boolean]
+  #  Returns true **other** is equal to self.
+  def ==(other)
+    if Ryo.ryo?(other)
+      @_table == Ryo.table_of(other)
+    else
+      other = Hash.try_convert(other)
+      return false unless other
+      @_table == other.map { [_1.to_s, _2] }.to_h
+    end
+  end
+  alias_method :eql?, :==
+
+  ##
+  # @return [String]
+  #  Returns a String representation of a Ryo object.
+  def inspect
+    Ryo.inspect_object(self)
+  end
+
+  ##
+  # @private
+  def pretty_print(q)
+    q.text(inspect)
+  end
+
+  ##
+  # @private
+  def respond_to?(property, include_all = false)
+    respond_to_missing?(property, include_all)
+  end
+
+  ##
+  # @private
+  def respond_to_missing?(property, include_all = false)
+    true
+  end
+
+  ##
+  # @private
+  def method_missing(name, *args, &b)
+    property = name.to_s
+    if property[-1] == "="
+      property = property[0..-2]
+      self[property] = args.first
+    elsif Ryo.property?(self, property)
+      self[property]
+    elsif @_proto
+      Ryo.call_method(@_proto, name, *args, &b)
+         .tap { _1.bind!(self) if Ryo.function?(_1) }
+    end
+  end
+end
+
+##
+# @param props (see Ryo::Builder.build)
+# @param prototype (see Ryo::Builder.build)
+#
+# @return [Ryo::Object]
+#  Returns a Ryo object.
+def Ryo(props, prototype = nil)
+  Ryo::Object.create(props, prototype)
+end

data/ryo.rb.gemspec

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "./lib/ryo/version"
+Gem::Specification.new do |gem|
+  gem.name = "ryo.rb"
+  gem.authors = ["0x1eef"]
+  gem.email = ["0x1eef@protonmail.com"]
+  gem.homepage = "https://github.com/0x1eef/ryo.rb#readme"
+  gem.version = Ryo::VERSION
+  gem.licenses = ["MIT"]
+  gem.files = `git ls-files`.split($/)
+  gem.require_paths = ["lib"]
+  gem.description = "Ryo implements prototype-based inheritance, in Ruby."
+  gem.summary = gem.description
+  gem.add_development_dependency "yard", "~> 0.9"
+  gem.add_development_dependency "redcarpet", "~> 3.5"
+  gem.add_development_dependency "rspec", "~> 3.10"
+  gem.add_development_dependency "rubocop-rspec", "~> 2.12"
+  gem.add_development_dependency "standard", "~> 1.9"
+  gem.add_development_dependency "test-cmd.rb", "~> 0.4"
+end

data/share/ryo.rb/examples/1.0_prototypes_point_object.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+point_x = Ryo(x: 5)
+point_y = Ryo({y: 10}, point_x)
+point = Ryo({}, point_y)
+p [point.x, point.y]
+
+##
+# [5, 10]

data/share/ryo.rb/examples/1.1_prototypes_ryo_fn.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+point_x = Ryo(x: 5)
+point_y = Ryo({y: 10}, point_x)
+point = Ryo({
+  multiply: Ryo.fn { |m| [x * m, y * m] }
+}, point_y)
+p point.multiply.call(2)
+
+##
+# [10, 20]

data/share/ryo.rb/examples/2.0_iteration_each.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+point = Ryo(x: 10, y: 20)
+Ryo.each(point) do |key, value|
+  p [key, value]
+end
+
+##
+# ["x", 10]
+# ["y", 20]

data/share/ryo.rb/examples/2.1_iteration_map.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+point_x = Ryo(x: 2)
+point_y = Ryo({y: 4}, point_x)
+point = Ryo({}, point_y)
+
+Ryo.map!(point) { |key, value| value * 2 }
+p [point.x, point.y]
+p [point_x.x, point_y.y]
+
+##
+# [4, 8]
+# [4, 8]

data/share/ryo.rb/examples/2.2_iteration_ancestors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+point_x = Ryo(x: 5)
+point_y = Ryo({y: 10}, point_x)
+point = Ryo({}, point_y)
+
+p Ryo.find(point, ancestors: 0) { |k,v| v == 5 }   # => nil
+p Ryo.find(point, ancestors: 1) { |k,v| v == 5 }   # => nil
+p Ryo.find(point, ancestors: 2) { |k,v| v == 5 }.x # => point_x.x
+p Ryo.find(point) { |k,v| v == 5 }.x # => point_x.x

data/share/ryo.rb/examples/3.0_recursion_ryo_from.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+point = Ryo.from({
+  x: {to_i: 0},
+  y: {to_i: 10}
+})
+p [point.x.to_i, point.y.to_i]
+
+##
+# [0, 10]

data/share/ryo.rb/examples/3.1_recursion_ryo_from_with_array.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+points = Ryo.from([
+  {x: {to_i: 2}},
+  "foobar",
+  {y: {to_i: 4}}
+])
+
+p points[0].x.to_i
+p points[1]
+p points[2].y.to_i
+
+##
+# 2
+# "foobar"
+# 4