ryo.rb 0.4.4

data/share/ryo.rb/examples/3.2_recursion_ryo_from_with_openstruct.rb

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

data/share/ryo.rb/examples/4.0_basicobject_ryo_basicobject.rb

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

data/share/ryo.rb/examples/4.1_basicobject_ryo_basicobject_from.rb

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

data/share/ryo.rb/examples/5_collisions_resolution_strategy.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+ryo = Ryo::Object(then: 12)
+p ryo.then # => 12
+p ryo.then { 34 } # => 34

data/share/ryo.rb/examples/6_beyond_hash_objects.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ryo"
+
+class Point
+  def initialize
+    @x = 5
+    @y = 10
+  end
+
+  def each_pair
+    yield("x", @x)
+    yield("y", @y)
+  end
+end
+
+option = Ryo(Point.new)
+p option.x # => 5
+p option.y # => 10

data/share/ryo.rb/examples/7_ryo_lazy.rb

@@ -0,0 +1,14 @@
+require_relative "setup"
+require "ryo"
+
+point_x = Ryo(x: Ryo.lazy { 5 })
+point_y = Ryo({y: Ryo.lazy { 10 }}, point_x)
+point = Ryo({sum: Ryo.lazy { x + y }}, point_y)
+print "point.x = ", point.x, "\n"
+print "point.y = ", point.y, "\n"
+print "point.sum = ", point.sum, "\n"
+
+##
+# point.x = 5
+# point.y = 10
+# point.sum = 15

data/share/ryo.rb/examples/setup.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "bundler/setup"

data/spec/readme_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "test-cmd"
+
+RSpec.describe "README.md examples" do
+  run_example = ->(file) do
+    Test::Cmd.cmd("ruby share/ryo.rb/examples/#{file}")
+  end
+
+  subject do
+    run_example.(file).stdout.chomp
+  end
+
+  context "when given 1.0_prototypes_point_object.rb" do
+    let(:file) { "1.0_prototypes_point_object.rb" }
+    it { is_expected.to eq("[5, 10]") }
+  end
+
+  context "when given 1.1_prototypes_ryo_fn.rb" do
+    let(:file) { "1.1_prototypes_ryo_fn.rb" }
+    it { is_expected.to eq("[10, 20]") }
+  end
+
+  context "when given 2.0_iteration_each.rb" do
+    let(:file) { "2.0_iteration_each.rb" }
+    it { is_expected.to eq(%(["x", 10]\n["y", 20])) }
+  end
+
+  context "when given 2.1_iteration_map.rb" do
+    let(:file) { "2.1_iteration_map.rb" }
+    it { is_expected.to eq("[4, 8]\n[4, 8]") }
+  end
+
+  context "when given 2.2_iteration_ancestors.rb" do
+    let(:file) { "2.2_iteration_ancestors.rb" }
+    it { is_expected.to eq("nil\nnil\n5\n5") }
+  end
+
+  context "when given 3.0_recursion_ryo_from.rb" do
+    let(:file) { "3.0_recursion_ryo_from.rb" }
+    it { is_expected.to eq("[0, 10]") }
+  end
+
+  context "when given 3.1_recursion_ryo_from_with_array.rb" do
+    let(:file) { "3.1_recursion_ryo_from_with_array.rb" }
+    it { is_expected.to eq(%(2\n"foobar"\n4)) }
+  end
+
+  context "when given 3.2_recursion_ryo_from_with_openstruct.rb" do
+    let(:file) { "3.2_recursion_ryo_from_with_openstruct.rb" }
+    it { is_expected.to eq("[5, 10]") }
+  end
+
+  context "when given 4.0_basicobject_ryo_basicobject.rb" do
+    let(:file) { "4.0_basicobject_ryo_basicobject.rb" }
+    it { is_expected.to eq("[0, 0]") }
+  end
+
+  context "when given 4.1_basicobject_ryo_basicobject_from.rb" do
+    let(:file) { "4.1_basicobject_ryo_basicobject_from.rb" }
+    it { is_expected.to eq("[2, 4]") }
+  end
+
+  context "when given 5_collisions_resolution_strategy.rb" do
+    let(:file) { "5_collisions_resolution_strategy.rb" }
+    it { is_expected.to eq("12\n34") }
+  end
+
+  context "when given 6_beyond_hash_objects.rb" do
+    let(:file) { "6_beyond_hash_objects.rb" }
+    it { is_expected.to eq("5\n10") }
+  end
+
+  context "when given 7_ryo_lazy.rb" do
+    let(:file) { "7_ryo_lazy.rb" }
+    it { is_expected.to eq("point.x = 5\npoint.y = 10\npoint.sum = 15") }
+  end
+end

