attributable 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c22dc4806f8e50155cb39df375de2e883edfb086
-  data.tar.gz: 5edda9c0de87966920404d14b07a8ca78e395657
+  metadata.gz: ff3f791c159b7f77582d20aea0a0a2a608bf0089
+  data.tar.gz: 73fbc9b201af71fc14149c134ea87e55d88f01e7
 SHA512:
-  metadata.gz: b50d6942f2276f8571991bb33470191cceb7a215bc78d0e5318466249bba357c443a3e244db843b09ae8a582fdade35e03492666f29eecd1eccc43ebb4f02e77
-  data.tar.gz: ee3fad3f3cffafc5fe94d0ef27c56c590e06cbbcc8708f73aa51fe1e0a429b2179b471a3cea5259df251428d45003265476c2e13abc800f5019f477e6be724c0
+  metadata.gz: 86a48e5ec8a1e34b2c3535194a947d4a9f4ec4fdc0d571873cac0586392c0840c63f61fd5067273e31254db98f9828aa07731dea69d61626a022f6428cf9f451
+  data.tar.gz: 667d00b4f7c7bff03e151da759f2d6e75e773154627ec39a84f7c6e9e47159c779365935e813b2fd87e6a305bbf4db5155722f97e59bc86daedd78e333803ea0

data/README.md

@@ -98,31 +98,53 @@ Note that, by default, Attributable adds the following `initialize` method:
       initialize_attributes(attributes)
     end
 
-## Specialisation
+## Reuse via inheritance and mix-ins
 
-To allow reuse of attribute declarations, Attributable provides the `specialises` class method.
+To reuse attribute declarations, either user Ruby's built-in inheritance, mix-ins, or both:
 
+    class Author < User
+      attributes blogs: []
+    end
+    
+    ronson = Author.new(forename: "Jon", surname: "Ronson")
+    ronson.inspect # => <Author forename="Jon", surname="Ronson", blogs=[]>
+    
+The default values defined in superclasses or mixed-in modules can be changed:
+
+    class Ronson < User
+      attributes surname: "Ronson"
+    end
+
+    Ronson.new(forename: "Jon").inspect # <Ronson forename="Jon", surname="Ronson">
+    Ronson.new(forename: "Mark").inspect # <Ronson forename="Mark", surname="Ronson">
+
+Here's the same example, but using a module:
+
+    module User
+      extend Attributable
+  
+      attributes :forename, :surname
+    end
+    
     class Author
+      include User
       extend Attributable
-      
-      specialises User
       attributes blogs: []
     end
     
     ronson = Author.new(forename: "Jon", surname: "Ronson")
     ronson.inspect # => <Author forename="Jon", surname="Ronson", blogs=[]>
     
-Specialising classes can override the defaults set in specialised classes.
-
     class Ronson
+      include User
       extend Attributable
-
-      specialises User
       attributes surname: "Ronson"
     end
-
+    
     Ronson.new(forename: "Jon").inspect # <Ronson forename="Jon", surname="Ronson">
     Ronson.new(forename: "Mark").inspect # <Ronson forename="Mark", surname="Ronson">
+    
+__Note__: the `include` must occur before any call to `attributes`.
 
 ### Automatic specialisation for superclasses
 

data/lib/attributable.rb

@@ -2,24 +2,22 @@ require "attributable/version"
 
 module Attributable
   def attributes(*without_defaults, **with_defaults)
-    @predefined_attributes ||= {}
-    @predefined_attributes = @predefined_attributes.merge(from(without_defaults, with_defaults))
-    add_instance_methods(@predefined_attributes)
+    @attributes ||= {}
+    @attributes.merge!(attributes_from(superclass)) if respond_to?(:superclass)
+    @attributes.merge!(attributes_from(*included_modules))
+    @attributes.merge!(from(without_defaults, with_defaults))
+    add_instance_methods(@attributes)
   end
 
-  def specialises(clazz)
-    unless clazz.kind_of? Attributable
-      fail ArgumentError, "specialisation requires a class that extends Attributable"
-    end
+  private
 
-    super_attributes = clazz.new.instance_variable_get(:@attributes)
-    @predefined_attributes ||= {}
-    @predefined_attributes = super_attributes.merge(@predefined_attributes)
-    add_instance_methods(@predefined_attributes)
+  def attributes_from(*modules)
+    modules
+      .select { |m| m.kind_of?(Attributable) }
+      .map { |m| m.instance_variable_get(:@attributes) }
+      .reduce({}, &:merge)
   end
 
-  private
-
   # Converts a list of attribute names and a hash of attribute names to default values
   # to a hash of attribute names to default values
   def from(without_defaults, with_defaults)
@@ -29,24 +27,23 @@ module Attributable
     end
   end
 
-  def add_instance_methods(predefined_attributes)
-    add_constructor(predefined_attributes)
-    add_accessors(predefined_attributes.keys)
-    add_equality_methods(predefined_attributes.keys)
-    add_inspect_method(predefined_attributes.keys)
+  def add_instance_methods(attributes)
+    add_constructor(attributes)
+    add_accessors(attributes.keys)
+    add_equality_methods(attributes.keys)
+    add_inspect_method(attributes.keys)
   end
 
