cattri 0.1.3 → 0.2.0

data/spec/cattri/attribute_spec.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+RSpec.describe Cattri::Attribute do
+  let(:name) { :attr }
+  let(:klass) { Class.new }
+  let(:final) { true }
+  let(:expose) { :read_write }
+  let(:scope) { :class }
+  let(:predicate) { false }
+  let(:default) { "default" }
+  let(:transformer) { ->(value) { value } }
+
+  subject(:attribute) do
+    described_class.new(
+      name,
+      defined_in: klass,
+      final: final,
+      expose: expose,
+      scope: scope,
+      predicate: predicate,
+      default: default,
+      transformer: transformer
+    )
+  end
+
+  describe "#initialize" do
+    it "instantiates an Attribute" do
+      expect(attribute).to be_a(described_class)
+      expect(attribute.defined_in).to eq(klass)
+    end
+  end
+
+  describe "#to_h" do
+    it "returns the Cattri::AttributeOptions hash" do
+      hash = attribute.to_h
+      options_hash = attribute.instance_variable_get(:@options).to_h
+
+      expect(hash).to be_a(Hash)
+      expect(hash).to eq(options_hash.merge(defined_in: klass))
+    end
+  end
+
+  %i[
+    name
+    ivar
+    default
+    transformer
+    expose
+    visibility
+  ].each do |option|
+    describe "##{option}" do
+      it "proxies to @options.#{option}" do
+        result = attribute.public_send(option)
+        options_value = attribute.instance_variable_get(:@options).public_send(option)
+
+        expect(result).to eq(options_value)
+      end
+    end
+  end
+
+  describe "#internal_reader?" do
+    [
+      [:read, false],
+      [:write, true],
+      [:read_write, false],
+      [:none, true]
+    ].each do |(value, expected)|
+      context "when instantiated with `expose: :#{value}`" do
+        let(:expose) { value }
+
+        it "returns #{expected}" do
+          expect(attribute.internal_reader?).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe "#internal_writer?" do
+    [
+      [:read, true],
+      [:write, false],
+      [:read_write, false],
+      [:none, true]
+    ].each do |(value, expected)|
+      context "when instantiated with `expose: :#{value}`" do
+        let(:expose) { value }
+
+        it "returns #{expected}" do
+          expect(attribute.internal_writer?).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe "#readable?" do
+    [
+      [:read, true],
+      [:write, false],
+      [:read_write, true],
+      [:none, false]
+    ].each do |(value, expected)|
+      context "when instantiated with `expose: #{value}`" do
+        let(:expose) { value }
+
+        it "returns #{expected}" do
+          expect(attribute.readable?).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe "#writable?" do
+    [
+      [true, :read, false],
+      [true, :write, false],
+      [true, :read_write, false],
+      [true, :none, false],
+      [false, :read, false],
+      [false, :write, true],
+      [false, :read_write, true],
+      [false, :none, false]
+    ].each do |(final_value, expose_value, expected)|
+      context "when instantiated with `final: #{final_value}, expose: #{expose_value}`" do
+        let(:final) { final_value }
+        let(:expose) { expose_value }
+
+        it "returns #{expected}" do
+          expect(attribute.writable?).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe "#readonly?" do
+    [
+      [true, :read, true],
+      [true, :write, true],
+      [true, :read_write, true],
+      [true, :none, false],
+      [false, :read, true],
+      [false, :write, false],
+      [false, :read_write, false],
+      [false, :none, false]
+    ].each do |(final_value, expose_value, expected)|
+      context "when instantiated with `final: #{final_value}, expose: #{expose_value}`" do
+        let(:final) { final_value }
+        let(:expose) { expose_value }
+
+        it "returns #{expected}" do
+          expect(attribute.readonly?).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe "#final?" do
+    [true, false].each do |value|
+      context "when instantiated with `final: #{value}`" do
+        let(:final) { value }
+
+        it "returns #{value}" do
+          expect(attribute.final?).to eq(value)
+        end
+      end
+    end
+  end
+
+  describe "#class_attribute?" do
+    %i[class instance].each do |value|
+      context "when instantiated with `scope: #{value}`" do
+        let(:scope) { value }
+
+        it "returns #{value}" do
+          expect(attribute.class_attribute?).to eq(value == :class)
+        end
+      end
+    end
+  end
+
+  describe "#with_predicate?" do
+    [true, false].each do |value|
+      context "when instantiated with `predicate: #{value}`" do
+        let(:predicate) { value }
+
+        it "returns #{value}" do
+          expect(attribute.with_predicate?).to eq(value)
+        end
+      end
+    end
+  end
+
+  describe "#allowed_methods" do
+    shared_examples_for "allowed method set" do |writable, predicate, expected|
+      let(:expose) { writable ? :read_write : :read }
+      let(:predicate) { predicate }
+      let(:final) { false }
+
+      it "returns #{expected.inspect} for writable: #{writable}, predicate: #{predicate}" do
+        expect(attribute.allowed_methods).to eq(expected)
+      end
+    end
+
+    it_behaves_like "allowed method set", true,  true,  %i[attr attr= attr?]
+    it_behaves_like "allowed method set", true,  false, %i[attr attr=]
+    it_behaves_like "allowed method set", false, true,  %i[attr attr?]
+    it_behaves_like "allowed method set", false, false, [:attr]
+  end
+
+  describe "#validate_assignment!" do
+    [
+      [true, :read, true, false],
+      [true, :write, true, false],
+      [true, :read_write, true, false],
+      [true, :none, true, false],
+      [false, :read, false, true],
+      [false, :write, false, false],
+      [false, :read_write, false, false],
+      [false, :none, false, false]
+    ].each do |(final_value, expose_value, raise_final, raise_readonly)|
+      context "when instantiated with `final: #{final_value}, expose: #{expose_value}`" do
+        let(:final) { final_value }
+        let(:expose) { expose_value }
+
+        it "raises an error" do
+          message =
+            if raise_final
+              "Cannot assign to final attribute `:#{attribute.name}`"
+            elsif raise_readonly
+              "Cannot assign to readonly attribute `:#{attribute.name}`"
+            end
+
+          if raise_final || raise_readonly
+            expect { attribute.validate_assignment! }
+              .to raise_error(Cattri::AttributeError, message)
+          end
+        end
+      end
+    end
+
+    context "when instantiated with `final: false, expose: :read_write`" do
+      let(:final) { false }
+      let(:expose) { :read_write }
+
+      it "does not raise an error" do
+        expect { attribute.validate_assignment! }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#evaluate_default" do
+    context "when the default value succeeds" do
+      it "calls the transformer and returns the result" do
+        expect(attribute.evaluate_default).to eq(default)
+      end
+    end
+
+    context "when the default value raises an error" do
+      let(:default) { double("invalid") }
+
+      before do
+        allow(default).to receive(:dup).and_raise(TypeError, "boom")
+      end
+
+      it "raises Cattri::AttributeError" do
+        expect { attribute.evaluate_default }
+          .to raise_error(
+            Cattri::AttributeError,
+            "Failed to evaluate the default value for `:#{attribute.name}`. Error: boom"
+          )
+      end
+    end
+  end
+
+  describe "#process_assignment" do
+    context "when the transformer succeeds" do
+      it "calls the transformer and returns the result" do
+        expect(attribute.process_assignment("cattri")).to eq("cattri")
+      end
+    end
+
+    context "when the transformer raises an error" do
+      let(:transformer) { double("invalid") }
+
+      before do
+        allow(transformer).to receive(:call).and_raise(TypeError, "boom")
+      end
+
+      it "raises Cattri::AttributeError" do
+        expect { attribute.process_assignment(1, a: 2) }
+          .to raise_error(
+            Cattri::AttributeError,
+            "Failed to evaluate the setter for `:#{attribute.name}`. Error: boom"
+          )
+      end
+    end
+  end
+end

