cattri 0.1.3 → 0.2.0

data/spec/cattri/deferred_attrributes_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::DeferredAttributes do
+  def define_attribute(name, value, scope: :instance)
+    Cattri::Attribute.new(name, default: value, scope: scope, defined_in: klass)
+  end
+
+  let(:klass) do
+    Class.new do
+      include Cattri
+      extend Cattri::DeferredAttributes
+    end
+  end
+
+  let(:class_attribute) { define_attribute(:class_attr, "class", scope: :class) }
+  let(:instance_attribute) { define_attribute(:instance_attr, "instance") }
+  let(:context) { Cattri::Context.new(klass) }
+
+  describe "core methods" do
+    subject { klass }
+
+    before do
+      subject.defer_attribute(class_attribute)
+      subject.defer_attribute(instance_attribute)
+    end
+
+    describe ".extended" do
+      let(:base_module) { Module.new }
+
+      it "prepends Hook if not already present" do
+        expect(base_module.singleton_class.ancestors).not_to include(Cattri::DeferredAttributes::Hook)
+
+        described_class.extended(base_module)
+
+        expect(base_module.singleton_class.ancestors).to include(Cattri::DeferredAttributes::Hook)
+      end
+
+      it "does not prepend Hook twice" do
+        described_class.extended(base_module)
+        original_ancestors = base_module.singleton_class.ancestors.dup
+
+        described_class.extended(base_module)
+
+        expect(base_module.singleton_class.ancestors).to eq(original_ancestors)
+      end
+    end
+
+    describe "defer_attribute" do
+      it "stores deferred attributes" do
+        deferred_attributes = subject.instance_variable_get(:@deferred_attributes)
+
+        expect(deferred_attributes).to include(
+          class_attribute.name => class_attribute,
+          instance_attribute.name => instance_attribute
+        )
+      end
+    end
+
+    describe "apply_deferred_attributes" do
+      before do
+        allow(Cattri::Context).to receive(:new).and_return(context)
+        allow(Cattri::AttributeCompiler).to receive(:define_accessor)
+      end
+
+      it "applies deferred attributes to the given target" do
+        subject.apply_deferred_attributes(klass)
+
+        expect(Cattri::AttributeCompiler).to have_received(:define_accessor).with(class_attribute, context)
+        expect(Cattri::AttributeCompiler).to have_received(:define_accessor).with(instance_attribute, context)
+      end
+    end
+  end
+
+  describe Cattri::DeferredAttributes::Hook do
+    let(:klass) { Class.new }
+
+    let(:plain_module) do
+      Module.new.tap do |mod|
+        mod.singleton_class.prepend(Cattri::DeferredAttributes::Hook)
+      end
+    end
+
+    let(:hook_module) do
+      Module.new do
+        extend Cattri::DeferredAttributes
+
+        def self.apply_deferred_attributes(_target)
+          @called = true
+        end
+      end
+    end
+
+    context "with hooked module" do
+      it "triggers apply_deferred_attributes (include)" do
+        klass.include(hook_module)
+        expect(hook_module.instance_variable_get(:@called)).to eq(true)
+      end
+
+      it "triggers apply_deferred_attributes (extend)" do
+        klass.extend(hook_module)
+        expect(hook_module.instance_variable_get(:@called)).to eq(true)
+      end
+    end
+
+    context "without hooked module" do
+      it "does not call apply_deferred_attributes if not defined (include)" do
+        expect { klass.include(plain_module) }.not_to raise_error
+      end
+
+      it "does not call apply_deferred_attributes if not defined (extend)" do
+        expect { klass.extend(plain_module) }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/cattri/dsl_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe Cattri::Dsl do
+  let(:registry) { instance_double(Cattri::AttributeRegistry) }
+
+  let(:klass) do
+    Class.new do
+      extend Cattri::Dsl
+
+      def self.__cattri_visibility
+        :protected
+      end
+    end
+  end
+
+  before do
+    allow(klass).to receive(:attribute_registry).and_return(registry)
+  end
+
+  describe ".cattri" do
+    it "delegates to attribute_registry.define_attribute with merged visibility" do
+      expect(registry).to receive(:define_attribute)
+        .with(:foo, 123, visibility: :protected)
+
+      klass.cattri(:foo, 123)
+    end
+
+    it "merges user-provided options with current visibility" do
+      expect(registry).to receive(:define_attribute)
+        .with(:bar, nil, visibility: :protected, final: true)
+
+      klass.cattri(:bar, nil, final: true)
+    end
+
+    it "passes through block if provided" do
+      expect(registry).to receive(:define_attribute) do |name, value, **opts, &blk|
+        expect(name).to eq(:lazy)
+        expect(value).to be_nil
+        expect(opts[:visibility]).to eq(:protected)
+        expect(blk.call).to eq(:computed)
+      end
+
+      klass.cattri(:lazy) { :computed }
+    end
+  end
+
+  describe ".final_cattri" do
+    it "calls cattri with final: true merged into options" do
+      expect(klass).to receive(:cattri)
+        .with(:token, "xyz", hash_including(final: true))
+
+      klass.final_cattri(:token, "xyz")
+    end
+
+    it "respects additional options" do
+      expect(klass).to receive(:cattri)
+        .with(:token, "xyz", hash_including(scope: :class, final: true))
+
+      klass.final_cattri(:token, "xyz", scope: :class)
+    end
+
+    it "passes block through to cattri" do
+      block = proc { "lazy!" }
+      expect(klass).to receive(:cattri).with(:val, nil, hash_including(final: true), &block)
+
+      klass.final_cattri(:val, nil, &block)
+    end
+  end
+end