data/spec/ryo_basic_object_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require "ostruct"
+
+RSpec.describe Ryo::BasicObject do
+  describe "Ryo::BasicObject()" do
+    context "when given a Hash" do
+      subject { [point.x, point.y] }
+      let(:point) { Ryo::BasicObject(x: 0, y: 0) }
+      it { is_expected.to eq([0, 0]) }
+    end
+
+    context "when given an OpenStruct" do
+      subject { [point.x, point.y] }
+      let(:point) { Ryo::BasicObject(OpenStruct.new(x: 0, y: 0)) }
+      it { is_expected.to eq([0, 0]) }
+
+      context "when verifying the object is a Ryo object" do
+        subject { Ryo === point }
+        it { is_expected.to be(true) }
+      end
+    end
+  end
+
+  describe ".from" do
+    context "when given an instance of Ryo::BasicObject" do
+      subject { Ryo.from(point) }
+      let(:point) { Ryo::BasicObject(x: 5, y: 10) }
+      it { is_expected.to eq(point) }
+    end
+
+    context "when given nested Hash objects" do
+      subject { point.x.to_i }
+      let(:point) { Ryo::BasicObject.from({x: {to_i: 4}}) }
+      it { is_expected.to eq(4) }
+    end
+
+    context "when given an Array that contains nested Hash objects" do
+      subject { points[0].x.to_i }
+      let(:points) { Ryo::BasicObject.from([{x: {to_i: 4}}]) }
+      it { is_expected.to eq(4) }
+    end
+
+    context "with a prototype" do
+      let(:point_a) { Ryo::BasicObject.from(x: {to_i: 0}) }
+      let(:point_b) { Ryo::BasicObject.from({y: {to_i: 2}}, point_a) }
+
+      context "when traversing to the prototype (point_a)" do
+        subject { point_b.x.to_i }
+        it { is_expected.to eq(0) }
+      end
+
+      context "when verifying a nested Hash doesn't inherit the prototype (point_a)" do
+        subject { point_b.y.x }
+        it { is_expected.to eq(nil) }
+      end
+    end
+  end
+end

