virtus2 2.0.1

data/lib/virtus/version.rb

@@ -0,0 +1,3 @@
+module Virtus
+  VERSION = '2.0.1'.freeze
+end

data/lib/virtus.rb

@@ -0,0 +1,310 @@
+require 'ostruct'
+
+# Base module which adds Attribute API to your classes
+module Virtus
+
+  # Provides args for const_get and const_defined? to make them behave
+  # consistently across different versions of ruby
+  EXTRA_CONST_ARGS = (RUBY_VERSION < '1.9' ? [] : [ false ]).freeze
+
+  # Represents an undefined parameter used by auto-generated option methods
+  Undefined = Object.new.freeze
+
+  class CoercionError < StandardError
+    attr_reader :output, :attribute
+
+    def initialize(output, attribute)
+      @output, @attribute = output, attribute
+      super(build_message)
+    end
+
+    def build_message
+      if attribute_name?
+        "Failed to coerce attribute `#{attribute_name}' from #{output.inspect} into #{target_type}"
+      else
+        "Failed to coerce #{output.inspect} into #{target_type}"
+      end
+    end
+
+    def attribute_name
+      attribute.options[:name]
+    end
+
+    def attribute_name?
+      attribute_name ? true : false
+    end
+
+    def target_type
+      if attribute.respond_to?(:coercion_error_message)
+        attribute.coercion_error_message
+      else
+        attribute.primitive.inspect
+      end
+    end
+  end
+
+  # Extends base class or a module with virtus methods
+  #
+  # @param [Object] object
+  #
+  # @return [undefined]
+  #
+  # @deprecated
+  #
+  # @api private
+  def self.included(object)
+    super
+    if Class === object
+      Virtus.warn("including Virtus module is deprecated. Use 'include Virtus.model' instead #{caller.first}")
+      object.send(:include, ClassInclusions)
+    else
+      Virtus.warn("including Virtus module is deprecated. Use 'include Virtus.module' instead #{caller.first}")
+      object.extend(ModuleExtensions)
+    end
+  end
+  private_class_method :included
+
+  # Extends an object with virtus extensions
+  #
+  # @param [Object] object
+  #
+  # @return [undefined]
+  #
+  # @deprecated
+  #
+  # @api private
+  def self.extended(object)
+    Virtus.warn("extending with Virtus module is deprecated. Use 'extend(Virtus.model)' instead #{caller.first}")
+    object.extend(Extensions)
+  end
+  private_class_method :extended
+
+  # Sets the global coercer configuration
+  #
+  # @example
+  #   Virtus.coercer do |config|
+  #     config.string.boolean_map = { true => '1', false => '0' }
+  #   end
+  #
+  # @return [Coercible::Coercer]
+  #
+  # @api public
+  def self.coercer(&block)
+    configuration.coercer(&block)
+  end
+
+  # Sets the global coercion configuration value
+  #
+  # @param [Boolean] value
+  #
+  # @return [Virtus]
+  #
+  # @api public
+  def self.coerce=(value)
+    configuration.coerce = value
+    self
+  end
+
+  # Returns the global coercion setting
+  #
+  # @return [Boolean]
+  #
+  # @api public
+  def self.coerce
+    configuration.coerce
+  end
+
+  # Provides access to the global Virtus configuration
+  #
+  # @example
+  #   Virtus.config do |config|
+  #     config.coerce = false
+  #   end
+  #
+  # @return [Configuration]
+  #
+  # @api public
+  def self.config(&block)
+    yield configuration if block_given?
+    configuration
+  end
+
+  # Provides access to the Virtus module builder
+  # see Virtus::ModuleBuilder
+  #
+  # @example
+  #   MyVirtusModule = Virtus.module { |mod|
+  #     mod.coerce = true
+  #     mod.string.boolean_map = { 'yup' => true, 'nope' => false }
+  #   }
+  #
+  #  class Book
+  #    include MyVirtusModule
+  #
+  #    attribute :published, Boolean
+  #  end
+  #
+  #  # This could be made more succinct as well
+  #  class OtherBook
+  #    include Virtus.module { |m| m.coerce = false }
+  #  end
+  #
+  # @return [Module]
+  #
+  # @api public
+  def self.model(options = {}, &block)
+    ModelBuilder.call(options, &block)
+  end
+
+  # Builds a module for...modules
+  #
+  # @example
+  #
+  #   module Common
+  #     include Virtus.module
+  #
+  #     attribute :name, String
+  #     attribute :age,  Integer
+  #   end
+  #
+  #   class User
+  #     include Common
+  #   end
+  #
+  #   class Admin
+  #     include Common
+  #   end
+  #
+  # @return [Module]
+  #
+  # @api public
+  def self.module(options = {}, &block)
+    ModuleBuilder.call(options, &block)
+  end
+
+  # Builds a module for value object models
+  #
+  # @example
+  #
+  #   class GeoLocation
+  #     include Virtus.value_object
+  #
+  #     values do
+  #       attribute :lat, Float
+  #       attribute :lng, Float
+  #     end
+  #   end
+  #
+  # @return [Module]
+  #
+  # @api public
+  def self.value_object(options = {}, &block)
+    ValueObjectBuilder.call(options, &block)
+  end
+
+  # Global configuration instance
+  #
+  # @ return [Configuration]
+  #
+  # @api private
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # @api private
+  def self.constantize(type)
+    inflector.constantize(type)
+  end
+
+  # @api private
+  def self.inflector
+    @inflector ||=
+      begin
+        require 'dry/inflector'
+        Dry::Inflector.new
+      rescue LoadError
+        raise(
+          NotImplementedError,
+          'Virtus needs dry-inflector gem to constantize namespaced constant names'
+        )
+      end
+  end
+
+  # Finalize pending attributes
+  #
+  # @example
+  #   class User
+  #     include Virtus.model(:finalize => false)
+  #
+  #     attribute :address, 'Address'
+  #   end
+  #
+  #   class Address
+  #     include Virtus.model(:finalize => false)
+  #
+  #     attribute :user, 'User'
+  #   end
+  #
+  #   Virtus.finalize # this will resolve constant names
+  #
+  # @return [Array] array of finalized models
+  #
+  # @api public
+  def self.finalize
+    Builder.pending.each do |klass|
+      klass.attribute_set.finalize
+    end
+  end
+
+  # @api private
+  def self.warn(msg)
+    Kernel.warn(msg)
+  end
+
+end # module Virtus
+
+require 'descendants_tracker'
+require 'axiom-types'
+require 'coercible'
+
+require 'virtus/support/equalizer'
+require 'virtus/support/options'
+require 'virtus/support/type_lookup'
+
+require 'virtus/model'
+require 'virtus/extensions'
+require 'virtus/const_missing_extensions'
+require 'virtus/class_inclusions'
+require 'virtus/module_extensions'
+
+require 'virtus/configuration'
+require 'virtus/builder'
+require 'virtus/builder/hook_context'
+
+require 'virtus/class_methods'
+require 'virtus/instance_methods'
+
+require 'virtus/value_object'
+
+require 'virtus/coercer'
+require 'virtus/attribute_set'
+
+require 'virtus/attribute/default_value'
+require 'virtus/attribute/default_value/from_clonable'
+require 'virtus/attribute/default_value/from_callable'
+require 'virtus/attribute/default_value/from_symbol'
+
+require 'virtus/attribute'
+require 'virtus/attribute/builder'
+require 'virtus/attribute/coercer'
+require 'virtus/attribute/accessor'
+require 'virtus/attribute/coercible'
+require 'virtus/attribute/strict'
+require 'virtus/attribute/lazy_default'
+require 'virtus/attribute/nullify_blank'
+
+require 'virtus/attribute/boolean'
+require 'virtus/attribute/collection'
+require 'virtus/attribute/enum'
+require 'virtus/attribute/hash'
+require 'virtus/attribute/embedded_value'