-  def add_constructor(predefined_attributes)
-    define_method "initialize" do |attributes = {}|
-      initialize_attributes(attributes)
+  def add_constructor(attributes)
+    define_method "initialize" do |values = {}|
+      initialize_attributes(values)
     end
 
-    define_method "initialize_attributes" do |attributes = {}|
-      if self.class.superclass.kind_of? Attributable
-        super_attributes = self.class.superclass.new.instance_variable_get(:@attributes)
-        predefined_attributes = super_attributes.merge(predefined_attributes)
-      end
-      @attributes = predefined_attributes.merge(attributes)
+    define_method "initialize_attributes" do |values = {}|
+      unknown_keys = values.keys - attributes.keys
+      fail KeyError, "Unknown attributes: #{(unknown_keys).join(", ")}" unless unknown_keys.empty?
+
+      @attributes = attributes.merge(values)
     end
   end
 

data/lib/attributable/version.rb

@@ -1,3 +1,3 @@
 module Attributable
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/spec/attributable/accessors_spec.rb

@@ -7,7 +7,7 @@ end
 
 describe Attributable do
   describe "accessors" do
-    it "should raise for an unknown attribute" do
+    it "should not have an accessor for an unknown attribute" do
       i = User.new(id: 1, forename: "John", surname: "Doe")
       expect(i.respond_to?(:address)).to be_false
     end

data/spec/attributable/construction_spec.rb

@@ -5,17 +5,6 @@ class User
   attributes :id, :forename, surname: "Bloggs"
 end
 
-class UserWithDerivedAttribute
-  extend Attributable
-  attributes :id, :forename, surname: "Bloggs"
-  attr_reader :fullname
-
-  def initialize(attributes = {})
-    initialize_attributes(attributes)
-    @fullname = "#{forename} #{surname}"
-  end
-end
-
 describe Attributable do
   describe "construction" do
     it "should accept a hash" do
@@ -41,10 +30,27 @@ describe Attributable do
       expect(i.forename).to be_nil
       expect(i.surname).to eq("Doe")
     end
+
+    it "should raise error when values for unknown attributes are specified" do
+      expect { User.new(password: "secret", admin: true, surname: "Doe") }.to(
+        raise_error(KeyError, "Unknown attributes: password, admin")
+      )
+    end
   end
 
   describe "constructor" do
     it "should be overridable" do
+      class UserWithDerivedAttribute
+        extend Attributable
+        attributes :id, :forename, surname: "Bloggs"
+        attr_reader :fullname
+
+        def initialize(attributes = {})
+          initialize_attributes(attributes)
+          @fullname = "#{forename} #{surname}"
+        end
+      end
+
       i = UserWithDerivedAttribute.new(id: 1, forename: "John", surname: "Doe")
 
       expect(i.id).to eq(1)

data/spec/attributable/specialisation_spec.rb

@@ -1,38 +1,35 @@
 require "attributable"
 
-class User
-  extend Attributable
-  attributes :id, :forename, surname: "Bloggs"
-end
-
 describe Attributable do
-  describe "specialisation" do
-    it "should pull in attributes from specified class" do
-      class SuperUser
+  describe "prerequisites for specialisation" do
+    it "should be possible to call attributes more than once" do
+      class Person
         extend Attributable
-
-        attributes :password, active: true
-        specialises User
+        attributes :forename, surname: "Bloggs"
+        attributes :id, active: true
       end
 
-      s = SuperUser.new(id: 1, forename: "Bob", password: "secret", active: false)
+      p = Person.new(id: 1, forename: "Bob")
 
-      expect(s.id).to eq(1)
-      expect(s.forename).to eq("Bob")
-      expect(s.surname).to eq("Bloggs")
-      expect(s.password).to eq("secret")
-      expect(s.active).to be_false
+      expect(p.id).to eq(1)
+      expect(p.forename).to eq("Bob")
+      expect(p.surname).to eq("Bloggs")
+      expect(p.active).to be_true
     end
+  end
 
-    it "should be possible to declare specialisation before attributes" do
-      class SuperUser2
-        extend Attributable
+  describe "inheritance" do
+    class User
+      extend Attributable
+      attributes :id, :forename, surname: "Bloggs"
+    end
 
-        specialises User
+    it "should inherit attributes from superclass" do
+      class SuperUser < User
         attributes :password, active: true
       end
 
-      s = SuperUser2.new(id: 1, forename: "Bob", password: "secret", active: false)
+      s = SuperUser.new(id: 1, forename: "Bob", password: "secret", active: false)
 
       expect(s.id).to eq(1)
       expect(s.forename).to eq("Bob")
@@ -41,84 +38,137 @@ describe Attributable do
       expect(s.active).to be_false
     end
 
