virtus 1.0.0.beta6 → 1.0.0.beta7

data/lib/virtus/attribute/builder.rb

@@ -23,7 +23,7 @@ module Virtus
             if klass < Axiom::Types::Type
               determine_type(klass.primitive)
             elsif EmbeddedValue.handles?(klass)
-              EmbeddedValue.determine_type(klass)
+              EmbeddedValue
             elsif klass < Enumerable
               Collection
             end
@@ -62,7 +62,7 @@ module Virtus
 
       # @api private
       def initialize_coercer
-        @options.update(:coercer => @options.fetch(:coercer) { build_coercer })
+        @options.update(:coercer => @options.fetch(:coercer) { @klass.build_coercer(@type, @options) })
       end
 
       # @api private
@@ -106,14 +106,6 @@ module Virtus
         @options.update(:reader => reader_visibility, :writer => writer_visibility)
       end
 
-      # @api private
-      def build_coercer
-        Coercer.new(
-          @options.fetch(:configured_coercer) { Virtus.coercer },
-          @type.coercion_method
-        )
-      end
-
     end # class Builder
 
   end # class Attribute

data/lib/virtus/attribute/embedded_value.rb

@@ -25,28 +25,39 @@ module Virtus
     class EmbeddedValue < Attribute
       TYPES = [Struct, OpenStruct, Virtus, Model::Constructor].freeze
 
-      class FromStruct < self
+      class Coercer
+        attr_reader :primitive
+
+        def initialize(primitive)
+          @primitive = primitive
+        end
+
+      end # Coercer
+
+      class FromStruct < Coercer
 
         # @api public
-        def coerce(input)
+        def call(input)
           if input.kind_of?(primitive)
             input
           elsif not input.nil?
             primitive.new(*input)
           end
         end
+
       end # FromStruct
 
-      class FromOpenStruct < self
+      class FromOpenStruct < Coercer
 
         # @api public
-        def coerce(input)
+        def call(input)
           if input.kind_of?(primitive)
             input
           elsif not input.nil?
             primitive.new(input)
           end
         end
+
       end # FromOpenStruct
 
       # @api private
@@ -55,17 +66,19 @@ module Virtus
       end
 
       # @api private
-      def self.determine_type(klass)
-        if klass < Virtus || klass < Model::Constructor || klass <= OpenStruct
-          FromOpenStruct
-        elsif klass < Struct
-          FromStruct
-        end
+      def self.build_type(options)
+        Axiom::Types::Object.new { primitive options[:type] }
       end
 
       # @api private
-      def self.build_type(options)
-        Axiom::Types::Object.new { primitive options[:type] }
+      def self.build_coercer(type, _options)
+        primitive = type.primitive
+
+        if primitive < Virtus || primitive < Model::Constructor || primitive <= OpenStruct
+          FromOpenStruct.new(primitive)
+        elsif primitive < Struct
+          FromStruct.new(primitive)
+        end
       end
 
       # @api public
@@ -74,5 +87,6 @@ module Virtus
       end
 
     end # class EmbeddedValue
+
   end # class Attribute
 end # module Virtus

data/lib/virtus/attribute/strict.rb

@@ -4,10 +4,14 @@ module Virtus
     module Strict
 
       # @api public
-      def coerce(input)
-        coerced = super
-        raise ArgumentError unless coercer.success?(primitive, coerced)
-        coerced
+      def coerce(*)
+        output = super
+
+        if coercer.success?(primitive, output) || !required? && output.nil?
+          output
+        else
+          raise CoercionError.new(output, primitive)
+        end
       end
 
     end # Strict

data/lib/virtus/attribute.rb

@@ -5,9 +5,10 @@ module Virtus
 
     include ::Equalizer.new(:type, :options)
 
-    accept_options :primitive, :accessor, :default, :lazy, :strict
+    accept_options :primitive, :accessor, :default, :lazy, :strict, :required
 
     strict false
+    required true
     accessor :public
 
     # @see Virtus.coerce
@@ -42,6 +43,14 @@ module Virtus
       Builder.call(type, options)
     end
 
+    # @api private
+    def self.build_coercer(type, options = {})
+      Coercer.new(
+        options.fetch(:configured_coercer) { Virtus.coercer },
+        type.coercion_method
+      )
+    end
+
     # @api private
     def self.new(*args)
       attribute = super
@@ -83,6 +92,11 @@ module Virtus
       coercer.call(value)
     end
 
+    # @api public
+    def rename(name)
+      self.class.build(type, options.merge(:name => name))
+    end
+
     # @api public
     def value_coerced?(value)
       coercer.success?(primitive, value)
@@ -107,6 +121,11 @@ module Virtus
       kind_of?(Strict)
     end
 
+    # @api public
+    def required?
+      options[:required]
+    end
+
     # @api private
     def define_accessor_methods(attribute_set)
       attribute_set.define_reader_method(self, name,       options[:reader])