data/spec/integration/attributes_attribute_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "Adding attribute called 'attributes'" do
+
+  context "when mass assignment is disabled" do
+    before do
+      module Examples
+        class User
+          include Virtus.model(mass_assignment: false)
+
+          attribute :attributes
+        end
+      end
+    end
+
+    it "allows model to use `attributes` attribute" do
+      user = Examples::User.new
+      expect(user.attributes).to eq(nil)
+      user.attributes = "attributes string"
+      expect(user.attributes).to eq("attributes string")
+    end
+
+    it "doesn't accept `attributes` key in initializer" do
+      user = Examples::User.new(attributes: 'attributes string')
+      expect(user.attributes).to eq(nil)
+    end
+  end
+end

data/spec/integration/building_module_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe 'I can create a Virtus module' do
+  before do
+    module Examples
+      NoncoercingModule = Virtus.model { |config|
+        config.coerce = false
+      }
+
+      CoercingModule = Virtus.model { |config|
+        config.coerce = true
+
+        config.coercer do |coercer|
+          coercer.string.boolean_map = { 'yup' => true, 'nope' => false }
+        end
+      }
+
+      StrictModule = Virtus.model { |config|
+        config.strict = true
+      }
+
+      BlankModule = Virtus.model { |config|
+        config.nullify_blank = true
+      }
+
+      class NoncoercedUser
+        include NoncoercingModule
+
+        attribute :name, String
+        attribute :happy, String
+      end
+
+      class CoercedUser
+        include CoercingModule
+
+        attribute :name, String
+        attribute :happy, Boolean
+      end
+
+      class StrictModel
+        include StrictModule
+
+        attribute :stuff, Hash
+        attribute :happy, Boolean, :strict => false
+      end
+
+      class BlankModel
+        include BlankModule
+
+        attribute :stuff, Hash
+        attribute :happy, Boolean, :nullify_blank => false
+      end
+    end
+  end
+
+  specify 'including a custom module with coercion disabled' do
+    user = Examples::NoncoercedUser.new(:name => :Giorgio, :happy => 'yes')
+
+    expect(user.name).to be(:Giorgio)
+    expect(user.happy).to eql('yes')
+  end
+
+  specify 'including a custom module with coercion enabled' do
+    user = Examples::CoercedUser.new(:name => 'Paul', :happy => 'nope')
+
+    expect(user.name).to eql('Paul')
+    expect(user.happy).to be(false)
+  end
+
+  specify 'including a custom module with strict enabled' do
+    model = Examples::StrictModel.new
+
+    expect { model.stuff = 'foo' }.to raise_error(Virtus::CoercionError)
+
+    model.happy = 'foo'
+
+    expect(model.happy).to eql('foo')
+  end
+
+  specify 'including a custom module with nullify blank enabled' do
+    model = Examples::BlankModel.new
+
+    model.stuff = ''
+    expect(model.stuff).to be_nil
+
+    model.happy = 'foo'
+
+    expect(model.happy).to eql('foo')
+  end
+end

