attributes_dsl 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da436a8b36ce35a3c4b4b87b33ed84a03a7dd910
-  data.tar.gz: 8d7edd3acf452eff9b4255a15a16cfee6f1d00d1
+  metadata.gz: a0a8b2957544474ff4116fd2b6d1703de977ba74
+  data.tar.gz: b61d244f9ea674fdff84404e269dfa083fca6f64
 SHA512:
-  metadata.gz: 63ea9addb5f796e1009f0140cc3523b4be461c280811d19b878edb3247ae5e1abe9f1cda60a05c703dfe7c28558bbf2868e2432c0b5957bce0d6ab15b0a8b408
-  data.tar.gz: e2555ba15ad33fbadbded4f29c0936687e23273ca534de57a9af3767a82f0a3372561d39c1145ec0031ca44f6afe4b0168d871173573c1b41b2f27ecc722fe74
+  metadata.gz: de35390efe7b4feb77a049d040884615e11c5de61e9d8cb3bb595fbf2b71a0b0e3d53b5dd78425c6e775774366bb39cd538b5b6fa3e1af6c67e61ec03863669d
+  data.tar.gz: 213cac8c92f35d396ce1272b53baace3a03ee635521e573cf039c85fd72bf4f43f384f46ae7d958188f9ca1d6c3424f82bc992e82c94b7fecd5221c6f10fbff4

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## version 0.0.2 2015-09-11
+
+This version is a result of applying v0.0.1 to the existing gems:
+
+* [abstract_mapper](https://github.com/nepalez/abstract_mapper)
+* [query_builder](https://github.com/nepalez/query_builder)
+* [rom-kafka](https://github.com/nepalez/rom-kafka) (WIP)
+
+### Added
+
+* Support for inheritance of attributes (nepalez)
+
+### Bugs fixed
+
+* Allow initializer to be used without arguments (nepalez)
+* Allow attributes to be redefined (nepalez)
+* Remove `AttributesDSL#new` and move its logics to the initializer (nepalez)
+
+[Compare v0.0.1...v0.0.2](https://github.com/nepalez/attributes_dsl/compare/v0.0.1...v0.0.2)
+
 ## version 0.0.1 2015-09-10
 
 This is the first published version

data/README.md

@@ -60,13 +60,18 @@ user = User.new(sex: :women, age: "26", place: "Moscow")
 Additional Details
 ------------------
 
+### Attribute declaration
+
 The `attribute` class method takes the `name` and 2 options:
+
 - `:default` for the default value (otherwise `nil`);
 - `:required` to declare the attribute as required. It will be ignored if a default value is provided!
 
 It is also takes the block, used to coerce a value. The coercer is applied to the default value too.
 
-Also notice, that instance methods (like `#name`) are just aliases for the corresponding value of the `#attributes` hash. Instance variables aren't defined for them (to ensure syncronization between `#name` and `#attributes[:name]`):
+### Instance methods
+
+Instance methods (like `#name`) are just aliases for the corresponding value of the `#attributes` hash. Instance variables aren't defined for them (to ensure syncronization between `#name` and `#attributes[:name]`):
 
 ```ruby
 user = User.new(name: "John")
@@ -77,6 +82,39 @@ user.name # => :John
 user.instance_variable_get :@name # => nil
 ```
 
+### Inheritance
+
+Subclasses inherits attributes of the superclass:
+
+```ruby
+class UserWithRole < User
+  attribute :role, default: :user
+end
+
+user = UserWithRole.new(name: "Sam")
+user.attributes
+# => { name: :Sam, sex: :male, age: 0, position: nil, role: :user }
+```
+
+### Undefining Attributes
+
+This feature is not available (and it won't be).
+
+The reason is that a subclass should satisfy a contract of its superclass, including the existence of attributes, declared by the superclass.
+All you can do is reload attribute definition in a subclass:
+
+```ruby
+class Person < User
+  attribute :name, &:to_s
+end
+
+user = Person.new(name: :Sam)
+user.attributes
+# => { name: "Sam", sex: :male, age: 0, position: nil }
+```
+
+### Freezing
+
 You're free to redefine attributes (class settings are used by the initializer only):
 
 ```ruby
@@ -122,20 +160,20 @@ The results are following:
 
 ```
 -------------------------------------------------
-               anima    202.863k (± 5.1%) i/s -      1.023M
-              kwattr    171.461k (± 5.3%) i/s -    855.680k
-     fast_attributes    156.596k (± 2.5%) i/s -    785.792k
-      attributes_dsl     58.966k (± 4.6%) i/s -    296.514k
-         active_attr     58.322k (± 2.8%) i/s -    293.205k
-              virtus     45.734k (± 2.7%) i/s -    228.960k
+               anima    211.638k (± 3.7%) i/s -      1.071M
+              kwattr    187.276k (± 3.6%) i/s -    947.484k
+     fast_attributes    160.916k (± 2.4%) i/s -    816.726k
+      attributes_dsl     71.850k (± 3.0%) i/s -    365.365k
+         active_attr     71.489k (± 3.6%) i/s -    357.995k
+              virtus     45.554k (± 7.1%) i/s -    229.338k
 
 Comparison:
-               anima:   202862.9 i/s
-              kwattr:   171460.9 i/s - 1.18x slower
-     fast_attributes:   156596.3 i/s - 1.30x slower
-      attributes_dsl:    58966.5 i/s - 3.44x slower
-         active_attr:    58321.6 i/s - 3.48x slower
-              virtus:    45734.3 i/s - 4.44x slower
+               anima:   211637.9 i/s
+              kwattr:   187276.2 i/s - 1.13x slower
+     fast_attributes:   160916.1 i/s - 1.32x slower
+      attributes_dsl:    71850.0 i/s - 2.95x slower
+         active_attr:    71489.1 i/s - 2.96x slower
+              virtus:    45553.8 i/s - 4.65x slower
 ```
 
 Results above are pretty reasonable.
@@ -144,7 +182,7 @@ The gem is faster than `virtus` that has many additional features.
 
 It is as fast as `active_attrs` (but has more customizable coercers).
 
-It is 2 times slower than `fast_attributes` that has no coercer and default values. And it is 3-3.5 times slower than `anima` and `kwattr` that provides only the base settings.
+It is 2 times slower than `fast_attributes` that has no coercer and default values. And it is 3 times slower than `anima` and `kwattr` that provides only the base settings.
 
 Installation
 ------------

data/benchmark/run.rb

@@ -94,28 +94,28 @@ end
 Benchmark.ips do |x|
   x.config time: 5, warmup: 5
 
-  x.report("attributes_dsl") do
-    AttributesDSLExample.call
-  end
-
-  x.report("virtus") do
-    VirtusExample.call
+  x.report("anima") do
+    AnimaExample.call
   end
 
-  x.report("active_attr") do
-    AttributesDSLExample.call
+  x.report("kwattr") do
+    KwattrExample.call
   end
 
   x.report("fast_attributes") do
     FastAttributesExample.call
   end
 
-  x.report("anima") do
-    AnimaExample.call
+  x.report("attributes_dsl") do
+    AttributesDSLExample.call
   end
 
-  x.report("kwattr") do
-    KwattrExample.call
+  x.report("active_attr") do
+    AttributesDSLExample.call
+  end
+
+  x.report("virtus") do
+    VirtusExample.call
   end
 
   x.compare!

data/lib/attributes_dsl.rb

@@ -56,24 +56,17 @@ module AttributesDSL
     define_method(s_name) { attributes.fetch(s_name) }
   end
 
-  # Object contstructor that filters hash of attributes
-  #
-  # @param [Hash] hash The hash of attributes to be assinged
-  #
-  # @return [Object]
-  #
-  # @raise [ArgumentError] in case a required attribute is missed
-  #
-  def new(hash)
-    super attributes.extract(hash)
-  end
-
   # @private
   def self.extended(klass)
     # use __send__ for compatibility to 1.9.3 (where `.include` was private)
     klass.__send__(:include, InstanceMethods)
   end
 
+  # @private
+  def inherited(klass)
+    klass.instance_variable_set(:@attributes, attributes)
+  end
+
   # Defines instance methods for the hash of attributes and its initializer
   module InstanceMethods
 
@@ -85,12 +78,12 @@ module AttributesDSL
 
     # Initializes the object and sets the hash of its [#attributes]
     #
-    # Uses attributes prepared by [.new]
-    #
     # @param [Hash] attributes
     #
-    def initialize(attributes)
-      @attributes = attributes
+    # @raise [ArgumentError] in case a required attribute is missed
+    #
+    def initialize(attributes = {})
+      @attributes = self.class.attributes.extract(attributes)
     end
 
   end # module InstanceMethods

data/lib/attributes_dsl/attributes.rb

@@ -21,10 +21,10 @@ module AttributesDSL
 
     # Initializes an immutable collection with an initial set of attributes
     #
-    # @param [Set] attributes
+    # @param [Hash] attributes
     #
-    def initialize(attributes = nil)
-      @attributes = Set.new attributes
+    def initialize(attributes = {})
+      @attributes = attributes
       IceNine.deep_freeze(self)
     end
 
@@ -36,7 +36,9 @@ module AttributesDSL
     # @return [AttributesDSL::Attributes]
     #
     def register(name, options = {}, &coercer)
-      self.class.new(attributes.to_a << Attribute.new(name, options, &coercer))
+      self.class.new(
+        attributes.merge(name => Attribute.new(name, options, &coercer))
+      )
     end
 
     # Extracts instance attributes from the input hash
@@ -59,13 +61,13 @@ module AttributesDSL
 
     def validate(input)
       undefined = required - input.keys
-      return attributes if undefined.empty?
+      return attributes.values if undefined.empty?
 
       fail ArgumentError.new "Undefined attributes: #{undefined.join(", ")}"
     end
 
     def required
-      attributes.select(&:required).map(&:name)
+      attributes.values.select(&:required).map(&:name)
     end
 
   end # class Attributes

data/lib/attributes_dsl/version.rb

@@ -4,6 +4,6 @@ module AttributesDSL
 
   # The semantic version of the module.
   # @see http://semver.org/ Semantic versioning 2.0
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
 
 end # module AttributesDSL

data/spec/integration/attributes_dsl_spec.rb

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

data/spec/unit/attributes_spec.rb

@@ -14,19 +14,25 @@ describe AttributesDSL::Attributes do
   describe "#attributes" do
     subject { attributes.attributes }
 
-    it { is_expected.to be_kind_of Set }
+    it { is_expected.to be_kind_of Hash }
     it { is_expected.to be_empty }
   end # describe #attributes
 
   describe "#register" do
-    subject { attributes.register(:foo, default: :FOO, &coercer) }
+    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 "registers the attribute" do
-      attribute = subject.attributes.first
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attributes_dsl
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Andrew Kozin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-10 00:00:00.000000000 Z
+date: 2015-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ice_nine