data/lib/virtus/const_missing_extensions.rb

@@ -9,7 +9,9 @@ module Virtus
     #
     # @api private
     def const_missing(name)
-      Attribute::Builder.determine_type(name) or Axiom::Types.const_get(name) or super
+      Attribute::Builder.determine_type(name) or
+        Axiom::Types.const_defined?(name) && Axiom::Types.const_get(name) or
+        super
     end
 
   end

data/lib/virtus/version.rb

@@ -1,3 +1,3 @@
 module Virtus
-  VERSION = '1.0.0.beta6'
+  VERSION = '1.0.0.beta7'
 end

data/lib/virtus.rb

@@ -10,6 +10,15 @@ module Virtus
   # Represents an undefined parameter used by auto-generated option methods
   Undefined = Object.new.freeze
 
+  class CoercionError < StandardError
+    attr_reader :output, :primitive
+
+    def initialize(output, primitive)
+      @output, @private = output, primitive
+      super("Failed to coerce #{output.inspect} into #{primitive.inspect}")
+    end
+  end
+
   # Extends base class or a module with virtus methods
   #
   # @param [Object] object

data/spec/integration/building_module_spec.rb

@@ -59,7 +59,7 @@ describe 'I can create a Virtus module' do
   specify 'including a custom module with strict enabled' do
     model = Examples::StrictModel.new
 
-    expect { model.stuff = 'foo' }.to raise_error(ArgumentError)
+    expect { model.stuff = 'foo' }.to raise_error(Virtus::CoercionError)
 
     model.happy = 'foo'
 

data/spec/integration/injectible_coercers_spec.rb

@@ -0,0 +1,48 @@
+require 'virtus'
+
+describe 'Injectible coercer' do
+  before do
+    module Examples
+      class EmailAddress
+        include Virtus.value_object
+
+        values do
+          attribute :address, String, :coercer => lambda { |add| add.downcase }
+        end
+
+        def self.coerce(input)
+          if input.is_a?(String)
+            new(:address => input)
+          else
+            new(input)
+          end
+        end
+      end
+
+      class User
+        include Virtus.model
+
+        attribute :email, EmailAddress,
+          :coercer => lambda { |input| Examples::EmailAddress.coerce(input) }
+      end
+    end
+  end
+
+  after do
+    Examples.send(:remove_const, :EmailAddress)
+    Examples.send(:remove_const, :User)
+  end
+
+  let(:doe) { Examples::EmailAddress.new(:address => 'john.doe@example.com') }
+
+  it 'accepts an email hash' do
+    user = Examples::User.new :email => { :address => 'John.Doe@Example.Com' }
+    expect(user.email).to eq(doe)
+  end
+
+  it 'coerces an embedded string' do
+    user = Examples::User.new :email => 'John.Doe@Example.Com'
+    expect(user.email).to eq(doe)
+  end
+
+end

data/spec/integration/required_attributes_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Using required attributes' do
+  before do
+    module Examples
+      class User
+        include Virtus.model(:strict => true)
+
+        attribute :name, String
+        attribute :age,  Integer, :required => false
+      end
+    end
+  end
+
+  it 'raises coercion error when required attribute is nil' do
+    expect { Examples::User.new(:name => nil) }.to raise_error(Virtus::CoercionError)
+  end
+
+  it 'does not raise coercion error when not required attribute is nil' do
+    user = Examples::User.new(:name => 'Jane', :age => nil)
+
+    expect(user.name).to eql('Jane')
+    expect(user.age).to be(nil)
+  end
+end

data/spec/unit/virtus/attribute/coerce_spec.rb

@@ -5,9 +5,14 @@ describe Virtus::Attribute, '#coerce' do
 
   fake(:coercer) { Virtus::Attribute::Coercer }
 
-  let(:object) { described_class.build(String, :coercer => coercer, :strict => strict) }
-  let(:input)  { 1 }
-  let(:output) { '1' }
+  let(:object)   {
+    described_class.build(String,
+      :coercer => coercer, :strict => strict, :required => required)
+  }
+
+  let(:required) { true }
+  let(:input)    { 1 }
+  let(:output)   { '1' }
 
   context 'when strict mode is turned off' do
     let(:strict) { false }
@@ -34,11 +39,40 @@ describe Virtus::Attribute, '#coerce' do
       expect(coercer).to have_received.success?(String, output)
     end
 
