virtus 1.0.0.beta8 → 1.0.0.rc1

data/lib/virtus/class_inclusions.rb

@@ -13,6 +13,7 @@ module Virtus
     def self.included(descendant)
       super
       descendant.extend(ClassMethods)
+      descendant.extend(Extensions::AllowedWriterMethods)
       descendant.class_eval { include Methods }
       descendant.class_eval { include InstanceMethods }
       descendant.class_eval { include InstanceMethods::Constructor }

data/lib/virtus/class_methods.rb

@@ -14,11 +14,7 @@ module Virtus
     # @api private
     def self.extended(descendant)
       super
-      AttributeSet.create(descendant)
-      descendant.module_eval do
-        extend DescendantsTracker
-        include attribute_set
-      end
+      descendant.send(:include, AttributeSet.create(descendant))
     end
     private_class_method :extended
 

data/lib/virtus/configuration.rb

@@ -28,8 +28,10 @@ module Virtus
     # @return [Configuration]
     #
     # @api public
-    def self.build(&block)
-      new.call(&block)
+    def self.build(options = {}, &block)
+      config = new.call(&block)
+      options.each { |key, value| config.public_send("#{key}=", value) }
+      config
     end
 
     # Initialized a configuration instance
@@ -77,5 +79,13 @@ module Virtus
       @coercer
     end
 
+    # @api private
+    def to_h
+      { :coerce             => coerce,
+        :finalize           => finalize,
+        :strict             => strict,
+        :configured_coercer => coercer }.freeze
+    end
+
   end # class Configuration
 end # module Virtus

data/lib/virtus/extensions.rb

@@ -18,9 +18,8 @@ module Virtus
       object.instance_eval do
         extend Methods
         extend InstanceMethods
-        extend InstanceMethods::Constructor
+        extend AllowedWriterMethods
         extend InstanceMethods::MassAssignment
-        extend attribute_set
       end
     end
     private_class_method :extended
@@ -29,18 +28,16 @@ module Virtus
 
       # @api private
       def self.extended(descendant)
-        AttributeSet.create(descendant)
-        descendant.instance_eval do
-          extend attribute_set
-        end
+        super
+        descendant.extend(AttributeSet.create(descendant))
       end
       private_class_method :extended
 
-      # Defines an attribute on an object's class
+      # Defines an attribute on an object's class or instance
       #
       # @example
       #    class Book
-      #      include Virtus
+      #      include Virtus.model
       #
       #      attribute :title,        String
       #      attribute :author,       String
@@ -52,7 +49,7 @@ module Virtus
       # @param [Symbol] name
       #   the name of an attribute
       #
-      # @param [Class] type
+      # @param [Class,Array,Hash,Axiom::Types::Type,String,Symbol] type
       #   the type class of an attribute
       #
       # @param [#to_hash] options
@@ -63,32 +60,19 @@ module Virtus
       # @see Attribute.build
       #
       # @api public
-      def attribute(name, type = Object, options = {})
+      def attribute(name, type = nil, options = {})
         assert_valid_name(name)
-        attribute_set << Attribute.build(type, merge_options(name, options))
+        attribute_set << Attribute.build(type, options.merge(:name => name))
         self
       end
 
+      # @see Virtus.default_value
+      #
       # @api public
       def values(&block)
-        private :attributes=
+        private :attributes= if instance_methods.include?(:attributes=)
         yield
         include(::Equalizer.new(*attribute_set.map(&:name)))
-        self
-      end
-
-      # The list of writer methods that can be mass-assigned to in #attributes=
-      #
-      # @return [Set]
-      #
-      # @api private
-      def allowed_writer_methods
-        @allowed_writer_methods ||=
-          begin
-            allowed_writer_methods  = allowed_methods.grep(WRITER_METHOD_REGEXP).to_set
-            allowed_writer_methods -= INVALID_WRITER_METHODS
-            allowed_writer_methods.freeze
-          end
       end
 
       private