data/spec/cattri/error_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::Error do
+  describe ".new" do
+    it "inherits from StandardError" do
+      expect(described_class).to be < StandardError
+    end
+
+    it "sets the message and custom backtrace" do
+      backtrace = ["custom/location.rb:42"]
+      error = described_class.new("oops", backtrace)
+
+      expect(error.message).to eq("oops")
+      expect(error.backtrace).to eq(backtrace)
+    end
+
+    it "defaults to caller backtrace if none given" do
+      error = described_class.new("default trace")
+      expect(error.backtrace).to be_an(Array)
+      expect(error.backtrace.first).to include(__FILE__)
+    end
+  end
+end
+
+RSpec.describe Cattri::AttributeError do
+  it "inherits from Cattri::Error" do
+    expect(described_class).to be < Cattri::Error
+  end
+
+  it "retains message and backtrace" do
+    error = described_class.new("bad attr", ["attr.rb:1"])
+    expect(error.message).to eq("bad attr")
+    expect(error.backtrace).to eq(["attr.rb:1"])
+  end
+end

data/spec/cattri/inheritance_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::Inheritance do
+  let(:base_class) do
+    Class.new.tap do |klass|
+      klass.include(Cattri::ContextRegistry)
+      klass.singleton_class.include(Cattri::ContextRegistry)
+
+      klass.attr_reader :inherited_called_with
+
+      def klass.inherited(subclass)
+        @inherited_called_with = subclass
+      end
+
+      def klass.inherited_called_with # rubocop:disable Style/TrivialAccessors
+        @inherited_called_with
+      end
+    end
+  end
+
+  before do
+    allow(Cattri::Context).to receive(:new).and_call_original
+    allow_any_instance_of(Cattri::AttributeRegistry).to receive(:copy_attributes_to)
+  end
+
+  describe ".install" do
+    it "preserves and calls existing inherited method" do
+      Cattri::Inheritance.install(base_class)
+
+      subclass = Class.new(base_class) # triggers inherited hook
+
+      expect(base_class.inherited_called_with).to eq(subclass)
+    end
+
+    it "initializes a Cattri::Context for the subclass" do
+      Cattri::Inheritance.install(base_class)
+
+      expect(Cattri::Context).to receive(:new) do |actual_subclass|
+        expect(actual_subclass.superclass).to eq(base_class)
+      end
+
+      Class.new(base_class)
+    end
+
+    it "invokes copy_attributes_to with the subclass context" do
+      context = instance_double(Cattri::Context)
+      allow(Cattri::Context).to receive(:new).and_return(context)
+
+      registry = instance_double(Cattri::AttributeRegistry)
+      allow(base_class).to receive(:attribute_registry).and_return(registry)
+
+      expect(registry).to receive(:copy_attributes_to).with(context)
+
+      Cattri::Inheritance.install(base_class)
+      Class.new(base_class)
+    end
+  end
+end