+    context 'when attribute is not required and input is nil' do
+      let(:required) { false }
+      let(:input)    { nil }
+
+      it 'returns nil' do
+        stub(coercer).call(input) { input }
+        stub(coercer).success?(String, input) { false }
+
+        expect(subject).to be(nil)
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, input)
+      end
+    end
+
+    context 'when attribute is required and input is nil' do
+      let(:input) { nil }
+
+      it 'returns raises error' do
+        stub(coercer).call(input) { input }
+        stub(coercer).success?(String, input) { false }
+
+        expect { subject }.to raise_error(Virtus::CoercionError)
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, input)
+      end
+    end
+
     it 'raises error when input was not coerced' do
       stub(coercer).call(input) { input }
       stub(coercer).success?(String, input) { false }
 
-      expect { subject }.to raise_error(ArgumentError)
+      expect { subject }.to raise_error(Virtus::CoercionError)
 
       expect(coercer).to have_received.call(input)
       expect(coercer).to have_received.success?(String, input)

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

@@ -8,7 +8,9 @@ describe Virtus::Attribute::EmbeddedValue, '.build' do
 
     it { should be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    its(:coercer) { should be_instance_of(described_class::FromOpenStruct) }
   end
 
   context 'when type includes Virtus' do
@@ -16,7 +18,9 @@ describe Virtus::Attribute::EmbeddedValue, '.build' do
 
     it { should be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    its(:coercer) { should be_instance_of(described_class::FromOpenStruct) }
   end
 
   context 'when type is an OpenStruct subclass' do
@@ -24,7 +28,9 @@ describe Virtus::Attribute::EmbeddedValue, '.build' do
 
     it { should be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    its(:coercer) { should be_instance_of(described_class::FromOpenStruct) }
   end
 
   context 'when type is OpenStruct' do
@@ -32,7 +38,9 @@ describe Virtus::Attribute::EmbeddedValue, '.build' do
 
     it { should be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    its(:coercer) { should be_instance_of(described_class::FromOpenStruct) }
   end
 
   context 'when type is Struct' do
@@ -40,6 +48,8 @@ describe Virtus::Attribute::EmbeddedValue, '.build' do
 
     it { should be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromStruct) }
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    its(:coercer) { should be_instance_of(described_class::FromStruct) }
   end
 end

data/spec/unit/virtus/attribute/rename_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#rename' do
+  subject { object.rename(:bar) }
+
+  let(:object) { described_class.build(String, :name => :foo, :strict => true) }
+  let(:other)  { described_class.build(String, :name => :bar, :strict => true) }
+
+  its(:name) { should be(:bar) }
+
+  it { should_not be(object) }
+  it { should be_strict }
+end

data/spec/unit/virtus/attribute/required_predicate_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#required?' do
+  subject { object.required? }
+
+  let(:object) { described_class.build(String, :required => required) }
+
+  context 'when required option is true' do
+    let(:required) { true }
+
+    it { should be(true) }
+  end
+
+  context 'when required option is false' do
+    let(:required) { false }
+
+    it { should be(false) }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: virtus
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta6
+  version: 1.0.0.beta7
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-25 00:00:00.000000000 Z
+date: 2013-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: descendants_tracker
@@ -145,8 +145,10 @@ files:
 - spec/integration/embedded_value_spec.rb
 - spec/integration/extending_objects_spec.rb
 - spec/integration/hash_attributes_coercion_spec.rb
+- spec/integration/injectible_coercers_spec.rb
 - spec/integration/mass_assignment_with_accessors_spec.rb
 - spec/integration/overriding_virtus_spec.rb
+- spec/integration/required_attributes_spec.rb
 - spec/integration/struct_as_embedded_value_spec.rb
 - spec/integration/using_modules_spec.rb
 - spec/integration/value_object_with_custom_constructor_spec.rb
@@ -171,6 +173,8 @@ files:
 - spec/unit/virtus/attribute/hash/class_methods/build_spec.rb
 - spec/unit/virtus/attribute/hash/coerce_spec.rb
 - spec/unit/virtus/attribute/lazy_predicate_spec.rb
+- spec/unit/virtus/attribute/rename_spec.rb
+- spec/unit/virtus/attribute/required_predicate_spec.rb
 - spec/unit/virtus/attribute/set_default_value_spec.rb
 - spec/unit/virtus/attribute/set_spec.rb
 - spec/unit/virtus/attribute/value_coerced_predicate_spec.rb
@@ -180,7 +184,6 @@ files:
 - spec/unit/virtus/attribute_set/each_spec.rb
 - spec/unit/virtus/attribute_set/element_reference_spec.rb
 - spec/unit/virtus/attribute_set/element_set_spec.rb
-- spec/unit/virtus/attribute_set/inspect_spec.rb
 - spec/unit/virtus/attribute_set/merge_spec.rb
 - spec/unit/virtus/attribute_set/reset_spec.rb
 - spec/unit/virtus/attribute_spec.rb

data/spec/unit/virtus/attribute_set/inspect_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::AttributeSet, '#inspect' do
-  subject { object.inspect }
-
-  let(:object) { described_class.new('Test') }
-
-  it { pending; should eql('Test::AttributeSet') }
-end