virtus 0.5.5 → 1.0.0.beta3

data/TODO.md

@@ -0,0 +1,6 @@
+1.0.0.rc ROADMAP:
+
+  - Refactor to use soon-to-be-extracted axiom-types
+  - Add ability to pass in custom reader/writer *objects*
+  - Refactor to use extracted equalizer gem
+  - Tune Adamantium usage to memoize common methods in Attribute

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
-threshold: 18
-total_score: 340
+threshold: 13
+total_score: 321

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 18.2
+threshold: 21.4

data/config/mutant.yml

@@ -1,3 +1,14 @@
 ---
 name: virtus
-namespace: Virtus
+namespace:
+  - 'Virtus::Attribute'
+  - 'Virtus::AttributeSet'
+  - 'Virtus::ClassInclusions'
+  - 'Virtus::ClassMethods'
+  - 'Virtus::Configuration'
+  - 'Virtus::ConstMissingExtensions'
+  - 'Virtus::Extensions'
+  - 'Virtus::InstanceMethods'
+  - 'Virtus::ModuleBuilder'
+  - 'Virtus::ModuleExtensions'
+  - 'Virtus::ValueObject'

data/config/reek.yml

@@ -1,105 +1,96 @@
 ---
-UncommunicativeParameterName:
-  accept: []
+Attribute:
+  enabled: true
   exclude: []
+BooleanParameter:
   enabled: true
-  reject:
-  - !ruby/regexp /^.$/
-  - !ruby/regexp /[0-9]$/
-  - !ruby/regexp /[A-Z]/
-LargeClass:
-  max_methods: 14
   exclude: []
+ClassVariable:
   enabled: true
-  max_instance_variables: 8
-UncommunicativeMethodName:
-  accept: []
   exclude: []
+ControlParameter:
   enabled: true
-  reject:
-  - !ruby/regexp /^[a-z]$/
-  - !ruby/regexp /[0-9]$/
-  - !ruby/regexp /[A-Z]/
-LongParameterList:
-  max_params: 3
   exclude: []
+DataClump:
   enabled: true
-  overrides: {}
+  exclude: []
+  max_copies: 2
+  min_clump_size: 2
+DuplicateMethodCall:
+  enabled: false
 FeatureEnvy:
-  exclude: [
-    Virtus::Attribute::Boolean#value_coerced?,
-    Virtus::ClassMethods#build_attribute,
-    Virtus::Coercion::TimeCoercions#to_string,
-    Virtus::Coercion::TimeCoercions#coerce_with_method,
-    Virtus::TypeLookup#determine_type_from_primitive,
-    Virtus::ValueObject::ClassMethods#attribute
-  ]
   enabled: true
-ClassVariable:
   exclude: []
+IrresponsibleModule:
   enabled: true
-BooleanParameter:
   exclude: []
+LongParameterList:
   enabled: true
-IrresponsibleModule:
   exclude: []
+  max_params: 2
+LongYieldList:
   enabled: true
-UncommunicativeModuleName:
-  accept: []
   exclude: []
-  enabled: true
-  reject:
-  - !ruby/regexp /^.$/
-  - !ruby/regexp /[0-9]$/
+  max_params: 2
 NestedIterators:
+  enabled: true
+  max_allowed_nesting: 1
   ignore_iterators: []
   exclude: []
+NilCheck:
   enabled: true
-  max_allowed_nesting: 2
-LongMethod:
-  max_statements: 6
   exclude: []
+RepeatedConditional:
   enabled: true
-Duplication:
-  allow_calls: []
-  exclude: [
-    Virtus::Attribute::DefaultValue#evaluate
-  ]
+  exclude: []
+  max_ifs: 1
+TooManyInstanceVariables:
   enabled: true
-  max_calls: 1
-UtilityFunction:
-  max_helper_calls: 1
-  exclude: [
-    Virtus::Attribute::Boolean#value_coerced?,
-    Virtus::ClassMethods#build_attribute
-  ]
+  exclude: []
+  max_instance_variables: 3
+TooManyMethods:
   enabled: true
-Attribute:
   exclude: []
-  enabled: false
-UncommunicativeVariableName:
-  accept: []
+  max_methods: 10
+TooManyStatements:
+  enabled: true
   exclude: []
+  max_statements: 4
+UncommunicativeMethodName:
   enabled: true
+  exclude: []
   reject:
-  - !ruby/regexp /^.$/
+  - !ruby/regexp /^[a-z]$/
   - !ruby/regexp /[0-9]$/
   - !ruby/regexp /[A-Z]/