@@ -102,16 +86,28 @@ module Virtus
         @attribute_set
       end
 
-      # Merge default options
+    end # Methods
+
+    module AllowedWriterMethods
+      WRITER_METHOD_REGEXP   = /=\z/.freeze
+      INVALID_WRITER_METHODS = %w[ == != === []= attributes= ].to_set.freeze
+
+      # The list of writer methods that can be mass-assigned to in #attributes=
       #
-      # @return [Hash]
+      # @return [Set]
       #
       # @api private
-      def merge_options(name, options)
-        { :name => name }.merge(options)
+      def allowed_writer_methods
+        @allowed_writer_methods ||=
+          begin
+            allowed_writer_methods  = allowed_methods.grep(WRITER_METHOD_REGEXP).to_set
+            allowed_writer_methods -= INVALID_WRITER_METHODS
+            allowed_writer_methods.freeze
+          end
       end
 
-    end # Methods
+    end # AllowedWriterMethods
 
   end # module Extensions
+
 end # module Virtus

data/lib/virtus/instance_methods.rb

@@ -14,7 +14,7 @@ module Virtus
       #
       # @api private
       def initialize(attributes = nil)
-        attribute_set.set(self, attributes) if attributes
+        self.class.attribute_set.set(self, attributes) if attributes
         set_default_attributes
       end
 
@@ -171,7 +171,7 @@ module Virtus
     # @api public
     def reset_attribute(attribute_name)
       attribute = attribute_set[attribute_name]
-      attribute_set.set_default(self, attribute) if attribute
+      attribute.set_default_value(self) if attribute
       self
     end
 

data/lib/virtus/model.rb

@@ -5,7 +5,7 @@ module Virtus
     # @api private
     def self.included(descendant)
       super
-      descendant.send(:include, ClassInclusions) if Class === descendant
+      descendant.send(:include, ClassInclusions)
     end
 
     # @api private
@@ -51,6 +51,7 @@ module Virtus
       # @api private
       def self.included(descendant)
         super
+        descendant.extend(Extensions::AllowedWriterMethods)
         descendant.send(:include, InstanceMethods::MassAssignment)
       end
       private_class_method :included
@@ -58,6 +59,7 @@ module Virtus
       # @api private
       def self.extended(descendant)
         super
+        descendant.extend(Extensions::AllowedWriterMethods)
         descendant.extend(InstanceMethods::MassAssignment)
       end
       private_class_method :included

data/lib/virtus/module_extensions.rb

@@ -25,7 +25,7 @@ module Virtus
     # @return [self]
     #
     # @api private
-    def attribute(name, type, options = {})
+    def attribute(name, type = nil, options = {})
       @attribute_definitions << [name, type, options]
       self
     end

data/lib/virtus/value_object.rb

@@ -34,7 +34,7 @@ module Virtus
       Virtus.warn "Virtus::ValueObject is deprecated and will be removed in 1.0.0 #{caller.first}"
 
       base.instance_eval do
-        include ::Virtus
+        include Virtus
         include InstanceMethods
         extend ClassMethods
         extend AllowedWriterMethods

data/lib/virtus/version.rb

@@ -1,3 +1,3 @@
 module Virtus
-  VERSION = '1.0.0.beta8'
+  VERSION = '1.0.0.rc1'
 end