data/spec/cattri/context_registry_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::ContextRegistry do
+  let(:klass) do
+    Class.new do
+      include Cattri::ContextRegistry
+      public :context, :attribute_registry
+    end
+  end
+
+  subject(:instance) { klass.new }
+
+  describe "#context" do
+    it "returns a Cattri::Context wrapping self" do
+      result = instance.context
+      expect(result).to be_a(Cattri::Context)
+      expect(result.target).to eq(instance)
+    end
+
+    it "memoizes the context" do
+      expect(instance.context).to equal(instance.context)
+    end
+  end
+
+  describe "#attribute_registry" do
+    it "returns a Cattri::AttributeRegistry instance" do
+      result = instance.attribute_registry
+      expect(result).to be_a(Cattri::AttributeRegistry)
+    end
+
+    it "is initialized with the context" do
+      expect(Cattri::AttributeRegistry).to receive(:new)
+        .with(instance.context)
+        .and_call_original
+
+      instance.attribute_registry
+    end
+
+    it "memoizes the registry" do
+      expect(instance.attribute_registry).to equal(instance.attribute_registry)
+    end
+  end
+end

data/spec/cattri/context_spec.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::Context do
+  let(:context_target) { Class.new }
+
+  def define_attribute(name, value, scope: :instance, visibility: :public)
+    Cattri::Attribute.new(
+      name,
+      default: value,
+      scope: scope,
+      defined_in: context_target,
+      visibility: visibility
+    )
+  end
+
+  let(:class_attribute) { define_attribute(:class_attr, "class", scope: :class) }
+  let(:instance_attribute) { define_attribute(:instance_attr, "instance") }
+  let(:attribute_options) { {} }
+
+  subject(:context) { described_class.new(context_target) }
+
+  describe "#initialize" do
+    it "instantiates a new Cattri::Context" do
+      expect(context).to be_a(described_class)
+      expect(context.target).to eq(context_target)
+    end
+  end
+
+  describe "#defined_methods" do
+    it "returns a Hash" do
+      expect(context.defined_methods).to be_a(Hash)
+    end
+
+    it "returns a frozen object" do
+      expect(context.defined_methods).to be_frozen
+    end
+
+    it "returns a duplicate of the internal hash" do
+      original = { foo: :bar }
+      context.instance_variable_set(:@__cattri_defined_methods, original.dup)
+
+      result = context.defined_methods
+
+      expect(result).to eq(original)
+      expect(result).not_to equal(original)
+    end
+  end
+
+  describe "#defer_definitions?" do
+    subject(:result) { described_class.new(target).defer_definitions? }
+
+    context "when the target is a Module but NOT a Class" do
+      let(:target) { Module.new }
+      it { is_expected.to be(true) }
+    end
+
+    context "when the target is a Class" do
+      let(:target) { Class.new }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe "#ensure_deferred_support!" do
+    let(:context_target) { Module.new }
+
+    subject(:call) { context.ensure_deferred_support! }
+
+    context "when the target already extends Cattri::DeferredAttributes" do
+      let(:context_target) do
+        Class.new do
+          include Cattri::DeferredAttributes
+        end
+      end
+
+      it "returns immediately without calling #extend again" do
+        expect(context_target).not_to receive(:extend).with(Cattri::DeferredAttributes)
+        call
+      end
+    end
+
+    context "when the target has not yet extended Cattri::DeferredAttributes" do
+      it "extends the target with Cattri::DeferredAttributes" do
+        expect(context_target).to receive(:extend).with(Cattri::DeferredAttributes).and_call_original
+        call
+        expect(context_target.singleton_class.ancestors).to include(Cattri::DeferredAttributes)
+      end
+    end
+  end
+
+  describe "#attribute_lookup_sources" do
+    let(:mod_a) { Module.new }
+    let(:mod_b) { Module.new }
+    let(:sc_double) { instance_double(Class, included_modules: [mod_b, mod_a]) }
+
+    subject(:sources) { context.attribute_lookup_sources }
+
+    before do
+      allow(context_target).to receive(:ancestors).and_return([context_target, mod_a, Object])
+      allow(context_target).to receive(:singleton_class).and_return(sc_double)
+    end
+
+    it "returns an ordered, duplicate-free list of sources" do
+      expect(sources).to eq([context_target, mod_a, Object, mod_b])
+      expect(sources.size).to eq(sources.uniq.size)
+    end
+
+    it "starts with the target itself" do
+      expect(sources.first).to equal(context_target)
+    end
+  end
+
+  describe "#define_method" do
+    let(:attribute_name) { class_attribute.name }
+    let(:impl) { proc { :something } }
+    let(:target) { context.send(:target_for, class_attribute) }
+
+    def stub_method_defined?(flag, attribute)
+      allow(context).to receive(:method_defined?)
+        .with(attribute, name: attribute.name).and_return(flag)
+    end
+
+    context "when the method does not exist" do
+      before { stub_method_defined?(false, class_attribute) }
+
+      it "delegates to #define_method!" do
+        expect(context).to receive(:define_method!)
+          .with(target, class_attribute, attribute_name, &impl)
+
+        context.define_method(class_attribute, &impl)
+      end
+    end
+
+    context "when the method already exists" do
+      before { stub_method_defined?(true, class_attribute) }
+
+      it "raises Cattri::AttributeError" do
+        expect(context).not_to receive(:define_method!)
+
+        expect do
+          context.define_method(class_attribute, &impl)
+        end.to raise_error(Cattri::AttributeError, /Method `:#{attribute_name}` already defined on #{target}/)
+      end
+    end
+  end
+
+  describe "#method_defined?" do
+    let(:attribute_name) { class_attribute.name }
+
+    subject(:result) { context.method_defined?(class_attribute) }
+
+    context "when the method is defined directly on the target class" do
+      before do
+        context.send(:target_for, class_attribute)
+               .define_method(attribute_name) { "cattri" }
+      end
+
+      it { is_expected.to be(true) }
+    end
+
+    context "when the method is NOT on the class but is tracked internally" do
+      before { context.send(:__cattri_defined_methods)[attribute_name] << attribute_name }
+      it { is_expected.to be(true) }
+    end
+
+    context "when the method is neither on the class nor tracked" do
+      it { is_expected.to be(false) }
+    end
+
+    context "when a different :name argument is supplied" do
+      before do
+        context.send(:target_for, class_attribute)
+               .define_method(attribute_name) { "cattri" }
+      end
+
+      it "checks the explicitly-passed name, not the attribute’s name" do
+        expect(context.method_defined?(class_attribute, name: attribute_name)).to be(true)
+        expect(context.method_defined?(class_attribute, name: :foo)).to be(false)
+      end
+    end
+  end
+
+  describe "#__cattri_defined_methods" do
+    it "returns a Hash" do
+      expect(context.send(:__cattri_defined_methods)).to be_a(Hash)
+    end
+
+    it "uses a default block to assign empty arrays" do
+      hash = context.send(:__cattri_defined_methods)
+      hash[:new_key] << :value
+
+      expect(hash[:new_key].to_a).to eq([:value])
+    end
+
+    it "memoizes the result" do
+      first_call = context.send(:__cattri_defined_methods)
+      second_call = context.send(:__cattri_defined_methods)
+
+      expect(first_call).to equal(second_call)
+    end
+  end
+
+  describe "#target_for" do
+    subject(:result) { context.send(:target_for, attribute) }
+
+    context "when a class-level attribute is provided" do
+      let(:attribute) { class_attribute }
+
+      it "returns the singleton_class" do
+        expect(result).to eq(context_target.singleton_class)
+      end
+    end
+
+    context "when a instance-level attribute is provided" do
+      let(:attribute) { instance_attribute }
+
+      it "returns the context's target" do
+        expect(result).to eq(context_target)
+      end
+    end
+  end
+
+  describe "#define_method!" do
+    let(:target) { context.send(:target_for, class_attribute) }
+    let(:attribute_name) { class_attribute.name }
+    let(:implementation) { proc { :impl } }
+
+    context "when method definition succeeds" do
+      before { allow(context).to receive(:apply_visibility!) }
+
+      it "defines the method, tracks it, and applies access" do
+        context.send(:define_method!, target, class_attribute, attribute_name, &implementation)
+
+        expect(target.instance_method(attribute_name)).to be_a(UnboundMethod)
+        expect(context_target.send(attribute_name)).to eq(:impl)
+
+        defined_set = context.send(:__cattri_defined_methods)[attribute_name]
+        expect(defined_set).to include(attribute_name)
+
+        expect(context).to have_received(:apply_visibility!)
+          .with(target, attribute_name, class_attribute)
+      end
+    end
+
+    context "when `class_eval` raises an error" do
+      before do
+        allow(target).to receive(:class_eval).and_raise(StandardError, "boom")
+      end
+
+      it "wraps the error in AttributeError" do
+        expect do
+          context.send(:define_method!, target, class_attribute, attribute_name, &implementation)
+        end.to raise_error(Cattri::AttributeError, /#{attribute_name}/)
+
+        defined_set = context.send(:__cattri_defined_methods)[attribute_name]
+        expect(defined_set).to be_empty
+      end
+    end
+  end
+
+  describe "#apply_visibility!" do
+    let(:target) { context.send(:target_for, attribute) }
+    let(:unbound_method) { instance_double(UnboundMethod) }
+    let(:unbound) { instance_double(Method) }
+    let(:name) { :foo }
+
+    subject(:call) { context.send(:apply_visibility!, target, name, attribute) }
+
+    context "when attribute.access == :public" do
+      let(:attribute) { define_attribute(:test_cattr, "test", scope: :class) }
+
+      it "returns immediately" do
+        call
+
+        expect(context).not_to receive(:resolve_access)
+        expect(context).not_to receive(:target_for)
+        expect(Module).not_to receive(:instance_method)
+      end
+    end
+
+    context "when attribute.access == :protected" do
+      let(:attribute) do
+        define_attribute(:test_cattr, "test", scope: :class, visibility: :protected)
+      end
+
+      it "applies protected visibility to the attribute method definition" do
+        expect(Module).to receive(:instance_method).with(:protected).and_return(unbound_method)
+        expect(unbound_method).to receive(:bind).with(target).and_return(unbound)
+        expect(unbound).to receive(:call).with(name)
+
+        call
+      end
+    end
+  end
+
+  describe "#effective_visibility" do
+    before do
+      stub_const("Cattri::AttributeOptions", Module.new)
+      allow(Cattri::AttributeOptions).to receive(:validate_visibility!).and_return(:explicit)
+    end
+
+    it "returns :protected for internal class-level methods" do
+      attr = double("Attribute", class_attribute?: true, visibility: nil)
+      allow(context).to receive(:internal_method?).with(attr, :foo).and_return(true)
+
+      expect(context.send(:effective_visibility, attr, :foo)).to eq(:protected)
+    end
+
+    it "returns :private for internal instance-level methods" do
+      attr = double("Attribute", class_attribute?: false, visibility: nil)
+      allow(context).to receive(:internal_method?).with(attr, :foo).and_return(true)
+
+      expect(context.send(:effective_visibility, attr, :foo)).to eq(:private)
+    end
+
+    it "returns declared visibility for public method" do
+      attr = double("Attribute", class_attribute?: false, visibility: :protected)
+      allow(context).to receive(:internal_method?).with(attr, :foo).and_return(false)
+
+      expect(context.send(:effective_visibility, attr, :foo)).to eq(:explicit)
+    end
+  end
+
+  describe "#internal_method?" do
+    it "returns true for writer when attribute has no public reader" do
+      attr = double("Attribute", internal_writer?: true, internal_reader?: false)
+      expect(context.send(:internal_method?, attr, :foo=)).to be true
+    end
+
+    it "returns false for writer when attribute has public reader" do
+      attr = double("Attribute", internal_writer?: false, internal_reader?: false)
+      expect(context.send(:internal_method?, attr, :foo=)).to be false
+    end
+
+    it "returns true for reader when attribute has no public writer" do
+      attr = double("Attribute", internal_writer?: false, internal_reader?: true)
+      expect(context.send(:internal_method?, attr, :foo)).to be true
+    end
+
+    it "returns false for reader when attribute has public writer" do
+      attr = double("Attribute", internal_writer?: false, internal_reader?: false)
+      expect(context.send(:internal_method?, attr, :foo)).to be false
+    end
+  end
+end