attributes_dsl 0.0.2 → 0.1.0

data/spec/integration/attributes_dsl_spec.rb

@@ -1,76 +0,0 @@
-# encoding: utf-8
-
-describe AttributesDSL do
-
-  let(:coercer) { -> value { value.to_s } }
-  let(:klass) { Class.new { extend AttributesDSL } }
-
-  before do
-    klass.attribute(:foo, &:to_s)
-    klass.attribute("bar")
-    klass.attribute(:baz, &:to_i)
-  end
-
-  subject { klass.new(arguments) }
-
-  describe "instance" do
-
-    context "without arguments" do
-      subject { klass.new }
-
-      it "initializes default attributes" do
-        expect(subject.attributes).to eql(foo: "", bar: nil, baz: 0)
-      end
-    end
-
-    context "when all required attributes are set" do
-      let(:arguments) { { bar: :BAR, baz: "42" } }
-      let(:klass) do
-        Class.new do
-          extend AttributesDSL
-
-          def initialize(attributes = {})
-            super
-            IceNine.deep_freeze(self)
-          end
-        end
-      end
-
-      it "initializes attributes" do
-        expect(subject.attributes).to eql(foo: "", bar: :BAR, baz: 42)
-      end
-
-      it "defines methods for every attribute" do
-        expect(subject.foo).to eql ""
-        expect(subject.bar).to eql :BAR
-        expect(subject.baz).to eql 42
-      end
-
-      it "doesn't freeze argument" do
-        expect { subject }.not_to change { arguments.frozen? }
-      end
-    end
-
-    context "when a required attribute is missed" do
-      let(:arguments) { { foo: :FOO, baz: "42" } }
-
-      before { klass.attribute("bar", required: true) }
-
-      it "fails" do
-        expect { subject }.to raise_error ArgumentError
-      end
-    end
-
-  end # describe instance
-
-  describe "subclass" do
-
-    subject { Class.new(klass) }
-
-    it "inherits parent attributes" do
-      expect(subject.new.attributes).to eql(klass.new.attributes)
-    end
-
-  end # describe subclass
-
-end # describe AttributesDSL

data/spec/unit/attribute_spec.rb

@@ -1,126 +0,0 @@
-# encoding: utf-8
-
-describe AttributesDSL::Attribute do
-
-  let(:attribute) do
-    described_class.new(name, default: default, required: required, &coercer)
-  end
-
-  let(:name)     { :foo }
-  let(:default)  { "FOO" }
-  let(:required) { true }
-  let(:coercer)  { -> v { v.to_s } }
-
-  describe ".new" do
-    subject { attribute }
-
-    it { is_expected.to be_frozen }
-  end # describe .new
-
-  describe "#name" do
-    subject { attribute.name }
-
-    it { is_expected.to eql name.to_sym }
-  end # describe #name
-
-  describe "#default" do
-    subject { attribute.default }
-
-    context "when value is given" do
-      it { is_expected.to eql default }
-    end
-
-    context "when value isn't set" do
-      let(:attribute) { described_class.new name }
-
-      it { is_expected.to be_nil }
-    end
-  end # describe #default
-
-  describe "#required" do
-    subject { attribute.required }
-
-    context "when set to true without default value" do
-      let(:attribute) { described_class.new name, required: true }
-
-      it { is_expected.to eql true }
-    end
-
-    context "when set to true with default value" do
-      let(:attribute) { described_class.new name, required: true, default: 1 }
-
-      it { is_expected.to eql false }
-    end
-
-    context "when value isn't set" do
-      let(:attribute) { described_class.new name }
-
-      it { is_expected.to eql false }
-    end
-  end # describe #required
-
-  describe "#coercer" do
-    subject { attribute.coercer }
-
-    context "when block is given" do
-      it { is_expected.to eql coercer }
-    end
-
-    context "when block isn't given" do
-      let(:attribute) { described_class.new name }
-
-      it { is_expected.to be_nil }
-    end
-  end # describe #coercer
-
-  describe "#value" do
-    subject { attribute.value(1) }
-
-    context "when coercer is given" do
-      it "uses the coercer" do
-        expect(subject).to eql "1"
-      end
-    end
-
-    context "when coercer isn't given" do
-      let(:attribute) { described_class.new name }
-
-      it "returns the input" do
-        expect(subject).to eql 1
-      end
-    end
-  end # describe #value
-
-  describe "#==" do
-    subject { attribute == other }
-
-    context "with the same name" do
-      let(:other) { described_class.new name }
-
-      it { is_expected.to eql true }
-    end
-
-    context "with another name" do
-      let(:other) { described_class.new :bar }
-
-      it { is_expected.to eql false }
-    end
-  end # describe #==
-
-  describe "#eql?" do
-    subject { attribute.eql? other }
-
-    context "with the same name" do
-      let(:other) { described_class.new name }
-
-      it { is_expected.to eql true }
-    end
-
-    context "with another name" do
-      let(:other) { described_class.new :bar }
-
-      it { is_expected.to eql false }
-    end
-  end # describe #eql?
-
-end # describe AttributesDSL::Attribute

data/spec/unit/attributes_spec.rb

@@ -1,82 +0,0 @@
-# encoding: utf-8
-
-describe AttributesDSL::Attributes do
-
-  let(:attributes) { described_class.new }
-  let(:coercer)    { -> value { value.to_s } }
-
-  describe ".new" do
-    subject { attributes }
-
-    it { is_expected.to be_frozen }
-  end # describe .new
-
-  describe "#attributes" do
-    subject { attributes.attributes }
-
-    it { is_expected.to be_kind_of Hash }
-    it { is_expected.to be_empty }
-  end # describe #attributes
-
-  describe "#register" do
-    subject do
-      attributes.register(:bar).register(:foo, default: :FOO, &coercer)
-    end
-
-    it "returns new collection" do
-      expect(subject).to be_kind_of described_class
-    end
-
-    it "adds attributes" do
-      expect(subject.attributes.keys).to contain_exactly(:bar, :foo)
-    end
-
-    it "uses arguments" do
-      attribute = subject.attributes[:foo]
-
-      expect(attribute).to be_kind_of AttributesDSL::Attribute
-      expect(attribute.name).to eql :foo
-      expect(attribute.default).to eql :FOO
-      expect(attribute.coercer).to eql coercer
-    end
-
-    context "without options" do
-      subject { attributes.register :foo }
-
-      it { is_expected.to be_kind_of described_class }
-    end
-  end # describe #register
-
-  describe "#extract" do
-    subject { attributes.extract hash }
-
-    let(:hash) { { bar: :BAR } }
-    let(:attributes) do
-      described_class
-        .new
-        .register(:foo, required: true, &coercer)
-        .register(:bar, required: true)
-        .register(:baz, default: :BAZ, &coercer)
-    end
-
-    context "when all required attributes are present" do
-      let(:hash) { { foo: :FOO, bar: :BAR, qux: :QUX } }
-
-      it "returns a proper hash" do
-        expect(subject).to eql(foo: "FOO", bar: :BAR, baz: "BAZ")
-      end
-    end
-
-    context "when a required attribute is absent" do
-      let(:hash) { { baz: :BAZ } }
-
-      it "fails" do
-        expect { subject }.to raise_error do |error|
-          expect(error).to be_kind_of ArgumentError
-          expect(error.message).to eql "Undefined attributes: foo, bar"
-        end
-      end
-    end
-  end # describe #extract
-
-end # describe AttributeDSL::Attributes