data/spec/ryo_enumerable_spec.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+RSpec.describe Ryo::Enumerable do
+  describe ".each" do
+    context "when verifying each traverses through the prototype chain" do
+      subject { Ryo.each(point_c).map { [_1, _2] } }
+      let(:point_a) { Ryo(x: 0) }
+      let(:point_b) { Ryo({y: 5}, point_a) }
+      let(:point_c) { Ryo({}, point_b) }
+      it { is_expected.to eq([["y", 5], ["x", 0]]) }
+    end
+  end
+
+  describe ".map" do
+    subject(:point_c) { Ryo.map(point_b) { _2 * 2 } }
+    let(:point_a) { Ryo::BasicObject(x: 4, y: 4) }
+    let(:point_b) { Ryo::BasicObject({x: 2, y: 2}, point_a) }
+
+    context "when verifying the map operation" do
+      it { is_expected.to eq({x: 4, y: 4}) }
+    end
+
+    context "when verifying the map operation on the prototype" do
+      subject { point_a }
+      before { Ryo.map!(point_b) { _2 * 2 } }
+      it { is_expected.to eq({x: 8, y: 8}) }
+    end
+
+    context "when verifying the map operation returns a new object" do
+      subject { Ryo.kernel(:equal?).bind_call(point_b, point_c) }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe ".select" do
+    context "with prototype chain traversal" do
+      subject { Ryo.select(point_b) { _1 == "y" and _2 == 4 } }
+      let(:point_a) { Ryo::BasicObject(x: 1, y: 2) }
+      let(:point_b) { Ryo::BasicObject({x: 3, y: 4}, point_a) }
+
+      context "when verifying the filter operation" do
+        it { is_expected.to eq(y: 4) }
+      end
+
+      context "when verifying the filter operation on the prototype" do
+        subject { point_a.y }
+        before { Ryo.select!(point_b) { _1 == "x" } }
+        it { is_expected.to eq(nil) }
+      end
+    end
+  end
+
+  describe ".reject" do
+    context "with prototype chain traversal" do
+      subject { Ryo.reject(point_b) { _1 == "x" } }
+      let(:point_a) { Ryo::BasicObject(x: 1, y: 2) }
+      let(:point_b) { Ryo::BasicObject({x: 3, y: 4}, point_a) }
+
+      context "when verifying the filter operation" do
+        it { is_expected.to eq(y: 4) }
+      end
+
+      context "when verifying the filter operation on the prototype" do
+        subject { point_a.y }
+        before { Ryo.reject!(point_b) { _1 == "y" } }
+        it { is_expected.to eq(nil) }
+      end
+    end
+  end
+
+  describe ".any?" do
+    let(:point_a) { Ryo::BasicObject(y: 10) }
+    let(:point_b) { Ryo::BasicObject({x: 5}, point_a) }
+
+    context "when an iteration returns a truthy value" do
+      subject { Ryo.any?(point_b) { _2 > 5 } }
+      it { is_expected.to be(true) }
+    end
+
+    context "when an iteration fails to return a truthy value" do
+      subject { Ryo.any?(point_b) { _2 > 20 } }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe ".all?" do
+    let(:point_a) { Ryo::BasicObject(y: 10) }
+    let(:point_b) { Ryo::BasicObject({x: 5}, point_a) }
+    let(:point_c) { Ryo::BasicObject({z: 0}, point_b) }
+
+    context "when every iteration returns a truthy value" do
+      subject { Ryo.all?(point_c) { _2 < 11 } }
+      it { is_expected.to be(true) }
+    end
+
+    context "when an iteration fails to return a truthy value" do
+      subject { Ryo.all?(point_c) { _2 < 5 } }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe ".find" do
+    let(:point_a) { Ryo::BasicObject(x: 5) }
+    let(:point_b) { Ryo::BasicObject({y: 10}, point_a) }
+    let(:point_c) { Ryo::BasicObject({z: 15}, point_b) }
+
+    context "when an iteration yields true on point_a" do
+      subject { Ryo.find(point_c) { _2 == 5 } }
+      it { is_expected.to be(point_a) }
+    end
+
+    context "when an iteration yields true on point_b" do
+      subject { Ryo.find(point_c) { _2 == 10 } }
+      it { is_expected.to be(point_b) }
+    end
+
+    context "when an iteration yields true on point_c" do
+      subject { Ryo.find(point_c) { _2 == 15 } }
+      it { is_expected.to be(point_c) }
+    end
+
+    context "when an iteration never yields true" do
+      subject { Ryo.find(point_c) { _2 == 20 } }
+      it { is_expected.to eq(nil) }
+    end
+
+    context "when ancestors is set to zero" do
+      context "when the condition matches for point_a" do
+        subject { Ryo.find(point_c, ancestors: 0) { _2 == 5 } }
+        it { is_expected.to be_nil }
+      end
+
+      context "when the condition matches for point_b" do
+        subject { Ryo.find(point_c, ancestors: 0) { _2 == 10 } }
+        it { is_expected.to be_nil }
+      end
+
+      context "when the condition matches for point_c" do
+        subject { Ryo.find(point_c, ancestors: 0) { _2 == 15 } }
+        it { is_expected.to be(point_c) }
+      end
+    end
+
+    context "when ancestors is set to one" do
+      context "when the condition matches for point_a" do
+        subject { Ryo.find(point_c, ancestors: 1) { _2 == 5 } }
+        it { is_expected.to be_nil }
+      end
+
+      context "when the condition matches for point_b" do
+        subject { Ryo.find(point_c, ancestors: 1) { _2 == 10 } }
+        it { is_expected.to be(point_b) }
+      end
+
+      context "when the condition matches for point_c" do
+        subject { Ryo.find(point_c, ancestors: 1) { _2 == 15 } }
+        it { is_expected.to be(point_c) }
+      end
+    end
+
+    context "when ancestors is set to two" do
+      context "when the condition matches for point_a" do
+        subject { Ryo.find(point_c, ancestors: 2) { _2 == 5 } }
+        it { is_expected.to be(point_a) }
+      end
+
+      context "when the condition matches for point_b" do
+        subject { Ryo.find(point_c, ancestors: 2) { _2 == 10 } }
+        it { is_expected.to be(point_b) }
+      end
+
+      context "when the condition matches for point_c" do
+        subject { Ryo.find(point_c, ancestors: 2) { _2 == 15 } }
+        it { is_expected.to be(point_c) }
+      end
+    end
+
+    context "when ancestors is set to three (or higher)" do
+      context "when the condition matches for point_a" do
+        subject { Ryo.find(point_c, ancestors: 3) { _2 == 5 } }
+        it { is_expected.to be(point_a) }
+      end
+
+      context "when the condition matches for point_b" do
+        subject { Ryo.find(point_c, ancestors: 3) { _2 == 10 } }
+        it { is_expected.to be(point_b) }
+      end
+
+      context "when the condition matches for point_c" do
+        subject { Ryo.find(point_c, ancestors: 3) { _2 == 15 } }
+        it { is_expected.to be(point_c) }
+      end
+    end
+  end
+end