-SimulatedPolymorphism:
+  accept: []
+UncommunicativeModuleName:
+  enabled: true
   exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  accept: []
+UncommunicativeParameterName:
   enabled: true
-  max_ifs: 1
-DataClump:
   exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UncommunicativeVariableName:
   enabled: true
-  max_copies: 2
-  min_clump_size: 2
-ControlCouple:
-  exclude: [
-    'Virtus::InstanceMethods#initialize'
-  ]
+  exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UnusedParameters:
   enabled: true
-LongYieldList:
-  max_params: 1
   exclude: []
+UtilityFunction:
   enabled: true
+  exclude: []
+  max_helper_calls: 0

data/lib/virtus.rb

@@ -1,10 +1,4 @@
-require 'set'
-require 'date'
-require 'time'
-require 'bigdecimal'
-require 'bigdecimal/util'
 require 'ostruct'
-require 'backports'
 
 # Base module which adds Attribute API to your classes
 module Virtus
@@ -18,7 +12,7 @@ module Virtus
 
   # Extends base class or a module with virtus methods
   #
-  # @param [Class] descendant
+  # @param [Object] object
   #
   # @return [undefined]
   #
@@ -26,8 +20,10 @@ module Virtus
   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
@@ -41,22 +37,135 @@ module Virtus
   #
   # @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)
+    configuration.call(&block)
+  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)
+    ModelExtensionBuilder.call(options, &block)
+  end
+
+  # Builds a module for...modules
+  #
+  # @api public
+  def self.module(options = {}, &block)
+    ModuleExtensionBuilder.call(options, &block)
+  end
+
+  # Builds a module for value object models
+  #
+  # @api public
+  def self.value_object(options = {}, &block)
+    ValueObjectExtensionBuilder.call(options, &block)
+  end
+
+  # Global configuration instance
+  #
+  # @ return [Configuration]
+  #
+  # @api private
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # @api private
+  def self.warn(msg)
+    Kernel.warn(msg)
+  end
+
 end # module Virtus
 
 require 'descendants_tracker'
+require 'equalizer'
+require 'axiom-types'
+require 'coercible'
 
-require 'virtus/support/type_lookup'
-require 'virtus/support/options'
 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/module_builder'
+
 require 'virtus/class_methods'
 require 'virtus/instance_methods'
 
@@ -64,45 +173,20 @@ require 'virtus/value_object'
 
 require 'virtus/attribute_set'
 
-require 'virtus/coercion'
-require 'virtus/coercion/object'
-require 'virtus/coercion/numeric'
-require 'virtus/coercion/integer'
-require 'virtus/coercion/float'
-require 'virtus/coercion/decimal'
-require 'virtus/coercion/false_class'
-require 'virtus/coercion/true_class'
-require 'virtus/coercion/hash'
-require 'virtus/coercion/array'
-require 'virtus/coercion/time_coercions'
-require 'virtus/coercion/date'
-require 'virtus/coercion/date_time'
-require 'virtus/coercion/time'
-require 'virtus/coercion/string'
-require 'virtus/coercion/symbol'
-
 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/object'
-require 'virtus/attribute/class'
-require 'virtus/attribute/collection'
-require 'virtus/attribute/array'
-require 'virtus/attribute/set'
+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/boolean'
-require 'virtus/attribute/date'
-require 'virtus/attribute/date_time'
-require 'virtus/attribute/numeric'
-require 'virtus/attribute/decimal'
-require 'virtus/attribute/float'
+require 'virtus/attribute/collection'
 require 'virtus/attribute/hash'
-require 'virtus/attribute/integer'
-require 'virtus/attribute/symbol'
-require 'virtus/attribute/string'
-require 'virtus/attribute/time'
 require 'virtus/attribute/embedded_value'
-require 'virtus/attribute/embedded_value/from_struct'
-require 'virtus/attribute/embedded_value/from_open_struct'

data/lib/virtus/attribute.rb

@@ -1,49 +1,28 @@
 module Virtus
 
-  # Abstract class implementing base API for attribute types
-  #
-  # @abstract
   class Attribute
-    extend DescendantsTracker
-    extend TypeLookup
-    extend Options
-    include Equalizer.new(inspect) << :name << :options
+    extend DescendantsTracker, Options, TypeLookup
 
-    accept_options :primitive, :accessor, :reader,
-      :writer, :coercion_method, :default
+    include ::Equalizer.new(:type, :options)
 