data/spec/cattri/initializer_patch_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::InitializerPatch do
+  let(:klass) do
+    Class.new do
+      include Cattri
+
+      cattri :final_attr, -> { "default-final" }, final: true
+      cattri :regular_attr, -> { "default-regular" }
+
+      def initialize(preset: nil)
+        self.final_attr = preset if preset
+      end
+    end
+  end
+
+  subject(:instance) { klass.new }
+
+  describe "#initialize (via InitializerPatch)" do
+    it "sets the default value for final attribute if unset" do
+      expect(instance.final_attr).to eq("default-final")
+    end
+
+    it "does not override a final value if already set in initialize" do
+      custom = klass.new(preset: "explicit")
+      expect(custom.final_attr).to eq("explicit")
+    end
+
+    it "does not set default for non-final attributes" do
+      expect(instance.cattri_variable_defined?(:regular_attr)).to be false
+    end
+  end
+end

data/spec/cattri/internal_store_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::InternalStore do
+  let(:klass) do
+    Class.new do
+      include Cattri::InternalStore
+
+      public :normalize_ivar, :__cattri_store, :__cattri_set_variables
+    end
+  end
+
+  subject(:instance) { klass.new }
+
+  describe "#cattri_variable_defined?" do
+    it "returns false when variable is not set" do
+      expect(instance.cattri_variable_defined?(:foo)).to be false
+    end
+
+    it "returns true when variable is set" do
+      instance.cattri_variable_set(:foo, 123)
+      expect(instance.cattri_variable_defined?(:foo)).to be true
+    end
+  end
+
+  describe "#cattri_variable_get" do
+    it "returns nil when variable is not set" do
+      expect(instance.cattri_variable_get(:bar)).to be_nil
+    end
+
+    it "returns the value when variable is set" do
+      instance.cattri_variable_set(:bar, "hello")
+      expect(instance.cattri_variable_get(:bar)).to eq("hello")
+    end
+  end
+
+  describe "#cattri_variable_set" do
+    it "sets the value for a variable" do
+      instance.cattri_variable_set(:baz, 42)
+      expect(instance.cattri_variable_get(:baz)).to eq(42)
+    end
+
+    it "tracks the variable as explicitly set" do
+      instance.cattri_variable_set(:baz, 42)
+      expect(instance.__cattri_set_variables).to include(:baz)
+    end
+
+    it "normalizes the key (removes @ and converts to symbol)" do
+      instance.cattri_variable_set("@qux", 99)
+      expect(instance.__cattri_store).to have_key(:qux)
+    end
+
+    it "raises if modifying a final value" do
+      instance.cattri_variable_set(:locked, "a", final: true)
+
+      expect do
+        instance.cattri_variable_set(:locked, "b", final: true)
+      end.to raise_error(Cattri::AttributeError, /Cannot modify final attribute :locked/)
+    end
+  end
+
+  describe "#cattri_variable_memoize" do
+    it "memoizes value if not already set" do
+      result = instance.cattri_variable_memoize(:lazy) { "computed" }
+
+      expect(result).to eq("computed")
+      expect(instance.cattri_variable_get(:lazy)).to eq("computed")
+    end
+
+    it "returns existing value if already set" do
+      instance.cattri_variable_set(:lazy, "preset")
+      result = instance.cattri_variable_memoize(:lazy) { "should not run" }
+
+      expect(result).to eq("preset")
+    end
+  end
+
+  describe "#__cattri_store" do
+    it "returns a Hash" do
+      expect(instance.__cattri_store).to be_a(Hash)
+    end
+
+    it "memoizes the store" do
+      expect(instance.__cattri_store).to equal(instance.__cattri_store)
+    end
+  end
+
+  describe "#__cattri_set_variables" do
+    it "returns a Set" do
+      expect(instance.__cattri_set_variables).to be_a(Set)
+    end
+
+    it "memoizes the set" do
+      expect(instance.__cattri_set_variables).to equal(instance.__cattri_set_variables)
+    end
+  end
+
+  describe "#normalize_ivar" do
+    it "converts string with @ to symbol without @" do
+      expect(instance.normalize_ivar("@name")).to eq(:name)
+    end
+
+    it "converts plain string to symbol" do
+      expect(instance.normalize_ivar("email")).to eq(:email)
+    end
+
+    it "converts symbol to symbol" do
+      expect(instance.normalize_ivar(:age)).to eq(:age)
+    end
+
+    it "freezes the returned symbol" do
+      sym = instance.normalize_ivar("cool")
+      expect(sym).to be_frozen
+    end
+  end
+
+  describe "#guard_final!" do
+    it "raises if key is defined and final" do
+      instance.__cattri_store[:foo] = Cattri::AttributeValue.new("sealed", true)
+      expect do
+        instance.send(:guard_final!, :foo)
+      end.to raise_error(Cattri::AttributeError, /Cannot modify final attribute :foo/)
+    end
+
+    it "does nothing if key is not defined" do
+      expect do
+        instance.send(:guard_final!, :bar)
+      end.not_to raise_error
+    end
+
+    it "does nothing if key is defined but not final" do
+      instance.__cattri_store[:baz] = Cattri::AttributeValue.new("open", false)
+      expect do
+        instance.send(:guard_final!, :baz)
+      end.not_to raise_error
+    end
+  end
+end

