virtus 1.0.0.beta8 → 1.0.0.rc1

data/lib/virtus/attribute/builder.rb

@@ -1,19 +1,20 @@
 module Virtus
 
+  # Attribute placeholder used when type constant is passed as a string or symbol
+  #
   # @private
   class PendingAttribute
-    attr_reader :name
+    attr_reader :type, :options, :name
 
     # @api private
     def initialize(type, options)
-      @type    = type
-      @options = options
-      @name    = options[:name]
+      @type, @options = type.to_s, options
+      @name = options[:name]
     end
 
     # @api private
     def finalize
-      Attribute::Builder.call(determine_type, @options).finalize
+      Attribute::Builder.call(determine_type, options).finalize
     end
 
     # @api private
@@ -23,21 +24,24 @@ module Virtus
 
     # @api private
     def determine_type
-      if @type.include?('::')
+      if type.include?('::')
         # TODO: wrap it up in Virtus.constantize and use feature-detection to
         #       pick up either Inflecto or ActiveSupport, whateve is available
         if defined?(Inflecto)
-          Inflecto.constantize(@type)
+          Inflecto.constantize(type)
         else
           raise NotImplementedError, 'Virtus needs inflecto gem to constantize namespaced constant names'
         end
       else
-        Object.const_get(@type)
+        Object.const_get(type)
       end
     end
 
   end # PendingAttribute
 
+  # Extracts the actual type primitive from input type
+  #
+  # @private
   class TypeDefinition
     attr_reader :type, :primitive
 
@@ -76,13 +80,11 @@ module Virtus
 
   class Attribute
 
-    # TODO: this is a huge class and it might be a good idea to split it into
-    #       smaller chunks. We probably need some option parser with dedicated
-    #       sub-classes per attribute type (different one for Hash, Collection, EV)
+    # Builder is used to set up an attribute instance based on input type and options
     #
     # @private
     class Builder
-      attr_reader :attribute
+      attr_reader :attribute, :options, :type_definition, :klass, :type
 
       # @api private
       def self.call(type, options = {})
@@ -129,48 +131,54 @@ module Virtus
 
       # @api private
       def initialize_class
-        @klass = self.class.determine_type(@type_definition.primitive, Attribute)
+        @klass = self.class.determine_type(type_definition.primitive, Attribute)
       end
 
       # @api private
       def initialize_type
-        @type = @klass.build_type(@type_definition)
+        @type = klass.build_type(type_definition)
       end
 
       # @api private
       def initialize_options(options)
-        @options = @klass.options.merge(:coerce => Virtus.coerce).update(options)
-        @klass.merge_options!(@type, @options)
-        determine_visibility!
-      end
-
-      # @api private
-      def determine_visibility!
-        default_accessor  = @options.fetch(:accessor)
-        reader_visibility = @options.fetch(:reader, default_accessor)
-        writer_visibility = @options.fetch(:writer, default_accessor)
-        @options.update(:reader => reader_visibility, :writer => writer_visibility)
+        @options = klass.options.merge(:coerce => Virtus.coerce).update(options)
+        klass.merge_options!(type, @options)
+        determine_visibility
       end
 
       # @api private
       def initialize_default_value
-        @options.update(:default_value => DefaultValue.build(@options[:default]))
+        options.update(:default_value => DefaultValue.build(options[:default]))
       end
 
       # @api private
       def initialize_coercer
-        @options.update(:coercer => @options.fetch(:coercer) { @klass.build_coercer(@type, @options) })
+        options.update(:coercer => determine_coercer)
       end
 
       # @api private
       def initialize_attribute
-        @attribute = @klass.new(@type, @options) do |attribute|
-          attribute.extend(Accessor)    if @options[:name]
-          attribute.extend(Coercible)   if @options[:coerce]
-          attribute.extend(Strict)      if @options[:strict]
-          attribute.extend(LazyDefault) if @options[:lazy]
-        end
-        @attribute.finalize if @options[:finalize]
+        @attribute = klass.new(type, options)
+
+        @attribute.extend(Accessor)    if options[:name]
+        @attribute.extend(Coercible)   if options[:coerce]
+        @attribute.extend(Strict)      if options[:strict]
+        @attribute.extend(LazyDefault) if options[:lazy]
+
+        @attribute.finalize if options[:finalize]
+      end
+
+      # @api private
+      def determine_coercer
+        options.fetch(:coercer) { klass.build_coercer(type, options) }
+      end
+
+      # @api private
+      def determine_visibility
+        default_accessor  = options.fetch(:accessor)
+        reader_visibility = options.fetch(:reader, default_accessor)
+        writer_visibility = options.fetch(:writer, default_accessor)
+        options.update(:reader => reader_visibility, :writer => writer_visibility)
       end
 
     end # class Builder

data/lib/virtus/attribute/collection.rb

@@ -40,10 +40,17 @@ module Virtus
         def self.infer_member_type(type)
           return unless type.respond_to?(:count)
 
-          if type.count > 1
-            raise NotImplementedError, "build SumType from list of types (#{type})"
+          member_type =
+            if type.count > 1
+              raise NotImplementedError, "build SumType from list of types (#{type})"
+            else
+              type.first
+            end
+
+          if member_type.is_a?(Class) && member_type < Attribute && member_type.primitive
+            member_type.primitive
           else
-            type.first
+            member_type
           end
         end
 
@@ -59,9 +66,7 @@ module Virtus
 
       # @api private
       def self.merge_options!(type, options)
-        unless options.key?(:member_type)
-          options[:member_type] = Attribute.build(type.member_type)
-        end
+        options[:member_type] ||= Attribute.build(type.member_type)
       end
 
       # @api public

data/lib/virtus/attribute/embedded_value.rb

@@ -25,6 +25,9 @@ module Virtus
     class EmbeddedValue < Attribute
       TYPES = [Struct, OpenStruct, Virtus, Model::Constructor].freeze
 
+      # Abstract EV coercer class
+      #
+      # @private
       class Coercer
         attr_reader :primitive
 
@@ -34,6 +37,10 @@ module Virtus
 
       end # Coercer
 
+      # Builds Struct-like instance with attributes passed to the constructor as
+      # a list of args rather than a hash
+      #
+      # @private
       class FromStruct < Coercer
 
         # @api public
@@ -47,6 +54,10 @@ module Virtus
 
       end # FromStruct
 
+      # Builds OpenStruct-like instance with attributes passed to the constructor
+      # as a hash
+      #
+      # @private
       class FromOpenStruct < Coercer
 
         # @api public
@@ -67,8 +78,7 @@ module Virtus
 
       # @api private
       def self.build_type(definition)
-        klass = definition.primitive.is_a?(Class) ? definition.primitive : definition.type
-        Axiom::Types::Object.new { primitive klass }
+        Axiom::Types::Object.new { primitive definition.primitive }
       end
 
       # @api private
@@ -82,11 +92,6 @@ module Virtus
         end
       end
 
-      # @api public
-      def primitive
-        type.primitive
-      end
-
     end # class EmbeddedValue
 
   end # class Attribute

data/lib/virtus/attribute/hash.rb

@@ -57,7 +57,23 @@ module Virtus
           if type.size > 1
             raise ArgumentError, "more than one [key => value] pair in `#{type}`"
           else
-            { :key_type => type.keys.first, :value_type => type.values.first }
+            key_type, value_type = type.keys.first, type.values.first
+
+            key_primitive =
+              if key_type.is_a?(Class) && key_type < Attribute && key_type.primitive
+                key_type.primitive
+              else
+                key_type
+              end
+
+            value_primitive =
+              if value_type.is_a?(Class) && value_type < Attribute && value_type.primitive
+                value_type.primitive
+              else
+                value_type
+              end
+
+            { :key_type   => key_primitive, :value_type => value_primitive}
           end
         end
 
@@ -77,13 +93,8 @@ module Virtus
 
       # @api private
       def self.merge_options!(type, options)
-        unless options.key?(:key_type)
-          options[:key_type] = Attribute.build(type.key_type)
-        end
-
-        unless options.key?(:value_type)
-          options[:value_type] = Attribute.build(type.value_type)
-        end
+        options[:key_type]   ||= Attribute.build(type.key_type)
+        options[:value_type] ||= Attribute.build(type.value_type)
       end
 
       # @api public

data/lib/virtus/attribute_set.rb

@@ -182,22 +182,11 @@ module Virtus
     # @api private
     def set_defaults(object, filter = method(:skip_default?))
       each do |attribute|
-        if filter.call(object, attribute)
-          next
-        end
-        set_default(object, attribute)
+        next if filter.call(object, attribute)
+        attribute.set_default_value(object)
       end
     end
 