+    accept_options :primitive, :accessor, :default, :lazy, :strict
+
+    strict false
     accessor :public
 
-    # Returns name of the attribute
-    #
-    # @example
-    #   User.attributes[:age].name  # => :age
+    # @see Virtus.coerce
     #
-    # @return [Symbol]
+    # @deprecated
     #
     # @api public
-    attr_reader :name
-
-    # Returns options hash for the attribute
-    #
-    # @return [Hash]
-    #
-    # @api private
-    attr_reader :options
+    def self.coerce(value = Undefined)
+      Virtus.warn "#{self}.coerce is deprecated and will be removed in 1.0.0. Use Virtus.coerce instead: ##{caller.first}"
+      return Virtus.coerce if value.equal?(Undefined)
+      Virtus.coerce = value
+      self
+    end
 
-    # Returns method name that should be used for coerceing
-    #
-    # @return [Symbol]
-    #
-    # @api private
-    attr_reader :coercion_method
-
-    # Returns default value
-    #
-    # @return [Object]
-    #
-    # @api private
-    attr_reader :default
+    attr_reader :type, :primitive, :options, :default_value, :coercer
 
     # Builds an attribute instance
     #
@@ -59,54 +38,25 @@ module Virtus
     # @return [Attribute]
     #
     # @api private
-    def self.build(name, type = Object, options = {})
-      attribute_class = determine_type(type) or
-        raise ArgumentError, "#{type.inspect} does not map to an attribute type"
-      attribute_options = attribute_class.merge_options(type, options)
-      attribute_class.new(name, attribute_options)
+    def self.build(type, options = {})
+      Builder.call(type, options)
     end
 
-    # Determine attribute type based on class or name
-    #
-    # Returns Attribute::EmbeddedValue if a virtus class is passed
-    #
-    # @example
-    #   address_class = Class.new { include Virtus }
-    #   Virtus::Attribute.determine_type(address_class) # => Virtus::Attribute::EmbeddedValue
-    #
-    # @see Virtus::Support::TypeLookup.determine_type
-    #
-    # @return [Class]
-    #
-    # @api public
-    def self.determine_type(class_or_name)
-      case class_or_name
-      when ::Class
-        Attribute::EmbeddedValue.determine_type(class_or_name) || super
-      when ::String
-        super
-      when ::Enumerable
-        super(class_or_name.class)
-      else
-        super
-      end
+    # @api private
+    def self.new(*args)
+      attribute = super
+      yield(attribute)
+      attribute.finalize
     end
 
-    # A hook for Attributes to update options based on the type from the caller
-    #
-    # @param [Object] type
-    #   The raw type, typically given by the caller of ClassMethods#attribute
-    # @param [Hash] options
-    #   Attribute configuration options
-    #
-    # @return [Hash]
-    #   New Hash instance, potentially updated with information from the args
-    #
     # @api private
-    #
-    # @todo add type arg to Attribute#initialize signature and handle there?
-    def self.merge_options(type, options)
-      options
+    def self.build_type(options)
+      Axiom::Types.infer(options[:primitive])
+    end
+
+    # @api private
+    def self.merge_options!(*)
+      # noop
     end
 
     # Initializes an attribute instance
@@ -120,192 +70,54 @@ module Virtus
     # @return [undefined]
     #
     # @api private
-    def initialize(name, options = {})
-      @name                   = name.to_sym
-      @options                = self.class.options.merge(options).freeze
-      @instance_variable_name = "@#{@name}".to_sym
-      @primitive              = @options.fetch(:primitive)
-      @coercion_method        = @options.fetch(:coercion_method)
-      @default                = DefaultValue.build(@options[:default])
-      initialize_visibility
-    end
-
-    # Returns a concise string representation of the attribute instance
-    #
-    # @example
-    #   attribute = Virtus::Attribute::String.new(:name)
-    #   attribute.inspect # => #<Virtus::Attribute::String @name=:name>
-    #
-    # @return [String]
-    #
-    # @api public
-    def inspect
-      "#<#{self.class.inspect} @name=#{name.inspect}>"
+    def initialize(type, options)
+      @type          = type
+      @primitive     = type.primitive
+      @options       = options
+      @default_value = options.fetch(:default_value)
+      @coercer       = options.fetch(:coercer)
     end
 
-    # Returns value of an attribute for the given instance
-    #
-    # Sets the default value if an ivar is not set and default
-    # value is configured
-    #
-    # @example
-    #   attribute.get(instance)  # => value
-    #
-    # @return [Object]
-    #   value of an attribute
-    #
     # @api public