data/spec/integration/collection_member_coercion_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+# TODO: refactor to make it inline with the new style of integration specs
+
+class Address
+  include Virtus
+
+  attribute :address,     String
+  attribute :locality,    String
+  attribute :region,      String
+  attribute :postal_code, String
+end
+
+class PhoneNumber
+  include Virtus
+
+  attribute :number, String
+end
+
+class User
+  include Virtus
+
+  attribute :phone_numbers, Array[PhoneNumber]
+  attribute :addresses,     Set[Address]
+end
+
+describe User do
+  it { is_expected.to respond_to(:phone_numbers)  }
+  it { is_expected.to respond_to(:phone_numbers=) }
+  it { is_expected.to respond_to(:addresses)  }
+  it { is_expected.to respond_to(:addresses=) }
+
+  let(:instance) do
+    described_class.new(:phone_numbers => phone_numbers_attributes,
+                        :addresses     => addresses_attributes)
+  end
+
+  let(:phone_numbers_attributes) { [
+    { :number => '212-555-1212' },
+    { :number => '919-444-3265' },
+  ] }
+
+  let(:addresses_attributes) { [
+    { :address => '1234 Any St.', :locality => 'Anytown', :region => "DC", :postal_code => "21234" },
+  ] }
+
+  describe '#phone_numbers' do
+    describe 'first entry' do
+      subject { instance.phone_numbers.first }
+
+      it { is_expected.to be_instance_of(PhoneNumber) }
+
+      describe '#number' do
+        subject { super().number }
+        it { is_expected.to eql('212-555-1212') }
+      end
+    end
+
+    describe 'last entry' do
+      subject { instance.phone_numbers.last }
+
+      it { is_expected.to be_instance_of(PhoneNumber) }
+
+      describe '#number' do
+        subject { super().number }
+        it { is_expected.to eql('919-444-3265') }
+      end
+    end
+  end
+
+  describe '#addresses' do
+    subject { instance.addresses.first }
+
+    it { is_expected.to be_instance_of(Address) }
+
+    describe '#address' do
+      subject { super().address }
+      it { is_expected.to eql('1234 Any St.') }
+    end
+
+    describe '#locality' do
+      subject { super().locality }
+      it { is_expected.to eql('Anytown')      }
+    end
+
+    describe '#region' do
+      subject { super().region }
+      it { is_expected.to eql('DC')           }
+    end
+
+    describe '#postal_code' do
+      subject { super().postal_code }
+      it { is_expected.to eql('21234')        }
+    end
+  end
+end