ryo.rb 0.4.4

data/spec/ryo_reflect_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+RSpec.describe Ryo::Reflect do
+  describe ".ryo?" do
+    subject { Ryo.ryo?(object) }
+
+    context "when given an instance of Ryo::BasicObject" do
+      let(:object) { Ryo::BasicObject(x: 1, y: 1) }
+      it { is_expected.to be(true) }
+    end
+
+    context "when given an instance of Ryo::Object" do
+      let(:object) { Ryo::Object(x: 2, y: 2) }
+      it { is_expected.to be(true) }
+    end
+
+    context "when given an instance of Object" do
+      let(:object) { Object.new }
+      it { is_expected.to be(false) }
+    end
+
+    context "when given an instance of Hash" do
+      let(:object) { {} }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe ".property?" do
+    subject { Ryo.property?(point_b, property) }
+    let(:point_a) { Ryo(x: 0) }
+    let(:point_b) { Ryo({y: 0}, point_a) }
+
+    context "when given a property belonging to a prototype" do
+      let(:property) { "x" }
+      it { is_expected.to be(false) }
+    end
+
+    context "when given a property belonging to self" do
+      let(:property) { "y" }
+      it { is_expected.to be(true) }
+    end
+  end
+
+  describe ".properties_of" do
+    context "when properties of a prototype are excluded" do
+      subject { Ryo.properties_of(point_b) }
+      let(:point_a) { Ryo(x: 0) }
+      let(:point_b) { Ryo({y: 0}, point_a) }
+      it { is_expected.to eq(["y"]) }
+    end
+  end
+
+  describe ".set_prototype_of" do
+    context "when the prototype of point_c is changed to point_b" do
+      subject { point_c.y }
+      let(:point_a) { Ryo(x: 0, y: 0) }
+      let(:point_b) { Ryo(y: 5) }
+      let(:point_c) { Ryo({}, point_a) }
+
+      before { Ryo.set_prototype_of(point_c, point_b) }
+      it { is_expected.to eq(5) }
+    end
+  end
+
+  describe ".prototype_of" do
+    let(:point_a) { Ryo(x: 0, y: 0) }
+    let(:point_b) { Ryo({y: 5}, point_a) }
+
+    context "when given an object with a prototype" do
+      subject { Ryo.prototype_of(point_b) }
+      it { is_expected.to be(point_a) }
+    end
+
+    context "when given an object without a prototype" do
+      subject { Ryo.prototype_of(point_a) }
+      it { is_expected.to be(nil) }
+    end
+  end
+
+  describe ".prototype_chain_of" do
+    context "when given the last prototype (point_c)" do
+      subject { Ryo.prototype_chain_of(point_c) }
+      let(:root) { Ryo({a: 1}) }
+      let(:point_a) { Ryo({b: 2}, root) }
+      let(:point_b) { Ryo({c: 3}, point_a) }
+      let(:point_c) { Ryo({d: 4}, point_b) }
+
+      it { is_expected.to eq([point_b, point_a, root]) }
+    end
+
+    context "when given an object without a prototype" do
+      subject { Ryo.prototype_chain_of(Ryo({})) }
+      it { is_expected.to eq([]) }
+    end
+  end
+
+  describe ".class_of" do
+    context "when given an instance of Ryo::BasicObject" do
+      subject { Ryo.class_of Ryo::BasicObject({}) }
+      it { is_expected.to eq(Ryo::BasicObject) }
+    end
+
+    context "when given an instance of Ryo::Object" do
+      subject { Ryo.class_of Ryo::Object({}) }
+      it { is_expected.to eq(Ryo::Object) }
+    end
+  end
+
+  describe ".equal?" do
+    let(:point_a) { Ryo::BasicObject(x: 5, y: 5) }
+    let(:point_b) { Ryo::BasicObject(x: 5, y: 5) }
+
+    context "when two objects are the same object" do
+      subject { Ryo.equal?(point_a, point_a) }
+      it { is_expected.to be(true) }
+    end
+
+    context "when two objects are distinct objects" do
+      subject { Ryo.equal?(point_a, point_b) }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe ".assign" do
+    let(:point_a) { Ryo(x: 0, y: 0) }
+    let(:point_b) { Ryo(y: 10) }
+
+    context "when point_b is assigned to point_a" do
+      subject { Ryo.assign(point_a, point_b) }
+      it { is_expected.to eq("x" => 0, "y" => 10) }
+      it { is_expected.to be_instance_of(Ryo::Object) }
+    end
+
+    context "when a Ryo object and Hash object are assigned to point_a" do
+      subject { Ryo.assign(point_a, point_b, {move: fn}) }
+      let(:fn) { Ryo.fn {} }
+      it { is_expected.to eq("x" => 0, "y" => 10, "move" => fn) }
+      it { is_expected.to be_instance_of(Ryo::Object) }
+      it { is_expected.to be(point_a) }
+    end
+  end
+
+  describe ".table_of" do
+    subject(:table) { Ryo.table_of(ryo, recursive:) }
+
+    context "without recursion" do
+      let(:recursive) { false }
+      context "when given a Ryo object" do
+        let(:ryo) { Ryo(x: 1, y:1) }
+        it { is_expected.to be_instance_of(Hash) }
+        it { is_expected.to eq("x" => 1, "y" => 1) }
+      end
+    end
+
+    context "with recursion" do
+      let(:recursive) { true }
+      context "when a Ryo object nests another Ryo object" do
+        let(:ryo) { Ryo(point: Ryo(x: 1, y: 1)) }
+        it { expect(table).to be_instance_of(Hash) }
+        it { expect(table["point"]).to be_instance_of(Hash) }
+        it { is_expected.to eq("point" => {"x" => 1, "y" => 1}) }
+      end
+
+      context "when a Ryo object has a nest depth of two" do
+        let(:ryo) { Ryo(point: Ryo(point: Ryo(x: 1, y: 1))) }
+        it { expect(table).to be_instance_of(Hash) }
+        it { expect(table["point"]).to be_instance_of(Hash) }
+        it { expect(table["point"]["point"]).to be_instance_of(Hash) }
+        it { is_expected.to eq("point" => {"point" => {"x" => 1, "y" => 1}}) }
+      end
+    end
+  end
+end