data/spec/ryo_keywords_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+RSpec.describe Ryo::Keywords do
+  describe ".function" do
+    let(:point) { Ryo(move: Ryo.fn { |x, y| [x, y] }) }
+
+    context "when the function requires argument(s)" do
+      context "when the required argument is not given" do
+        subject { point.move.() }
+        it { expect { is_expected }.to raise_error(ArgumentError) }
+      end
+
+      context "when the required argument is given" do
+        subject { point.move.(30, 50) }
+        it { is_expected.to eq([30, 50]) }
+      end
+    end
+
+    context "when the function receives a block" do
+      subject { point.move.() { "block" } }
+      let(:point) { Ryo(move: Ryo.fn { |&b| b.() }) }
+      it { is_expected.to eq("block") }
+    end
+  end
+
+  describe ".delete" do
+    let(:point_a) { Ryo(x: 0) }
+    let(:point_b) { Ryo({x: 1}, point_a) }
+
+    context "with no prototype" do
+      context "when a property is deleted" do
+        subject { point_a.x }
+        before { Ryo.delete(point_a, "x") }
+        it { is_expected.to be_nil }
+      end
+    end
+
+    context "with a prototype" do
+      context "when a property is deleted from point_a" do
+        subject { point_b.x }
+        before { Ryo.delete(point_a, "x") }
+        it { is_expected.to eq(1) }
+      end
+
+      context "when a property is deleted from point_b" do
+        subject { point_b.x }
+        before { Ryo.delete(point_b, "x") }
+        it { is_expected.to eq(0) }
+      end
+
+      context "when a property is deleted from both point_a / point_b" do
+        subject { point_b.x }
+        before { [point_a, point_b].each { Ryo.delete(_1, "x") } }
+        it { is_expected.to be(nil) }
+      end
+    end
+  end
+
+  describe ".in?" do
+    let(:point_a) { Ryo(x: 0) }
+    let(:point_b) { Ryo({y: 1}, point_a) }
+    let(:point_c) { Ryo({z: 2}, point_b) }
+
+    context "when given 'x' as a property name" do
+      subject { Ryo.in?(point_c, "x") }
+      it { is_expected.to be(true) }
+    end
+
+    context "when given 'y' as a property name" do
+      subject { Ryo.in?(point_c, "y") }
+      it { is_expected.to be(true) }
+    end
+
+    context "when given 'z' as a property name" do
+      subject { Ryo.in?(point_c, "z") }
+      it { is_expected.to be(true) }
+    end
+
+    context "when given 'w' as a property name" do
+      subject { Ryo.in?(point_c, "w") }
+      it { is_expected.to be(false) }
+    end
+  end
+end

