cattri 0.1.3 → 0.2.0

data/spec/cattri/attribute_options_spec.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::AttributeOptions do
+  describe ".validate_expose!" do
+    subject(:instance) { described_class.new(:attr) }
+
+    it "returns the valid option provided" do
+      expect(described_class.validate_expose!(:read)).to eq(:read)
+    end
+
+    it "returns the valid option provided from a string" do
+      expect(described_class.validate_expose!("read")).to eq(:read)
+    end
+
+    it "raises on an invalid option" do
+      expect do
+        described_class.validate_expose!(:invalid)
+      end.to raise_error(Cattri::AttributeError, /Invalid expose option `:invalid`/)
+    end
+  end
+
+  describe ".validate_visibility!" do
+    subject(:instance) { described_class.new(:attr) }
+
+    it "returns the valid option provided" do
+      expect(described_class.validate_visibility!(:public)).to eq(:public)
+    end
+
+    it "returns the valid option provided from a string" do
+      expect(described_class.validate_visibility!("public")).to eq(:public)
+    end
+
+    it "raises on an invalid option" do
+      expect do
+        described_class.validate_visibility!(:invalid)
+      end.to raise_error(Cattri::AttributeError, /Invalid visibility `:invalid`/)
+    end
+  end
+
+  describe "#initialize" do
+    let(:name) { :my_attribute }
+
+    it "sets @name to symbolized name" do
+      instance = described_class.new(name)
+      expect(instance.instance_variable_get(:@name)).to eq(:my_attribute)
+    end
+
+    context "with default options" do
+      subject(:instance) { described_class.new(name) }
+
+      it "sets @ivar to normalized default" do
+        expect(instance.instance_variable_get(:@ivar)).to eq(:@my_attribute)
+      end
+
+      it "sets @final to false" do
+        expect(instance.instance_variable_get(:@final)).to be(false)
+      end
+
+      it "sets @scope to :instance" do
+        expect(instance.instance_variable_get(:@scope)).to be(:instance)
+      end
+
+      it "sets @predicate to false" do
+        expect(instance.instance_variable_get(:@predicate)).to be(false)
+      end
+
+      it "sets @default using normalize_default" do
+        expect(instance.instance_variable_get(:@default).call).to eq(nil)
+      end
+
+      it "sets @transformer using normalize_transformer" do
+        transformer = instance.instance_variable_get(:@transformer)
+        expect(transformer).to respond_to(:call)
+      end
+
+      it "sets @expose using validate_expose!" do
+        expect(instance.instance_variable_get(:@expose)).to eq(:read_write)
+      end
+
+      it "sets @visibility using validate_visibility!" do
+        expect(instance.instance_variable_get(:@visibility)).to eq(:public)
+      end
+
+      it "freezes the instance" do
+        expect(instance).to be_frozen
+      end
+    end
+
+    context "with provided options" do
+      let(:ivar) { :custom_ivar }
+      let(:final) { true }
+      let(:scope) { :class }
+      let(:predicate) { true }
+      let(:default) { :custom_default }
+      let(:transformer) { ->(val) { val } }
+      let(:expose) { :read }
+      let(:visibility) { :private }
+
+      subject(:instance) do
+        described_class.new(
+          name,
+          ivar: ivar,
+          final: final,
+          scope: scope,
+          predicate: predicate,
+          default: default,
+          transformer: transformer,
+          expose: expose,
+          visibility: visibility
+        )
+      end
+
+      it "assigns the custom ivar" do
+        expect(instance.instance_variable_get(:@ivar)).to eq(:@custom_ivar)
+      end
+
+      it "assigns the custom final value" do
+        expect(instance.instance_variable_get(:@final)).to eq(true)
+      end
+
+      it "assigns the custom scope value" do
+        expect(instance.instance_variable_get(:@scope)).to eq(:class)
+      end
+
+      it "assigns the custom predicate value" do
+        expect(instance.instance_variable_get(:@predicate)).to eq(true)
+      end
+
+      it "assigns the custom default value" do
+        expect(instance.instance_variable_get(:@default).call).to eq(:custom_default)
+      end
+
+      it "assigns the custom transformer" do
+        expect(instance.instance_variable_get(:@transformer)).to eq(transformer)
+      end
+
+      it "assigns the custom expose value" do
+        expect(instance.instance_variable_get(:@expose)).to eq(:read)
+      end
+
+      it "assigns the custom visibility value" do
+        expect(instance.instance_variable_get(:@visibility)).to eq(:private)
+      end
+    end
+  end
+
+  describe "#[]" do
+    subject(:instance) { described_class.new(:attr) }
+
+    it "returns for known options" do
+      expect(instance[:name]).to eq(:attr)
+    end
+
+    it "returns nil for unknown options" do
+      expect(instance[:unknown]).to be_nil
+    end
+
+    it "converts the key provided to a symbol" do
+      expect(instance["ivar"]).to eq(:@attr)
+    end
+  end
+
+  describe "#to_h" do
+    it "returns a hash representation of the options" do
+      instance = described_class.new(:attr, ivar: :custom_ivar)
+      hash = instance.to_h
+
+      expect(hash).to be_frozen
+      expect(hash).to include(
+        name: :attr,
+        ivar: :@custom_ivar,
+        final: false,
+        scope: :instance,
+        predicate: false,
+        expose: :read_write,
+        visibility: :public
+      )
+
+      expect(hash[:default].call).to be_nil
+      expect(hash[:transformer].call(123)).to be(123)
+    end
+  end
+
+  describe "#normalize_ivar" do
+    subject(:instance) { described_class.new(:attr) }
+
+    [
+      [nil, :@attr],
+      %i[@custom @custom],
+      ["@_custom", :@_custom],
+      %i[@__custom @__custom]
+    ].each do |(ivar, expected)|
+      it "returns #{expected.inspect} for '#{ivar}'" do
+        expect(instance.send(:normalize_ivar, ivar)).to eq(expected)
+      end
+    end
+  end
+
+  describe "#normalize_default" do
+    subject(:instance) { described_class.new(:attr) }
+
+    it "returns existing callable unchanged" do
+      fn = -> { :ok }
+      default = instance.send(:normalize_default, fn)
+
+      expect(default).to be_a(Proc)
+      expect(default.call).to eq(fn.call)
+    end
+
+    it "wraps immutable value in lambda" do
+      default = instance.send(:normalize_default, :sym)
+
+      expect(default).to be_a(Proc)
+      expect(default.call).to eq(:sym)
+    end
+
+    it "wraps mutable values and duplicates them" do
+      default = instance.send(:normalize_default, [1, 2])
+      v1 = default.call
+      v2 = default.call
+
+      expect(v1).to eq([1, 2])
+      expect(v1).not_to be(v2)
+    end
+  end
+
+  describe "#normalize_transformer" do
+    subject(:instance) { described_class.new(:attr) }
+
+    it "returns kwargs if no positional args provided" do
+      expect(instance.transformer.call(a: 2)).to eq({ a: 2 })
+    end
+
+    it "returns single value if one positional arg provided" do
+      expect(instance.transformer.call("only")).to eq("only")
+    end
+
+    it "returns all positional args if multiple provided without kwargs" do
+      expect(instance.transformer.call(1, 2, 3)).to eq([1, 2, 3])
+    end
+
+    it "returns positional args and kwargs" do
+      expect(instance.transformer.call(1, a: 2)).to eq([1, { a: 2 }])
+    end
+  end
+
+  describe "#validate_scope!" do
+    subject(:instance) { described_class.new(:attr) }
+
+    [
+      [nil, :instance],
+      %i[instance instance],
+      %i[class class]
+    ].each do |(scope, expected)|
+      it "returns :#{expected} when provided :#{scope}" do
+        expect(instance.send(:validate_scope!, scope)).to eq(expected)
+      end
+    end
+
+    it "raises an error when provided an unknown scope" do
+      expect { instance.send(:validate_scope!, :invalid) }
+        .to raise_error(Cattri::AttributeError, /Invalid scope `:invalid`/)
+    end
+  end
+end

data/spec/cattri/attribute_registry_spec.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::AttributeRegistry do
+  let(:parent_klass) do
+    Class.new do
+      include Cattri
+    end
+  end
+
+  let(:klass) do
+    Class.new(parent_klass) do
+      include Cattri
+    end
+  end
+
+  let(:context) { Cattri::Context.new(klass) }
+  let(:defer) { false }
+
+  subject(:registry) { Cattri::AttributeRegistry.new(context) }
+
+  before do
+    allow(context).to receive(:defer_definitions?).and_return(defer)
+  end
+
+  describe "#initialize" do
+    it "instantiates an AttributeRegistry instance with context" do
+      expect(registry).to be_a(Cattri::AttributeRegistry)
+      expect(registry.context).to eq(context)
+    end
+  end
+
+  describe "#registered_attributes" do
+    it "returns a Hash" do
+      expect(context.send(:__cattri_defined_methods)).to be_a(Hash)
+    end
+
+    it "returns the defined attributes" do
+      registry.define_attribute(:enabled, true)
+
+      expect(registry.registered_attributes).to be_a(Hash)
+      expect(registry.registered_attributes[:enabled]).to be_a(Cattri::Attribute)
+    end
+  end
+
+  describe "#defined_attributes" do
+    let(:parent_attribute) { Cattri::Attribute.new(:parent, defined_in: context.target) }
+    let(:attribute) { Cattri::Attribute.new(:enabled, defined_in: context.target) }
+
+    before do
+      parent_klass.send(:attribute_registry)
+                  .instance_variable_set(
+                    :@__cattri_registered_attributes,
+                    { parent_attribute.name => parent_attribute }
+                  )
+
+      registry.instance_variable_set(:@__cattri_registered_attributes, { attribute.name => attribute })
+    end
+
+    it "returns only instance-level attributes by default" do
+      expect(registry.defined_attributes.values).to eq([attribute])
+    end
+
+    it "returns all attributes, instance- and ancestor-level, when setting with_ancestors: true" do
+      expect(registry.defined_attributes(with_ancestors: true).values).to eq([parent_attribute, attribute])
+    end
+  end
+
+  describe "#fetch_attribute" do
+    it "fetches a defined attribute" do
+      registry.define_attribute(:enabled, true)
+      attribute = registry.fetch_attribute(:enabled)
+
+      expect(attribute).to be_a(Cattri::Attribute)
+      expect(attribute.name).to eq(:enabled)
+      expect(attribute.defined_in).to eq(context.target)
+    end
+
+    it "returns nil on undefined attributes" do
+      attribute = registry.fetch_attribute(:undefined)
+      expect(attribute).to be_nil
+    end
+  end
+
+  describe "#fetch_attribute!" do
+    it "fetches a defined attribute" do
+      registry.define_attribute(:enabled, true)
+      attribute = registry.fetch_attribute!(:enabled)
+
+      expect(attribute).to be_a(Cattri::Attribute)
+      expect(attribute.name).to eq(:enabled)
+      expect(attribute.defined_in).to eq(context.target)
+    end
+
+    it "raises an error on undefined attributes" do
+      expect { registry.fetch_attribute!(:undefined) }
+        .to raise_error(Cattri::AttributeError, "Attribute :undefined has not been defined")
+    end
+  end
+
+  describe "#define_attribute" do
+    it "defines an attribute" do
+      registry.define_attribute(:enabled, true)
+      attribute = registry.fetch_attribute(:enabled)
+
+      expect(attribute).to be_a(Cattri::Attribute)
+      expect(attribute.name).to eq(:enabled)
+      expect(attribute.defined_in).to eq(context.target)
+    end
+
+    it "raises an error on duplicate attribute definitions" do
+      registry.define_attribute(:enabled, true)
+
+      expect { registry.define_attribute(:enabled, true) }
+        .to raise_error(Cattri::AttributeError, "Attribute :enabled has already been defined")
+    end
+  end
+
+  describe "#copy_attributes_to" do
+    let(:target_klass) do
+      Class.new do
+        include Cattri
+      end
+    end
+
+    let!(:target_registry) { target_klass.send(:attribute_registry) }
+    let(:target_context) { Cattri::Context.new(target_klass) }
+
+    it "copies final class attributes and sets their values" do
+      registry.define_attribute(:enabled, "yes", scope: :class, final: true)
+      registry.context.target.cattri_variable_set(:@enabled, "yes")
+
+      registry.copy_attributes_to(target_context)
+
+      expect(target_klass.cattri_variable_get(:@enabled)).to eq("yes")
+      expect(target_registry.fetch_attribute(:enabled)).to be_a(Cattri::Attribute)
+    end
+
+    it "skips non-final or instance-level attributes" do
+      registry.define_attribute(:skipped1, "val", scope: :instance, final: true)
+      registry.define_attribute(:skipped2, "val", scope: :class, final: false)
+
+      expect do
+        registry.copy_attributes_to(target_context)
+      end.not_to(change { target_klass.send(:attribute_registry).defined_attributes })
+    end
+
+    it "restores original context after copying" do
+      original_context = registry.context
+      registry.copy_attributes_to(target_context)
+
+      expect(registry.context).to equal(original_context)
+    end
+  end
+
+  describe "#validate_unique!" do
+    context "when no attributes are registered" do
+      it "returns without raising" do
+        expect { registry.send(:validate_unique!, :enabled) }.not_to raise_error
+      end
+    end
+
+    context "when attribute exists in @__cattri_registered_attributes" do
+      before do
+        registry.define_attribute(:enabled, true)
+      end
+
+      it "raises an error on duplicate attribute definitions" do
+        expect { registry.send(:validate_unique!, :enabled) }
+          .to raise_error(Cattri::AttributeError, "Attribute :enabled has already been defined")
+      end
+    end
+
+    context "when @__cattri_registered_attributes is defined but attribute does not exist" do
+      before do
+        registry.define_attribute(:existing, true)
+      end
+
+      it "does not raise error for a different attribute" do
+        expect { registry.send(:validate_unique!, :something_else) }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#register_attribute" do
+    let(:attribute) { Cattri::Attribute.new(:enabled, defined_in: context.target) }
+
+    before do
+      allow(registry).to receive(:defer_definition).and_return(nil)
+      allow(registry).to receive(:apply_definition!).and_return(nil)
+    end
+
+    it "registers the attribute in __defined_attributes" do
+      expect(registry.defined_attributes).to be_empty
+
+      registry.send(:register_attribute, attribute)
+
+      expect(registry.fetch_attribute(attribute.name)).to eq(attribute)
+    end
+
+    context "when attributes are not deferred" do
+      it "applies the attribute definition" do
+        registry.send(:register_attribute, attribute)
+
+        expect(registry).not_to have_received(:defer_definition)
+        expect(registry).to have_received(:apply_definition!).with(attribute)
+      end
+    end
+
+    context "when attributes are deferred" do
+      let(:defer) { true }
+
+      it "defers the attribute definition" do
+        registry.send(:register_attribute, attribute)
+
+        expect(registry).to have_received(:defer_definition).with(attribute)
+        expect(registry).not_to have_received(:apply_definition!)
+      end
+    end
+  end
+
+  describe "#defer_definition" do
+    let(:attribute) { Cattri::Attribute.new(:enabled, defined_in: context.target) }
+
+    before do
+      allow(context).to receive(:ensure_deferred_support!)
+      allow(context.target).to receive(:defer_attribute)
+    end
+
+    it "defers the attribute definition to context" do
+      registry.send(:defer_definition, attribute)
+
+      expect(context).to have_received(:ensure_deferred_support!)
+      expect(context.target).to have_received(:defer_attribute).with(attribute)
+    end
+  end
+
+  describe "#apply_definition!" do
+    let(:attribute) { Cattri::Attribute.new(:enabled, defined_in: context.target) }
+
+    it "calls Cattri::AttributeCompiler.define_accessor" do
+      allow(Cattri::AttributeCompiler).to receive(:define_accessor)
+
+      registry.send(:apply_definition!, attribute)
+
+      expect(Cattri::AttributeCompiler).to have_received(:define_accessor).with(attribute, context)
+    end
+
+    it "raises a Cattri::AttributeError when definition fails" do
+      allow(Cattri::AttributeCompiler).to receive(:define_accessor).and_raise(TypeError, "boom")
+
+      expect { registry.send(:apply_definition!, attribute) }
+        .to raise_error(Cattri::AttributeError, "Attribute #{attribute.name} could not be defined. Error: boom")
+    end
+  end
+end