data/spec/integration/inheritance_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Inheritance' do
+  before do
+    module Examples
+      class Base
+        include Virtus.model
+      end
+
+      class First < Base
+        attribute :id, Fixnum
+        attribute :name, String, default: ->(first, _) { "Named: #{first.id}" }
+        attribute :description, String
+      end
+
+      class Second < Base
+        attribute :something, String
+      end
+    end
+  end
+
+  it 'inherits model from the base class' do
+    expect(Examples::First.attribute_set.map(&:name)).to eql([:id, :name, :description])
+    expect(Examples::Second.attribute_set.map(&:name)).to eql([:something])
+  end
+
+  it 'sets correct attributes on the descendant classes' do
+    first = Examples::First.new(:id => 1, :description => 'hello world')
+
+    expect(first.id).to be(1)
+    expect(first.name).to eql('Named: 1')
+    expect(first.description).to eql('hello world')
+
+    second = Examples::Second.new
+
+    expect(second.something).to be(nil)
+
+    second.something = 'foo bar'
+
+    expect(second.something).to eql('foo bar')
+  end
+end

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ if ENV['COVERAGE'] == 'true'
     add_filter       'config/'
     add_filter       'spec'
     add_filter       '.bundle'
-    minimum_coverage 99
+    minimum_coverage 98
   end
 end
 

data/spec/unit/virtus/attribute/collection/class_methods/build_spec.rb

@@ -19,6 +19,16 @@ describe Virtus::Attribute, '.build' do
     end
   end
 
+  context 'when type is Array[Virtus::Attribute::Boolean]' do
+    let(:type) { Array[Virtus::Attribute::Boolean] }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Boolean)
+    end
+  end
+
   context 'when type is Array[Float]' do
     let(:type) { Array[Float] }
 

data/spec/unit/virtus/attribute/hash/class_methods/build_spec.rb

@@ -37,6 +37,20 @@ describe Virtus::Attribute::Hash, '.build' do
     end
   end
 
+  context 'when type is Hash[Virtus::Attribute::Hash => Virtus::Attribute::Boolean]' do
+    let(:type) { Hash[Virtus::Attribute::Hash => Virtus::Attribute::Boolean] }
+
+    it { should be_instance_of(Virtus::Attribute::Hash) }
+
+    it 'sets key type' do
+      expect(subject.type.key_type).to be(Axiom::Types::Hash)
+    end
+
+    it 'sets value type' do
+      expect(subject.type.value_type).to be(Axiom::Types::Boolean)
+    end
+  end
+
   context 'when type is Hash[Struct.new(:id) => Integer]' do
     let(:type)     { Hash[key_type => Integer] }
     let(:key_type) { Struct.new(:id) }

data/spec/unit/virtus/class_methods/finalize_spec.rb

@@ -7,29 +7,35 @@ describe Virtus, '.finalize' do
         include Virtus.model(:finalize => false)
 
         attribute :articles, Array['Examples::Article']
-        attribute :address,  'Examples::Address'
+        attribute :address,  :'Examples::Address'
       end
 
       class Article
         include Virtus.model(:finalize => false)
 
         attribute :posts, Hash['Examples::Person' => 'Examples::Post']
-        attribute :person, 'Examples::Person'
+        attribute :person, :'Examples::Person'
       end
 
       class Post
-        include Virtus.model(:finalize => false)
+        include Virtus.model
 
         attribute :title, String
       end
 
       class Address
-        include Virtus.model(:finalize => false)
+        include Virtus.model
 
         attribute :street, String
       end
     end
 
+    expect(Examples::Post.attribute_set[:title]).to be_finalized
+    expect(Examples::Address.attribute_set[:street]).to be_finalized
+
+    expect(Virtus::Builder.pending).not_to include(Examples::Post)
+    expect(Virtus::Builder.pending).not_to include(Examples::Address)
+
     Virtus.finalize
   end
 

data/spec/unit/virtus/model_spec.rb

@@ -10,7 +10,7 @@ describe Virtus, '.model' do
 
   share_examples_for 'a model with mass-assignment' do
     let(:attributes) do
-      { :name => 'Jane' }
+      { :name => 'Jane', :something => nil }
     end
 
     before do
@@ -32,11 +32,14 @@ describe Virtus, '.model' do
     let(:mod) { Virtus.model }
 
     context 'with a class' do
-      subject { Class.new }
+      let(:model) { Class.new }
+
+      subject { model }
 
       before do
         subject.send(:include, mod)