-    # Set default attribute
-    #
-    # @return [default value]
-    #
-    # @api private
-    def set_default(object, attribute)
-      attribute.set_default_value(object)
-    end
-
     # Coerce attributes received to a hash
     #
     # @return [Hash]

data/lib/virtus/builder.rb

@@ -0,0 +1,137 @@
+module Virtus
+
+  # Class to build a Virtus module with it's own config
+  #
+  # This allows for individual Virtus modules to be included in
+  # classes and not impacted by the global Virtus config,
+  # which is implemented using Virtus::config.
+  #
+  # @private
+  class Builder
+
+    # Return module
+    #
+    # @return [Module]
+    #
+    # @api private
+    attr_reader :mod
+
+    # Return config
+    #
+    # @return [config]
+    #
+    # @api private
+    attr_reader :config
+
+    # @api private
+    def self.call(options, &block)
+      new(Configuration.build(options, &block)).mod
+    end
+
+    # @api private
+    def self.pending
+      @pending ||= []
+    end
+
+    # Initializes a new Builder
+    #
+    # @param [Configuration] config
+    # @param [Module] mod
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(conf, mod = Module.new)
+      @config, @mod = conf, mod
+      add_included_hook
+      add_extended_hook
+    end
+
+    # @api private
+    def extensions
+      [Model::Core]
+    end
+
+    # @api private
+    def options
+      config.to_h
+    end
+
+    private
+
+    # Adds the .included hook to the anonymous module which then defines the
+    # .attribute method to override the default.
+    #
+    # @return [Module]
+    #
+    # @api private
+    def add_included_hook
+      with_hook_context do |context|
+        mod.define_singleton_method :included do |object|
+          Builder.pending << object unless context.finalize?
+          context.modules.each { |mod| object.send(:include, mod) }
+          object.define_singleton_method(:attribute, context.attribute_method)
+        end
+      end
+    end
+
+    # @api private
+    def add_extended_hook
+      with_hook_context do |context|
+        mod.define_singleton_method :extended do |object|
+          context.modules.each { |mod| object.extend(mod) }
+          object.define_singleton_method(:attribute, context.attribute_method)
+        end
+      end
+    end
+
+    # @api private
+    def with_hook_context
+      yield(HookContext.new(self, config))
+    end
+
+  end # class Builder
+
+  # @private
+  class ModelBuilder < Builder
+  end # ModelBuilder
+
+  # @private
+  class ModuleBuilder < Builder
+
+    private
+
+    # @api private
+    def add_included_hook
+      with_hook_context do |context|
+        mod.define_singleton_method :included do |object|
+          super(object)
+          object.extend(ModuleExtensions)
+          ModuleExtensions.setup(object, context.modules)
+          object.define_singleton_method(:attribute, context.attribute_method)
+        end
+      end
+    end
+
+  end # ModuleBuilder
+
+  # @private
+  class ValueObjectBuilder < Builder
+
+    # @api private
+    def extensions
+      super + [
+        Extensions::AllowedWriterMethods,
+        ValueObject::AllowedWriterMethods,
+        ValueObject::InstanceMethods
+      ]
+    end
+
+    # @api private
+    def options
+      super.merge(:writer => :private)
+    end
+
+  end # ValueObjectBuilder
+
+end # module Virtus

data/lib/virtus/builder/hook_context.rb

@@ -0,0 +1,51 @@
+module Virtus
+  class Builder
+
+    # Context used for building "included" and "extended" hooks
+    #
+    # @private
+    class HookContext
+      attr_reader :builder, :config, :attribute_method
+
+      # @api private
+      def initialize(builder, config)
+        @builder, @config = builder, config
+        initialize_attribute_method
+      end
+
+      # @api private
+      def modules
+        modules = builder.extensions
+        modules << Model::Constructor    if constructor?
+        modules << Model::MassAssignment if mass_assignment?
+        modules
+      end
+
+      # @api private
+      def constructor?
+        config.constructor
+      end
+
+      # @api private
+      def mass_assignment?
+        config.mass_assignment
+      end
+
+      # @api private
+      def finalize?
+        config.finalize
+      end
+
+      # @api private
+      def initialize_attribute_method
+        method_options = builder.options
+
+        @attribute_method = lambda do |name, type = nil, options = {}|
+          super(name, type, method_options.merge(options))
+        end
+      end
+
+    end # HookContext
+
+  end # Builder
+end # Virtus