-    def get(instance)
-      if instance.instance_variable_defined?(@instance_variable_name)
-        get!(instance)
-      else
-        value = default.call(instance, self)
-        set!(instance, value)
-        value
-      end
+    def coerce(value)
+      coercer.call(value)
     end
 
-    # Returns the instance variable of the attribute
-    #
-    # @example
-    #   attribute.get!(instance)  # => value
-    #
-    # @return [Object]
-    #   value of an attribute
-    #
     # @api public
-    def get!(instance)
-      instance.instance_variable_get(@instance_variable_name)
+    def value_coerced?(value)
+      coercer.success?(primitive, value)
     end
 
-    # Sets the value on the instance
-    #
-    # @example
-    #   attribute.set(instance, value)  # => value
+    # Return if the attribute is coercible
     #
-    # @return [self]
+    # @return [Boolean]
     #
     # @api public
-    def set(instance, value)
-      set!(instance, coerce(value))
+    def coercible?
+      kind_of?(Coercible)
     end
 
-    # Sets instance variable of the attribute
-    #
-    # @example
-    #   attribute.set!(instance, value)  # => value
-    #
-    # @return [self]
-    #
     # @api public
-    def set!(instance, value)
-      instance.instance_variable_set(@instance_variable_name, value)
-      self
+    def lazy?
+      kind_of?(LazyDefault)
     end
 
-    # Converts the given value to the primitive type
-    #
-    # @example
-    #   attribute.coerce(value)  # => primitive_value
-    #
-    # @param [Object] value
-    #   the value
-    #
-    # @return [Object]
-    #   nil, original value or value converted to the primitive type
-    #
     # @api public
-    def coerce(value)
-      Coercion[value.class].public_send(coercion_method, value)
+    def strict?
+      kind_of?(Strict)
     end
 
-    # Is the given value coerced into the target type for this attribute?
-    #
-    # @example
-    #   string_attribute = Virtus::Attribute::String.new(:str)
-    #   string_attribute.value_coerced?('foo')        # => true
-    #   string_attribute.value_coerced?(:foo)         # => false
-    #   integer_attribute = Virtus::Attribute::Integer.new(:integer)
-    #   integer_attribute.value_coerced?(5)           # => true
-    #   integer_attribute.value_coerced?('5')         # => false
-    #   date_attribute = Virtus::Attribute::Date.new(:date)
-    #   date_attribute.value_coerced?('2011-12-31')   # => false
-    #   date_attribute.value_coerced?(Date.today)     # => true
-    #
-    # @return [Boolean]
-    #
     # @api private
-    def value_coerced?(value)
-      @primitive === value
+    def define_accessor_methods(attribute_set)
+      attribute_set.define_reader_method(self, name,       options[:reader])
+      attribute_set.define_writer_method(self, "#{name}=", options[:writer])
     end
 
-    # Define reader and writer methods for an Attribute
-    #
-    # @param [Attribute] attribute
-    #
-    # @return [self]
-    #
-    # @api private
-    def define_accessor_methods(mod)
-      define_reader_method(mod)
-      define_writer_method(mod)
-      self
-    end
-
-    # Creates an attribute reader method
-    #
-    # @param [Module] mod
-    #
-    # @return [self]
-    #
     # @api private
-    def define_reader_method(mod)
-      mod.define_reader_method(self, name, @reader_visibility)
-      self
-    end
-
-    # Creates an attribute writer method
-    #
-    # @param [Module] mod
-    #
-    # @return [self]
-    #
-    # @api private
-    def define_writer_method(mod)
-      mod.define_writer_method(self, "#{name}=".to_sym, @writer_visibility)
-      self
-    end
-
-    # Returns a Boolean indicating whether the reader method is public
-    #
-    # @return [Boolean]
-    #
-    # @api private
-    def public_reader?
-      @reader_visibility == :public
-    end
-
-    # Returns a Boolean indicating whether the writer method is public
-    #
-    # @return [Boolean]
-    #
-    # @api private
-    def public_writer?
-      @writer_visibility == :public
-    end
-
-  private
-
-    # Initialize visibility of reader/write methods based on the options hash
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def initialize_visibility
-      default_accessor = @options.fetch(:accessor)
-      @reader_visibility = @options.fetch(:reader, default_accessor)
-      @writer_visibility = @options.fetch(:writer, default_accessor)
+    def finalize
+      freeze
     end
 
   end # class Attribute
+
 end # module Virtus