-    it "should ensure that local attributes precede specialised attributes" do
-      class SuperUser3
-        extend Attributable
-
-        specialises User
+    it "should ensure that subclass's attributes precede superclass's" do
+      class SuperUser2 < User
         attributes surname: "Smith"
       end
 
-      s = SuperUser3.new
+      s = SuperUser2.new
 
       expect(s.surname).to eq("Smith")
     end
+  end
+
+  describe "mixins" do
+    module Author
+      extend Attributable
+      attributes articles: []
+    end
+
+    it "should inherit attributes from mixed-in module" do
+      class Columnist
+        include Author
 
-    it "should ensure that position of specialises does not affect precedence" do
-      class SuperUser4
         extend Attributable
+        attributes :column
+      end
 
-        attributes surname: "Smith"
-        specialises User
+      c = Columnist.new(column: "Agony Aunt", articles: [:teen_advice])
+
+      expect(c.column).to eq("Agony Aunt")
+      expect(c.articles).to eq([:teen_advice])
+    end
+
+    it "should inherit defaults from mixed-in module" do
+      class Columnist2
+        include Author
+
+        extend Attributable
+        attributes :column
       end
 
-      s = SuperUser4.new
+      c = Columnist2.new
 
-      expect(s.surname).to eq("Smith")
+      expect(c.articles).to eq([])
     end
 
-    it "should raise if specialising class is not an instance of Attributable" do
-      expect do
-        class SuperUser5
-          extend Attributable
-          specialises String
-        end
-      end.to raise_error(
-        ArgumentError,
-        "specialisation requires a class that extends Attributable"
-      )
+    it "should ensure that includee's attributes precede included's" do
+      class Columnist3
+        include Author
+
+        extend Attributable
+        attributes articles: [:daily_column]
+      end
+
+      c = Columnist3.new
+
+      expect(c.articles).to eq([:daily_column])
     end
-  end
 
-  describe "automatic specialisation" do
-    it "should automatically specialise if superclass is an instance of Attributable" do
-      class SuperUser6 < User
-        attributes :password, active: true
+    xit "should work when include is last" do
+      class Columnist4
+        extend Attributable
+        attributes :column
+        include Author
       end
 
-      s = SuperUser6.new(id: 1, forename: "Bob", password: "secret", active: false)
+      c = Columnist4.new(column: "Agony Aunt", articles: [:teen_advice])
 
-      expect(s.id).to eq(1)
-      expect(s.forename).to eq("Bob")
-      expect(s.surname).to eq("Bloggs")
-      expect(s.password).to eq("secret")
-      expect(s.active).to be_false
+      expect(c.articles).to eq([:teen_advice])
+      expect(c).to eq(Columnist4.new(column: "Agony Aunt", articles: [:teen_advice]))
     end
 
-    it "should not override any custom methods" do
-      class SuperUser7 < User
-        def inspect
-          "SUPERUSER"
-        end
+    it "should work when include is in the middle" do
+      class Columnist5
+        extend Attributable
+        include Author
+        attributes :column
       end
 
-      s = SuperUser7.new(id: 1)
+      c = Columnist5.new(column: "Agony Aunt", articles: [:teen_advice])
 
-      expect(s.id).to eq(1)
-      expect(s.inspect).to eq("SUPERUSER")
+      expect(c.articles).to eq([:teen_advice])
+      expect(c).to eq(Columnist5.new(column: "Agony Aunt", articles: [:teen_advice]))
     end
 
-    it "shouldn't automatically specialise unless superclass is an instance of Attributable" do
-      class PORO
-        attr_accessor :name
+    it "should work with several includes" do
+      module Editor
+        extend Attributable
+        attributes :section
       end
 
-      class SuperUser8 < PORO
+      class AuthorAndEditor
+        include Author, Editor
         extend Attributable
-        attributes :forename, :surname
+        attributes :name
       end
 
-      expect { SuperUser8.new }.to_not raise_error
+      ae = AuthorAndEditor.new(name: "Joe Bloggs", section: "Sport")
+
+      expect(ae.name).to eq("Joe Bloggs")
+      expect(ae.section).to eq("Sport")
+      expect(ae.articles).to eq([])
+    end
+  end
+
+  describe "inheritance and mixins" do
+    class Blogger < User
+      include Author
+      extend Attributable
+      attributes :blog_name
+    end
+
+    it "should inherit attributes from both" do
+      b = Blogger.new(
+        id: 1,
+        forename: "John",
+        surname: "Doe",
+        articles: [:daily_column],
+        blog_name: "Research Rants"
+      )
+
+      expect(b.id).to eq(1)
+      expect(b.forename).to eq("John")
+      expect(b.surname).to eq("Doe")
+      expect(b.articles).to eq([:daily_column])
+      expect(b.blog_name).to eq("Research Rants")
+    end
+
+    it "should inherit defaults from both" do
+      b = Blogger.new
+
+      expect(b.surname).to eq("Bloggs")
+      expect(b.articles).to eq([])
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attributable
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Louis Rose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-10 00:00:00.000000000 Z
+date: 2014-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler