reindeer 0.0.1

data/.rspec

@@ -0,0 +1,6 @@
+RSpec.configure do |config|
+  # No monkey patching please.
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.0.1
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+ruby '1.9.3'
+
+group :test do
+  gem 'rake',  '~> 10'
+  gem 'rspec', '~> 2'
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rake (10.0.3)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 10)
+  rspec (~> 2)

data/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) 2013 Dan Brook
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the 'Software'), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# Reindeer - Moose sugar in ruby
+
+Takes Ruby's existing OO features and extends them with some sugar
+borrowed from [Moose](http://p3rl.org/Moose).
+
+# Installation
+
+    gem install reindeer
+
+# Usage
+
+    require 'reindeer'
+    class Point < Reindeer
+      has :x, is: :rw, is_a: Integer
+      has :y, is: :rw, is_a: Integer
+    end
+    class Point3D < Point
+      has :z, is: :rw, is_a: Integer
+    end
+
+# Features
+
+These features are supported to a greater or less extent:
+
+## Construction
+
+The `build` method can be used where one may have previously used
+`initialize`. It is called after all attributes have been setup so,
+laziness permitting, the object should be in a known state.
+
+Another facet of this feature is that each `build` method is called in
+the inheritance chain from most-derived to least.
+
+## Attributes
+
+Declared with the alternative syntax `has` they provide
+additional functionality while still remaining pure Ruby attributes
+under the hood.
+
+Their values can be passed to the `new` constructor in a hash where
+the symbolic keys map to attributes of the same. When a value is
+specified for a `lazy` attribute it obviates the laziness.
+
+The following options are supported:
+
+### is (aka accessors)
+
+Available in 3 flavours:
+
+* `:ro`
+* `:rw`
+* `:bare`
+
+The first two provide accessors like `attr_reader` and
+`attr_{reader,writer}` combined. The third explicitly provides no
+accessors which can be useful when delegators are specified.
+
+The default behaviour is `:ro`.
+
+### required (aka required attributes)
+
+If specified with a `true` value then the attribute must be specified
+at build time. Additionally `required` attributes can't be `lazy`
+attributes.
+
+### default (aka default attribute values)
+
+Can take either a value or something callable (e.g a `Proc`). If a
+value is provided it is `clone`d and if a callable is provided it is
+`call`ed without any arguments. The resulting value is used to
+populate the attribute if it wasn't provided to the constructor at
+object construction time or on first access if the attribute is
+`lazy`.
+
+### lazy (aka lazily evaluated)
+
+Expects a `Boolean` and if `true` then the attribute's value isn't
+generated until it is accessed (if at all). If specified the attribute
+*must* also either have a `builder` or `default` specified otherwise an
+`Reindeer::Meta::Attribute::AttributeError` is thrown.
+
+### lazy_build
+
+If passed `true` makes the attribute `lazy` and expects a private
+`builder` method of the same name as the attribute, but prefixed with
+`build_`, to be defined e.g given `has :foo, lazy_build: true` the
+private instance method `build_foo` should be defined. In addition
+clearer and predicate methods will be installed with the prefixes
+`clear_` and `has_` respectively e.g `clear_foo!` and `has_foo?`.
+
+### handles (aka delegation methods)
+
+Given an array of symbols each one adds an instance method that
+delegates to a method of the same name on the attribute value.
+
+### type_of (aka type constraints)
+
+Expects a class that composes the `Reindeer::Role::TypeConstraint`
+role. At the point a value is about set against an attribute it is
+checked against the type constraint, if valid then the value is set if
+not then an `Reindeer::TypeConstraint::Invalid` exception is raised.
+
+## Roles
+
+These are implemented in terms of `Module` and act to serve a similar
+purpose. What they provide in addition to `Module` are required
+methods and the attributes described above.
+
+To compose a role in a Reindeer class two expressions are required,
+`with` and `meta.compose!`, the former behaves like `include` and the
+latter brings in the role attributes and asserts the existence of any
+required methods e.g
+
+    module Breakable
+      include Reindeer::Role
+      has :is_broken, default: -> { false }
+      requires :fix!
+    end
+    
+    class Egg < Reindeer
+      with Breakable
+      
+      def fix!
+        throw :no_dice if is_broken
+      end
+      
+      meta.compose!
+    end
+
+The `.does?` method can be used to inspect which roles have been
+consumed e.g `Egg.does?(Breakable) == true`.
+
+For further elaboration on the subject of roles see the
+[Moose::Manual::Roles](https://metacpan.org/module/Moose::Manual::Roles)
+documentation.
+
+## Class constraints and Type constraints
+
+Given that Ruby has a well established class system one need only
+assert an attribute is of a given (existing) class a Reindeer will go
+to the trouble of asserting that when the attribute value is set e.g
+
+    class AccountSqlTable < Reindeer
+      has :id,     is_a: Fixnum
+      has :owner,  is_a: String
+      has :amount, is_a: Float
+      # ...
+    end
+
+However if you need a specific type of class (e.g strings of a certain
+length) then a custom type constraint is needed. These can be defined
+simply by composing the `Reindeer::Role::TypeConstraint` and
+implementing a `verify` method e.g
+
+    class Varchar255 < Reindeer
+      with Reindeer::Role::TypeConstraint
+      def verify(v)
+        v.length <= 255
+      end
+      meta.compose!
+    end
+
+    class AccountSqlTable # continued from above
+      has :summary, type_of: Varchar255
+    end
+
+*NB* The distinction between class and type constraints seems apt at this
+point but is by no means set in stone. Hopefully the passage of time
+shall enlighten us on the matter.
+
+# Contributing
+
+Pull requests welcome.
+
+# Author
+
+Dan Brook `<dan@broquaint.com>`

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new

data/lib/reindeer.rb

@@ -0,0 +1,45 @@
+require 'reindeer/meta'
+require 'reindeer/role'
+require 'reindeer/role/typeconstraint'
+
+class Reindeer
+  class << self
+    # XXX Support a single name for now i.e has %i[a b] won't work yet.
+    def has(name, opts={})
+      # XXX Should really do this at this once everything has been
+      # defined not up front like this. Don't know of any hooks though :(
+      meta.add_attribute(name, opts).install_methods_in(self)
+    end
+    
+    def with(role)
+      meta.add_role(role)
+    end
+
+    def does?(role)
+      meta.all_roles.include? role
+    end
+
+    def inherited(subclass)
+      provide_meta subclass
+    end
+
+    def provide_meta(subclass)
+      meta = Reindeer::Meta.new(subclass)
+      meth = Proc.new { meta }
+      klass = class << subclass; self; end
+      klass.__send__    :define_method, :meta, meth
+      subclass.__send__ :define_method, :meta, meth
+    end
+  end
+
+  def initialize(args={})
+    meta.setup_attributes(self, args)
+    meta.build_all(self, args)
+  end
+
+  def build(args); end
+
+  def does?(role)
+    meta.all_roles.include? role
+  end
+end

data/lib/reindeer/meta.rb

@@ -0,0 +1,99 @@
+require 'reindeer/meta/attribute'
+
+class Reindeer
+  class Meta
+
+    attr_reader :klass
+    attr_reader :required_methods
+
+    def initialize(klass)
+      @klass = klass # Hrm, circular? Not a problem with constants?
+      # TODO Use a hash
+      @attributes = []
+      @roles      = []
+      @required_methods = []
+    end
+
+    def build_all(obj, args)
+      to_build = obj.class.ancestors.take_while { |klass|
+        klass != Reindeer
+      }.reverse
+
+      (to_build - obj.class.included_modules).each { |klass|
+        # TODO assume build is private.
+        build = klass.instance_method(:build)
+        build.bind(obj).call(args)
+      }
+    end
+
+    def compose!
+      all_roles.each do |role|
+        role.assert_requires klass
+        # role.compose_methods! klass
+        klass.__send__ :include, role # Blech
+        role.role_meta.get_attributes.each do |attr|
+          attr.install_methods_in klass
+        end
+
+        get_attributes.push(*role.role_meta.get_attributes)
+      end
+    end
+
+    def add_role(role)
+      @roles << role
+    end
+
+    def all_roles
+      @roles
+    end
+
+    # Not sure if this is the best place for it.
+    def add_required_method(method)
+      @required_methods << method
+    end
+
+    def get_attributes
+      @attributes
+    end
+
+    def get_all_attributes
+      all_classes = klass.ancestors.take_while{|k| k!=Reindeer}.select{|c|
+        c.class == Class
+      }.reverse
+      all_classes.collect{|c| c.meta.get_attributes}.flatten
+    end
+
+    def add_attribute(name, opts)
+      attr = Reindeer::Meta::Attribute.new(name, opts)
+      get_attributes << attr
+      return attr
+    end
+
+    def setup_attributes(obj, args)
+      for attr in get_all_attributes
+        name = attr.name
+        if attr.required? and not args.has_key? name
+          raise Meta::Attribute::AttributeError,
+                "Did not specify required argument '#{name}'"
+        end
+
+        obj.instance_eval do
+          if args.has_key?(name)
+            attr.set_value_for self, args[name]
+          elsif attr.has_default? and not attr.is_lazy?
+            attr.set_value_for self, attr.get_default_value
+          end
+        end
+      end
+    end
+    
+    def has_attribute?(name)
+      get_attributes.any? {|a| a.name == name }
+    end
+
+    def get_attribute(sym)
+      sym = sym.sub(/^@/, '').to_sym if sym.is_a?(String)
+      get_attributes.select{|a| a.name == sym}.first
+    end
+  end
+end

data/lib/reindeer/meta/attribute.rb

@@ -0,0 +1,182 @@
+class Reindeer
+  class Meta
+    class Attribute
+      # Exceptions!
+      class AttributeError < StandardError; end
+
+      attr_reader :name
+
+      attr_reader :is_ro, :is_rw, :is_bare
+
+      attr_reader :is_a, :type_of
+
+      attr_reader :default_value
+      attr_reader :lazy_builder, :lazy_build
+
+      attr_reader :handles
+
+      def initialize(name, opts)
+        @name = name
+        process_opts opts
+      end
+
+      def to_var
+        "@#{name.to_s}"
+      end
+
+      def install_methods_in(klass)
+        install_accessors_in klass
+        if lazy_build
+          install_clearer_in   klass
+          install_predicate_in klass
+        end
+        install_delegators klass if has_handles?
+      end
+
+      def install_accessors_in(klass)
+        return if is_bare
+
+        if is_lazy?
+          attr_name = to_var
+          builder   = lazy_builder
+          klass.__send__ :define_method, name, Proc.new {
+            if instance_variable_defined? attr_name
+              instance_variable_get attr_name
+            else
+              meta.get_attribute(attr_name).set_value_for(
+                self, 
+                builder.is_a?(Symbol) ? __send__(builder) : builder.call()
+              )
+            end
+          }
+        else
+          name_sym = name
+          klass.class_eval { self.__send__ :attr_reader, name_sym }
+          if is_rw
+            klass.__send__ :define_method, "#{name}=", Proc.new {|v|
+              meta.get_attribute(name_sym).set_value_for(self, v)
+            }
+          end
+        end
+      end
+
+      def install_clearer_in(klass)
+        attr_name = to_var
+        klass.__send__ :define_method, "clear_#{name}!", Proc.new {
+          remove_instance_variable attr_name
+        }
+      end
+      
+      def install_predicate_in(klass)
+        attr_name = to_var
+        klass.__send__ :define_method, "has_#{name}?", Proc.new {
+          instance_variable_defined? attr_name
+        }
+      end
+
+      def install_delegators(klass)
+        attr_name = to_var
+        handles.each do |method|
+          klass.__send__ :define_method, method, Proc.new {|*args|
+            instance_variable_get(attr_name).__send__(method, *args)
+          }
+        end
+      end
+
+      def set_value_for(instance, value)
+        if is_a and not value.is_a? is_a
+          raise Meta::Attribute::AttributeError,
+               "The value for '#{name}' of type '#{value.class}' is not a '#{is_a}'"
+        end
+        type_of.check_constraint(value) if type_of
+        instance.instance_variable_set to_var, value
+      end
+
+      def get_default_value
+        default_value.call
+      end
+
+      # Predicates
+      def required?
+        @required
+      end
+      # There must be a cleaner way to get a boolean.
+      def has_default?
+        not default_value.nil?
+      end
+      def is_lazy?
+        not @lazy_builder.nil?
+      end
+      def has_handles?
+        not handles.nil?
+      end
+
+      private
+
+      def process_opts(opts)
+        process_is opts[:is]
+        
+        @required      = opts[:required]
+        @is_a          = opts[:is_a] if opts.has_key?(:is_a)
+        @type_of       = process_type_of opts[:type_of] if opts.has_key?(:type_of)
+        @default_value = process_default opts[:default] if opts.has_key?(:default)
+
+        process_lazy opts[:lazy], opts if opts.has_key?(:lazy)
+
+        if opts[:lazy_build]
+          raise AttributeError, "Can't have lazy_build and default, pick one!" if has_default?
+          @lazy_builder = "build_#{name}".to_sym
+          @lazy_build   = true
+        end
+
+        raise AttributeError, "Can't be lazy and required, pick one!" if required? and is_lazy?
+        process_handles opts[:handles] if opts.has_key?(:handles)
+      end
+
+      def process_is(val)
+        case val
+        when nil then @is_ro = true # Default behaviour if 'is' isn't specified.
+        when :ro then @is_ro = true
+        when :rw then @is_rw = true
+        when :bare then @is_bare = true
+        else raise AttributeError, "Unknown value for is '#{val}'"
+        end
+      end
+
+      def process_type_of(type_constraint)
+        tc = type_constraint.new # XXX Bleh!
+        if tc.respond_to? :verify # TODO Implement .does?
+          tc
+        elsif type_constraint.class == Class # or something
+          Reindeer::TypeConstraint::Class.new(isa)
+        else
+          raise AttributeError, "Unknown type constraint '#{isa}' for #{name}"
+        end
+      end
+
+      # TODO check default is callable.
+      def process_default(default)
+        if default.is_a?(Proc)
+          default
+        else
+          Proc.new { default.clone }
+        end
+      end
+
+      def process_lazy(is_lazy, opts)
+        if opts[:builder] and opts[:default]
+          raise AttributeError, "Can't use lazy & builder for lazy"
+        elsif not opts[:builder] and not opts[:default]
+          raise AttributeError, "Must specify lazy or builder for lazy"
+        end
+
+        @lazy_builder = opts[:builder] || process_default(opts[:default])
+      end
+
+      def process_handles(handles)
+        raise AttributeError, "Only support an Array of methods is supported for handles" unless handles.is_a?(Array)
+        @handles = handles
+      end
+    end
+  end
+end

data/lib/reindeer/role.rb

@@ -0,0 +1,32 @@
+class Reindeer
+  module Role
+    class RoleError < StandardError; end  #ahem
+
+    def Role.included(mod)
+      mod.module_eval {
+        class << self;
+          meta = Reindeer::Meta.new(self)
+          define_method :role_meta, Proc.new { meta }
+          
+          # Make this more composable?
+          define_method :has, Proc.new { |name, opts={}|
+            role_meta.add_attribute(name, opts)
+          }
+          
+          define_method :requires, Proc.new { |method|
+            role_meta.add_required_method(method)
+          }
+
+          define_method :assert_requires, Proc.new { |klass|
+            not_defined = role_meta.required_methods.select do |meth|
+              not klass.instance_methods(false).include?(meth)
+            end
+
+            return if not_defined.empty?
+            raise RoleError, "The class '#{klass}' composed '#{self}' but didn't define #{not_defined.join ', '}"
+          }
+        end
+      }
+    end
+  end
+end

data/lib/reindeer/role/typeconstraint.rb

@@ -0,0 +1,18 @@
+module Reindeer::Role::TypeConstraint
+  include Reindeer::Role
+  requires :verify
+
+  def check_constraint(v)
+    raise Reindeer::TypeConstraint::Invalid, error_message_for(v) unless verify(v)
+  end
+
+  def error_message_for(v)
+    return "The value '%s' not considered valid by %s" % [v, self.class]
+  end
+end
+
+class Reindeer
+  class TypeConstraint
+    class Invalid < StandardError; end
+  end
+end

data/lib/reindeer/version.rb

@@ -0,0 +1,3 @@
+module Reindeer
+  VERSION = '0.0.1'
+end

data/reindeer.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require "reindeer/version"
+
+Gem::Specification.new do |s|
+  s.name    = 'reindeer'
+  s.version = Reindeer::VERSION
+
+  s.required_ruby_version = ">= 1.9"
+  
+  s.summary     = "Moose sugar in Ruby"
+  s.description = "Adds featureful attributes, roles and type constraints"
+
+  s.authors  = ["Dan Brook"]
+  s.email    = 'dan@broquaint.com'
+  s.homepage = 'http://github.com/broquaint/reindeer'
+
+  s.files        = `git ls-files`.split("\n") - %w(.rvmrc .gitignore)
+  s.test_files   = `git ls-files spec`.split("\n")
+
+  s.add_development_dependency 'rake',  '~> 0.9.2'
+  s.add_development_dependency 'rspec', '~> 2'
+end

data/spec/reindeer/attributes_spec.rb

@@ -0,0 +1,222 @@
+require 'reindeer'
+
+describe 'Reindeer attributes' do
+  it 'should setup a method and initialize an attribute' do
+    class FirstOne < Reindeer
+      has :abc
+    end
+    obj = FirstOne.new abc: 'Hello!'
+    expect(obj.respond_to? :abc).to be_true
+    expect(obj.abc).to eq('Hello!')
+  end
+
+  it 'should setup two methods and initialize one attribute' do
+    class SecondOne < Reindeer
+      has :foo
+      has :bar
+    end
+    obj = SecondOne.new foo: 'World!'
+    expect(obj.respond_to? :foo).to be_true
+    expect(obj.respond_to? :bar).to be_true
+    expect(obj.foo).to eq('World!')
+    expect(obj.bar).to be_nil
+  end
+
+  it 'should honour is option' do
+    class ThirdOne < Reindeer
+      has :baz,  is: :ro
+      has :quux, is: :rw
+      has :xuuq, is: :bare
+    end
+
+    obj = ThirdOne.new baz: 'Sawasdee!'
+    expect(obj.respond_to? :baz).to be_true
+    expect(obj.respond_to? :baz=).to be_false
+    expect(obj.respond_to? :quux).to be_true
+    expect(obj.respond_to? :quux=).to be_true
+    expect(obj.respond_to? :xuuq).to be_false
+    expect(obj.meta.has_attribute?(:xuuq)).to be_true
+    expect(obj.baz).to eq('Sawasdee!')
+    expect(obj.quux).to be_nil
+    obj.quux = 'super'
+    expect(obj.quux).to eq('super')
+
+    expect {
+      class FirstFail < Reindeer
+        has :epic, is: 'fail'
+      end
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+  end
+
+  it 'should have required attributes' do
+    class SixthOne < Reindeer
+      has :foo, required: true
+    end
+    expect(SixthOne.new(foo: 'yep').foo).to eq('yep')
+    expect {
+      SixthOne.new
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+  end
+
+  it 'should have default attribute values' do
+    class SeventhOne < Reindeer
+      # clone, clone, execute
+      has :ichi, default: 'one'
+      has :ni,   default: %w[two three]
+      has :san,  default: -> { [:four, :five] }
+    end
+
+    expect(SeventhOne.new.ichi).to eq('one')
+
+    a = SeventhOne.new.ni
+    expect(a).to eq(%w{two three})
+    a << 'four five'
+    expect(SeventhOne.new.ni).to eq(%w{two three})
+
+    b = SeventhOne.new.san
+    expect(b).to eq([:four, :five])
+    b << :six
+    expect(SeventhOne.new.san).to eq([:four, :five])
+  end
+
+  it 'should have lazily built attribute values' do
+    class EighthOne < Reindeer
+      private
+      def build_ha
+        'mmm, lazy'
+      end
+      public
+      has :ha,  lazy: true, builder: :build_ha
+      has :hok, lazy: true, default: -> { 'not eager' }
+    end
+
+    expect(EighthOne.new.ha).to eq('mmm, lazy')
+    expect(EighthOne.new.hok).to eq('not eager')
+
+    expect {
+      class SecondFail < Reindeer
+        has :blam, lazy: true, builder: :flub, default: 'blub'
+      end
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+    expect {
+      class ThirdFail < Reindeer
+        has :blam, lazy: true
+      end
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+  end
+
+  it 'should support the lazy_build shorthand' do
+    class NinthOne < Reindeer
+      has :jet, lazy_build: true
+      private
+      def build_jet
+        :symbolic
+      end
+    end
+
+    expect(NinthOne.new.jet).to eq(:symbolic)
+
+    obj = NinthOne.new
+
+    expect(obj.has_jet?).to be_false
+    expect(obj.jet).to eq(:symbolic)
+    expect(obj.has_jet?).to be_true
+    obj.clear_jet!
+    expect(obj.has_jet?).to be_false
+
+    expect {
+      class FourthFail < Reindeer
+        has :nope, lazy_build: true, default: -> { 'boom!' }
+      end
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+  end
+
+  it 'should support delegation with handles' do
+    class TenthOne < Reindeer
+      has :bat, is: :bare, handles: [:sub]
+    end
+
+    obj = TenthOne.new(bat: 'zoo')
+    expect(obj.sub /z/, 'f').to eq('foo')
+    expect(obj.respond_to?(:bat)).to be_false
+
+    expect {
+      class FifthFail < Reindeer
+        has :bleh, handles: Object.new
+      end
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+  end
+
+  it 'should have simple type constraints' do
+    class EleventhOne < Reindeer
+      has :gau, is_a: String
+      has :sip, is_a: Fixnum
+    end
+
+    obj = EleventhOne.new(gau: 'foo', sip: 123)
+    expect(obj.gau).to eq('foo')
+    expect(obj.sip).to eq(123)
+
+    expect {
+      EleventhOne.new(gau: [])
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+    expect {
+      EleventhOne.new(sip: {})
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+  end
+
+  it 'should should consistently apply type constraints' do
+    class TwelvethOne < Reindeer
+      has :une,  is_a: Array, lazy_build: true
+      has :deux, is_a: Hash,  is: :rw
+      private
+      def build_une
+        %w{cool beans}
+      end
+    end
+
+    obj = TwelvethOne.new
+    expect(obj.une).to eq(%w{cool beans})
+    obj.deux = { hashie: 'hash' }
+    expect(obj.deux).to eq({ hashie: 'hash' })
+
+    expect {
+      TwelvethOne.new.deux = []
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+
+    expect {
+      class SixthFail < Reindeer
+        has :saywaht, is_a: Regexp, lazy: true, default: 'this here'
+      end
+      SixthFail.new.saywaht
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+  end
+
+  it 'should compose attributes up the inheritance chain' do
+    class SeventeenthOne < Reindeer
+      has :foo
+    end
+    module FourthRole
+      include Reindeer::Role
+      has :bar
+    end
+    class EighteenthOne < SeventeenthOne
+      with FourthRole
+      has :baz
+      meta.compose!
+    end
+
+    obj = EighteenthOne.new(foo: 1, bar: 2, baz: 3)
+    expect(obj.foo).to eq(1)
+    expect(obj.bar).to eq(2)
+    expect(obj.baz).to eq(3)
+  end
+
+  it 'should raise an exception for lazy required attributes' do
+    expect {
+      class LazyRequiredFail < Reindeer
+        has :zoiks, lazy: true, required: true
+      end
+    }.to raise_error(Reindeer::Meta::Attribute::AttributeError)
+  end
+end

data/spec/reindeer/construction_spec.rb

@@ -0,0 +1,20 @@
+require 'reindeer'
+
+describe 'Reindeer construction' do
+  it 'should call all build methods' do
+    class FifteenthOne < Reindeer
+      def build(args)
+        things << :super
+      end
+    end
+    class SixteenthOne < FifteenthOne
+      has :things, default: []
+      def build(args)
+        things << :neat
+      end
+    end
+
+    obj = SixteenthOne.new
+    expect(obj.things).to eq([:super, :neat])
+  end
+end

data/spec/reindeer/roles_spec.rb

@@ -0,0 +1,79 @@
+require 'reindeer'
+
+describe 'Reindeer roles' do
+  it 'should compose a role' do
+    # TODO more tests smaller roles (to begin with)
+    module FirstRole
+      include Reindeer::Role
+      has :trois, default: 'cool'
+      requires :quatre
+      def cinq
+        %w{cool beans}
+      end
+    end
+    class ThirteenthOne < Reindeer
+      with FirstRole
+      def quatre
+        'beans'
+      end
+      meta.compose!
+    end
+
+    obj = ThirteenthOne.new
+    expect(obj.trois).to eq('cool')
+    expect(obj.quatre).to eq('beans')
+    expect(obj.cinq).to eq(%w{cool beans})
+
+    expect {
+      module BankRole
+        include Reindeer::Role
+        requires :money
+      end
+      class SeventhFail < Reindeer
+        with BankRole
+        meta.compose!
+      end
+    }.to raise_error(Reindeer::Role::RoleError)
+  end
+
+  it 'should compose multiple roles' do
+    module SecondRole
+      include Reindeer::Role
+      has :foo
+      def bar; 'two'; end
+    end
+    module ThirdRole
+      include Reindeer::Role
+      has :baz
+      def quux; 'four'; end
+    end
+    class FourteenthOne < Reindeer
+      with SecondRole
+      with ThirdRole
+      meta.compose!
+    end
+    
+    obj = FourteenthOne.new(foo: 'one', baz: 'three')
+    expect(obj.foo).to eq('one')
+    expect(obj.bar).to eq('two')
+    expect(obj.baz).to eq('three')
+    expect(obj.quux).to eq('four')
+  end
+
+  it 'should know if an object does a role' do
+    module DoesRole
+      include Reindeer::Role
+    end
+    class ThatDoesARole < Reindeer
+      with DoesRole
+      meta.compose!
+    end
+    class ThatDoesNoRole < Reindeer; end
+
+    expect(ThatDoesARole.does? DoesRole).to be_true
+    expect(ThatDoesARole.new.does? DoesRole).to be_true
+
+    expect(ThatDoesNoRole.does? DoesRole).to be_false
+    expect(ThatDoesNoRole.new.does? DoesRole).to be_false
+  end
+end

data/spec/reindeer/types_spec.rb

@@ -0,0 +1,53 @@
+require 'reindeer'
+
+describe 'Reindeer types' do
+  it 'should constrain attributes' do
+    class QuietWord < Reindeer
+      with Reindeer::Role::TypeConstraint
+
+      def verify(val)
+        val.downcase == val
+      end
+
+      meta.compose!
+    end
+
+    class SoftlySpoken < Reindeer
+      has :start, is_a: String, type_of: QuietWord
+    end
+
+    obj = SoftlySpoken.new(start: 'foo')
+    expect(obj.start).to eq('foo')
+
+    expect {
+      obj = SoftlySpoken.new(start: 'LOUD NOISES')
+    }.to raise_error(Reindeer::TypeConstraint::Invalid)
+  end
+
+  it 'should have useful a error message' do
+    class LoudWord < Reindeer
+      with Reindeer::Role::TypeConstraint
+
+      def verify(val)
+        val.upcase == val
+      end
+
+      def error_message_for(val)
+        "THE VALUE '#{val}' WASN'T LOUD ENOUGH"
+      end
+
+      meta.compose!
+    end
+
+    class SergeantMajor < Reindeer
+      has :order, is_a: String, type_of: LoudWord
+    end
+
+    obj = SergeantMajor.new(order: 'TEN HUT')
+    expect(obj.order).to eq('TEN HUT')
+
+    expect {
+      SergeantMajor.new(order: 'quiet please')
+    }.to raise_error(Reindeer::TypeConstraint::Invalid, /WASN'T LOUD ENOUGH/)
+  end
+end

data/spec/reindeer_spec.rb

@@ -0,0 +1,10 @@
+require 'reindeer'
+
+describe 'Reindeer' do
+  it 'should have a meta per subclass' do
+    class FourthOne < Reindeer; end
+    class FifthOne  < Reindeer; end
+    expect(FourthOne.new.meta == FifthOne.new.meta).to be_false
+    expect(FourthOne.new.meta).to eql(FourthOne.meta)
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: reindeer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dan Brook
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+description: Adds featureful attributes, roles and type constraints
+email: dan@broquaint.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/reindeer.rb
+- lib/reindeer/meta.rb
+- lib/reindeer/meta/attribute.rb
+- lib/reindeer/role.rb
+- lib/reindeer/role/typeconstraint.rb
+- lib/reindeer/version.rb
+- reindeer.gemspec
+- spec/reindeer/attributes_spec.rb
+- spec/reindeer/construction_spec.rb
+- spec/reindeer/roles_spec.rb
+- spec/reindeer/types_spec.rb
+- spec/reindeer_spec.rb
+homepage: http://github.com/broquaint/reindeer
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Moose sugar in Ruby
+test_files:
+- spec/reindeer/attributes_spec.rb
+- spec/reindeer/construction_spec.rb
+- spec/reindeer/roles_spec.rb
+- spec/reindeer/types_spec.rb
+- spec/reindeer_spec.rb