data/spec/cattri/introspection_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri::Introspection do
+  let(:klass) do
+    Class.new do
+      include Cattri
+      cattri :foo, 123
+    end
+  end
+
+  let(:subclass) do
+    Class.new(klass) do
+      include Cattri::Introspection
+      cattri :bar, "bar"
+    end
+  end
+
+  before do
+    klass.include(Cattri::Introspection)
+  end
+
+  describe ".attribute_defined?" do
+    it "returns true for defined attributes" do
+      expect(klass.attribute_defined?(:foo)).to be true
+    end
+
+    it "returns false for unknown attributes" do
+      expect(klass.attribute_defined?(:missing)).to be false
+    end
+  end
+
+  describe ".attribute" do
+    it "returns the attribute definition" do
+      attr = klass.attribute(:foo)
+      expect(attr).to be_a(Cattri::Attribute)
+      expect(attr.name).to eq(:foo)
+    end
+
+    it "returns nil for unknown attributes" do
+      expect(klass.attribute(:missing)).to be_nil
+    end
+  end
+
+  describe ".attributes" do
+    it "lists local attributes by default" do
+      expect(subclass.attributes).to eq([:bar])
+    end
+
+    it "includes inherited attributes when requested" do
+      expect(subclass.attributes(with_ancestors: true)).to match_array(%i[foo bar])
+    end
+  end
+
+  describe ".attribute_definitions" do
+    it "returns a hash of defined attributes" do
+      defs = subclass.attribute_definitions
+      expect(defs).to be_a(Hash)
+      expect(defs).to have_key(:bar)
+      expect(defs[:bar]).to be_a(Cattri::Attribute)
+    end
+
+    it "includes ancestors if requested" do
+      defs = subclass.attribute_definitions(with_ancestors: true)
+      expect(defs).to have_key(:foo)
+      expect(defs[:foo]).to be_a(Cattri::Attribute)
+    end
+  end
+
+  describe ".attribute_methods" do
+    it "returns a hash of methods per attribute" do
+      methods = subclass.attribute_methods
+      expect(methods).to be_a(Hash)
+      expect(methods.keys).to include(:bar)
+      expect(methods[:bar]).to include(:bar)
+    end
+  end
+
+  describe ".attribute_source" do
+    it "returns the class where the attribute was originally defined" do
+      expect(subclass.attribute_source(:foo)).to eq(klass)
+      expect(subclass.attribute_source(:bar)).to eq(subclass)
+    end
+
+    it "returns nil for unknown attributes" do
+      expect(subclass.attribute_source(:missing)).to be_nil
+    end
+  end
+end

data/spec/cattri/visibility_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "cattri/visibility"
+
+RSpec.describe Cattri::Visibility do
+  let(:klass) do
+    Class.new do
+      extend Cattri::Visibility
+    end
+  end
+
+  describe "#__cattri_visibility" do
+    it "defaults to public" do
+      expect(klass.send(:__cattri_visibility)).to eq(:public)
+    end
+  end
+
+  describe "#public" do
+    it "sets visibility to public when no args are passed" do
+      klass.protected
+      klass.public
+
+      expect(klass.send(:__cattri_visibility)).to eq(:public)
+    end
+
+    it "delegates to Module#public when args are passed" do
+      klass.class_eval do
+        def sample_method; end
+      end
+
+      expect { klass.public :sample_method }.not_to raise_error
+      expect(klass.public_instance_methods).to include(:sample_method)
+    end
+  end
+
+  describe "#protected" do
+    it "sets visibility to protected when no args are passed" do
+      klass.protected
+      expect(klass.send(:__cattri_visibility)).to eq(:protected)
+    end
+
+    it "delegates to Module#protected when args are passed" do
+      klass.class_eval do
+        def protected_method; end
+      end
+
+      expect { klass.protected :protected_method }.not_to raise_error
+      expect(klass.protected_instance_methods).to include(:protected_method)
+    end
+  end
+
+  describe "#private" do
+    it "sets visibility to private when no args are passed" do
+      klass.private
+      expect(klass.send(:__cattri_visibility)).to eq(:private)
+    end
+
+    it "delegates to Module#private when args are passed" do
+      klass.class_eval do
+        def private_method; end
+      end
+
+      expect { klass.private :private_method }.not_to raise_error
+      expect(klass.private_instance_methods).to include(:private_method)
+    end
+  end
+end

data/spec/cattri_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cattri do
+  let(:klass) do
+    Class.new do
+      include Cattri
+
+      cattri :token, -> { "abc123" }
+      cattri :final_token, -> { "321cba" }, final: true
+    end
+  end
+
+  subject(:instance) { klass.new }
+
+  describe "including Cattri" do
+    it "defines a working accessor" do
+      expect(instance.token).to eq("abc123")
+      instance.token = "xyz"
+      expect(instance.token).to eq("xyz")
+    end
+
+    it "respects default visibility (public)" do
+      expect(klass.public_instance_methods).to include(:token, :token=)
+    end
+
+    it "installs initializer patch for default assignment" do
+      expect(instance.cattri_variable_defined?(:final_token)).to be true
+      expect(instance.cattri_variable_get(:final_token)).to eq("321cba")
+    end
+  end
+
+  describe ".with_cattri_introspection" do
+    let(:introspective_class) do
+      Class.new do
+        include Cattri
+        cattri :id, "foo"
+
+        with_cattri_introspection
+      end
+    end
+
+    it "adds .attribute_defined?" do
+      expect(introspective_class.attribute_defined?(:id)).to be true
+      expect(introspective_class.attribute_defined?(:missing)).to be false
+    end
+
+    it "returns attribute source and methods" do
+      expect(introspective_class.attribute_source(:id)).to eq(introspective_class)
+      expect(introspective_class.attribute_methods).to include(:id)
+    end
+  end
+end

data/spec/simplecov_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "simplecov"
+require "simplecov-cobertura"
+require "simplecov-html"
+
+SimpleCov.formatters = [
+  SimpleCov::Formatter::CoberturaFormatter,
+  SimpleCov::Formatter::HTMLFormatter
+]
+
+SimpleCov.start do
+  enable_coverage :branch
+
+  track_files "lib/cattri/**/*.rb"
+
+  add_filter "lib/cattri/version.rb"
+  add_filter "/spec/"
+end
+
+SimpleCov.minimum_coverage 100