data/spec/ryo_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+RSpec.describe Ryo do
+  describe ".from" do
+    context "when given an instance of Ryo::Object" do
+      subject { Ryo.from(point) }
+      let(:point) { Ryo(x: 5, y: 10) }
+      it { is_expected.to eq(point) }
+    end
+
+    context "when given { key => Hash<Symbol, Integer> }" do
+      subject { point.x.to_i }
+      let(:point) { Ryo.from({x: {to_i: 4}}) }
+      it { is_expected.to eq(4) }
+    end
+
+    context "when given { key => Array<String> }" do
+      subject { Ryo.from(key: %w[foo bar baz]) }
+      it { is_expected.to be_instance_of(Ryo::Object) }
+      it { is_expected.to eq("key" => %w[foo bar baz]) }
+    end
+
+    context "when given { key => Array<String, Ryo::BasicObject> }" do
+      subject { Ryo.from(key: ["foo", point]) }
+      let(:point) { Ryo::BasicObject(x: 0, y: 0) }
+      it { is_expected.to be_instance_of(Ryo::Object) }
+      it { is_expected.to eq("key" => ["foo", point]) }
+
+      context "with equal?" do
+        subject { super().key[-1] }
+        it { is_expected.to be(point) }
+      end
+    end
+
+    context "when given an Array that contains Hash objects" do
+      context "when given one Hash object" do
+        subject { ary[0].x.to_i }
+        let(:ary) { Ryo.from([{x: {to_i: 4}}]) }
+        it { is_expected.to eq(4) }
+      end
+
+      context "when given two Hash objects" do
+        subject { ary.map { _1.x.to_i } }
+        let(:ary) { Ryo.from([{x: {to_i: 4}}, {x: {to_i: 3}}]) }
+        it { is_expected.to eq([4, 3]) }
+      end
+
+      context "when given a mix of Hash objects, and other objects" do
+        subject { ary.map { (Ryo === _1) ? _1.x.to_i : _1 } }
+        let(:ary) { Ryo.from([{x: {to_i: 4}}, "foo"]) }
+        it { is_expected.to eq([4, "foo"]) }
+      end
+
+      context "when given a mix of Hash objects, and Ryo objects" do
+        subject { ary.map(&:x) }
+        let(:ary) { Ryo.from([{x: 1}, Ryo::BasicObject(x: 2)]) }
+        it { is_expected.to eq([1, 2]) }
+      end
+    end
+
+    context "when given an object that implements #each" do
+      subject { ary.map { (Ryo === _1) ? _1.x.to_i : _1 } }
+      let(:ary) do
+        Ryo.from Class.new {
+          def each
+            arr = [{x: {to_i: 4}}, "foo"]
+            arr.each { yield(_1) }
+          end
+        }.new
+      end
+      it { is_expected.to eq([4, "foo"]) }
+    end
+
+    context "when given an object that implements #each_pair" do
+      subject { [point.x, point.y] }
+      let(:point) do
+        Ryo.from Class.new {
+          def each_pair
+            yield("x", 5)
+            yield("y", 10)
+          end
+        }.new
+      end
+      it { is_expected.to eq([5, 10]) }
+    end
+
+    context "when given an object that doesn't implement #each or #each_pair" do
+      subject(:from) { Ryo.from(Object.new) }
+      it { expect { from }.to raise_error(TypeError, %r{does not implement #each / #each_pair}) }
+    end
+  end
+
+  describe ".dup" do
+    subject(:dup) { Ryo.dup(point_c) }
+    let(:point_a) { Ryo::BasicObject(x: 1) }
+    let(:point_b) { Ryo::BasicObject({y: 2}, point_a) }
+    let(:point_c) { Ryo::BasicObject({}, point_b) }
+
+    context "when the duplicate is mutated" do
+      before { dup.x = 5 }
+
+      context "when verifying the source wasn't mutated" do
+        subject { point_c.x }
+        it { is_expected.to eq(1) }
+      end
+
+      context "when verifying the duplicate was mutated" do
+        subject { dup.x }
+        it { is_expected.to eq(5) }
+      end
+    end
+
+    context "when verifying the source and duplicate are distinct objects" do
+      subject { Ryo.kernel(:equal?).bind_call(point_c, dup) }
+      it { is_expected.to eq(false) }
+    end
+
+    context "when verifying the source and duplicate are eql?" do
+      subject { point_c == dup }
+      it { is_expected.to be(true) }
+    end
+
+    context "when verifying the prototype chain of the source and duplicate are eql?" do
+      subject { Ryo.prototype_chain_of(point_c) == Ryo.prototype_chain_of(dup) }
+      it { is_expected.to eq(true) }
+    end
+  end
+end

data/spec/setup.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rspec"
+require "ryo"

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: ryo.rb
+version: !ruby/object:Gem::Version
+  version: 0.4.4
+platform: ruby
+authors:
+- '0x1eef'
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: test-cmd.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Ryo implements prototype-based inheritance, in Ruby.
+email:
+- 0x1eef@protonmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/specs.yml"
+- ".gitignore"
+- ".gitlab-ci.yml"
+- ".rubocop.yml"
+- ".yardoc-template/default/fulldoc/html/css/0x1eef.css"
+- ".yardoc-template/default/layout/html/setup.rb"
+- ".yardoc-template/default/module/setup.rb"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ryo.rb
+- lib/ryo/basic_object.rb
+- lib/ryo/builder.rb
+- lib/ryo/enumerable.rb
+- lib/ryo/function.rb
+- lib/ryo/keywords.rb
+- lib/ryo/lazy.rb
+- lib/ryo/object.rb
+- lib/ryo/reflect.rb
+- lib/ryo/version.rb
+- ryo.rb.gemspec
+- share/ryo.rb/examples/1.0_prototypes_point_object.rb
+- share/ryo.rb/examples/1.1_prototypes_ryo_fn.rb
+- share/ryo.rb/examples/2.0_iteration_each.rb
+- share/ryo.rb/examples/2.1_iteration_map.rb
+- share/ryo.rb/examples/2.2_iteration_ancestors.rb
+- share/ryo.rb/examples/3.0_recursion_ryo_from.rb
+- share/ryo.rb/examples/3.1_recursion_ryo_from_with_array.rb
+- share/ryo.rb/examples/3.2_recursion_ryo_from_with_openstruct.rb
+- share/ryo.rb/examples/4.0_basicobject_ryo_basicobject.rb
+- share/ryo.rb/examples/4.1_basicobject_ryo_basicobject_from.rb
+- share/ryo.rb/examples/5_collisions_resolution_strategy.rb
+- share/ryo.rb/examples/6_beyond_hash_objects.rb
+- share/ryo.rb/examples/7_ryo_lazy.rb
+- share/ryo.rb/examples/setup.rb
+- spec/readme_spec.rb
+- spec/ryo_basic_object_spec.rb
+- spec/ryo_enumerable_spec.rb
+- spec/ryo_keywords_spec.rb
+- spec/ryo_object_spec.rb
+- spec/ryo_prototypes_spec.rb
+- spec/ryo_reflect_spec.rb
+- spec/ryo_spec.rb
+- spec/setup.rb
+homepage: https://github.com/0x1eef/ryo.rb#readme
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Ryo implements prototype-based inheritance, in Ruby.
+test_files: []