-        subject.attribute :name
+        subject.attribute :name, String, :default => 'Jane'
+        subject.attribute :something
       end
 
       it_behaves_like 'a model with constructor'
@@ -46,6 +49,34 @@ describe Virtus, '.model' do
       it_behaves_like 'a model with mass-assignment' do
         let(:instance) { subject.new }
       end
+
+      it 'defaults to Object for attribute type' do
+        expect(model.attribute_set[:something].type).to be(Axiom::Types::Object)
+      end
+
+      context 'with a sub-class' do
+        subject { Class.new(model) }
+
+        before do
+          subject.attribute :age, Integer
+        end
+
+        it_behaves_like 'a model with constructor'
+
+        it_behaves_like 'a model with strict mode turned off'
+
+        it_behaves_like 'a model with mass-assignment' do
+          let(:instance) { subject.new }
+
+          let(:attributes) {
+            { :name => 'Jane', :something => nil, :age => 23 }
+          }
+        end
+
+        it 'has its own attributes' do
+          expect(subject.attribute_set[:age]).to be_kind_of(Virtus::Attribute)
+        end
+      end
     end
 
     context 'with an instance' do
@@ -54,6 +85,7 @@ describe Virtus, '.model' do
       before do
         subject.extend(mod)
         subject.attribute :name, String
+        subject.attribute :something
       end
 
       it_behaves_like 'a model with strict mode turned off'

data/spec/unit/virtus/module_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe Virtus, '.module' do
   share_examples_for 'a valid virtus object' do
     it 'reads and writes attribute' do
-      instance.name = 'Jane'
-      expect(instance.name).to eql('Jane')
+      instance.name = 'John'
+      expect(instance.name).to eql('John')
     end
   end
 
@@ -15,6 +15,10 @@ describe Virtus, '.module' do
       it_behaves_like 'a valid virtus object' do
         let(:instance) { model.new }
       end
+
+      it 'sets defaults' do
+        expect(instance.name).to eql('Jane')
+      end
     end
 
     context 'with constructor turned off' do
@@ -39,6 +43,16 @@ describe Virtus, '.module' do
         expect(instance).not_to respond_to(:attributes=)
       end
     end
+
+    context 'with coercion turned off' do
+      subject { Virtus.module(:coerce => false) }
+
+      it_behaves_like 'a valid virtus object'
+
+      it 'builds non-coercible attributes' do
+        expect(object.send(:attribute_set)[:name]).not_to be_coercible
+      end
+    end
   end
 
   let(:mod)      { Module.new }
@@ -47,10 +61,13 @@ describe Virtus, '.module' do
 
   before do
     mod.send(:include, subject)
-    mod.attribute :name, String
+    mod.attribute :name, String, :default => 'Jane'
+    mod.attribute :something
   end
 
   context 'with a class' do
+    let(:object) { model }
+
     before do
       model.send(:include, mod)
     end
@@ -59,10 +76,16 @@ describe Virtus, '.module' do
       expect(model.attribute_set[:name]).to be_kind_of(Virtus::Attribute)
     end
 
+    it 'defaults to Object for attribute type' do
+      expect(model.attribute_set[:something].type).to be(Axiom::Types::Object)
+    end
+
     it_behaves_like 'an object extended with virtus module'
   end
 
   context 'with a model instance' do
+    let(:object) { instance }
+
     before do
       instance.extend(mod)
     end
@@ -73,4 +96,22 @@ describe Virtus, '.module' do
 
     it_behaves_like 'an object extended with virtus module'
   end
+
+  context 'with another module' do
+    let(:other)  { Module.new }
+
+    let(:object) { instance }
+
+    before do
+      other.send(:include, mod)
+      model.send(:include, other)
+    end
+
+    it_behaves_like 'an object extended with virtus module'
+
+    it 'provides attributes for the model' do
+      expect(model.attribute_set[:name]).to be_kind_of(Virtus::Attribute)
+    end
+  end
+
 end