data/spec/ryo_object_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+RSpec.describe "Ryo objects" do
+  let(:car) { Ryo(name: "Car") }
+
+  describe "#respond_to?" do
+    context "when a property is defined" do
+      subject { car.respond_to?(:name) }
+      it { is_expected.to be(true) }
+    end
+
+    context "when a property is not defined" do
+      subject { car.respond_to?(:foobar) }
+      it { is_expected.to be(true) }
+    end
+  end
+
+  describe "#method_missing" do
+    context "when a property doesn't exist" do
+      subject { car.foobar }
+      it { is_expected.to eq(nil) }
+    end
+  end
+
+  describe "#eql?" do
+    context "when two objects are equal" do
+      subject { car == car_2 }
+      let(:car_2) { Ryo(name: "Car") }
+      it { is_expected.to be(true) }
+    end
+
+    context "when an object and a Hash are equal" do
+      subject { car == {"name" => "Car"} }
+      it { is_expected.to be(true) }
+    end
+
+    context "when an object and symbol-key Hash are equal" do
+      subject { car == {name: "Car"} }
+      it { is_expected.to be(true) }
+    end
+
+    context "when an object and nested symbol-key Hash are equal" do
+      subject { car == {name: "Car", wheels: {quantity: 4, weight: {lbs: "50"}}} }
+      let(:car) { Ryo.from(name: "Car", wheels: {quantity: 4, weight: {lbs: "50"}}) }
+      it { is_expected.to be(true) }
+    end
+
+    context "when an object is compared against nil" do
+      subject { car == nil }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe "when a property overshadows a method" do
+    let(:car) do
+      Ryo(tap: "property")
+    end
+
+    context "when a block is not given" do
+      subject { car.tap }
+      it { is_expected.to eq("property") }
+    end
+
+    context "when a block is given" do
+      subject { car.tap {} }
+      it { is_expected.to eq(car) }
+    end
+  end
+end

data/spec/ryo_prototypes_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+RSpec.describe "Prototypes" do
+  context "when there is one prototype" do
+    let(:root) { Ryo(name: "root") }
+    let(:node) { Ryo({}, root) }
+
+    context "when traversing to a property on the root prototype" do
+      subject { node.name }
+      it { is_expected.to eq("root") }
+    end
+
+    context "when a property is deleted from the root prototype" do
+      subject { node.name }
+      before { Ryo.delete(root, "name") }
+      it { is_expected.to eq(nil) }
+    end
+  end
+
+  context "when there are two prototypes" do
+    let(:root) { Ryo(name: "root") }
+    let(:node_1) { Ryo({}, root) }
+    let(:node_2) { Ryo({}, node_1) }
+
+    context "when traversing to a property on the root prototype" do
+      subject { node_2.name }
+      it { is_expected.to eq("root") }
+    end
+
+    context "when traversing to a property on the middle prototype" do
+      subject { node_2.name }
+      let(:node_1) { Ryo({name: "Node 1"}, root) }
+      it { is_expected.to eq("Node 1") }
+    end
+
+    context "when a property is deleted from the middle prototype" do
+      subject { node_2.name }
+      let(:node_1) { Ryo({name: "Node 1"}, root) }
+      before { Ryo.delete(node_1, "name") }
+      it { is_expected.to eq("root") }
+    end
+  end
+end