virtus 0.5.5 → 1.0.0.beta3

data/lib/virtus/model.rb

@@ -0,0 +1,68 @@
+module Virtus
+
+  module Model
+
+    # @api private
+    def self.included(descendant)
+      super
+      descendant.send(:include, ClassInclusions) if Class === descendant
+    end
+
+    # @api private
+    def self.extended(descendant)
+      super
+      descendant.extend(Extensions)
+    end
+
+    module Core
+
+      # @api private
+      def self.included(descendant)
+        super
+        descendant.extend(ClassMethods)
+        descendant.send(:include, ClassInclusions::Methods)
+        descendant.send(:include, InstanceMethods)
+      end
+      private_class_method :included
+
+      # @api private
+      def self.extended(descendant)
+        super
+        descendant.extend(Extensions::Methods)
+        descendant.extend(InstanceMethods)
+      end
+      private_class_method :included
+
+    end # Core
+
+    module Constructor
+
+      # @api private
+      def self.included(descendant)
+        super
+        descendant.send(:include, InstanceMethods::Constructor)
+      end
+      private_class_method :included
+
+    end # Constructor
+
+    module MassAssignment
+
+      # @api private
+      def self.included(descendant)
+        super
+        descendant.send(:include, InstanceMethods::MassAssignment)
+      end
+      private_class_method :included
+
+      # @api private
+      def self.extended(descendant)
+        super
+        descendant.extend(InstanceMethods::MassAssignment)
+      end
+      private_class_method :included
+
+    end # MassAssignment
+
+  end # Model
+end # Virtus

data/lib/virtus/module_builder.rb

@@ -0,0 +1,184 @@
+module Virtus
+
+  # Class to build a Virtus module with it's own configuration
+  #
+  # This allows for individual Virtus modules to be included in
+  # classes and not impacted by the global Virtus configuration,
+  # which is implemented using Virtus::Configuration.
+  #
+  # @private
+  class ExtensionBuilder
+
+    # Return module
+    #
+    # @return [Module]
+    #
+    # @api private
+    attr_reader :module
+
+    # Return configuration
+    #
+    # @return [Configuration]
+    #
+    # @api private
+    attr_reader :configuration
+
+    # Builds a new Virtus module
+    #
+    # The block is passed to Virtus::Configuration
+    #
+    # @example
+    #   ModuleBuilder.call do |config|
+    #     # config settings
+    #   end
+    #
+    # @return [Module]
+    #
+    # @api public
+    def self.call(options = {}, &block)
+      config  = Configuration.build(&block)
+      options.each { |key, value| config.public_send("#{key}=", value) }
+      builder = new(config)
+      builder.add_included_hook
+      builder.add_extended_hook
+      builder.module
+    end
+
+    # Initializes a new ModuleBuilder
+    #
+    # @param [Configuration] configuration
+    #
+    # @param [Module] mod
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(configuration, mod = Module.new)
+      @configuration = configuration
+      @module        = mod
+    end
+
+    # 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
+      attribute_proc  = attribute_method(configuration)
+      constructor     = configuration.constructor
+      mass_assignment = configuration.mass_assignment
+      extensions      = core_extensions
+      inclusions      = core_inclusions
+
+      self.module.define_singleton_method :included do |object|
+        super(object)
+        extensions.each { |mod| object.extend(mod) }
+        inclusions.each { |mod| object.send(:include, mod) }
+        object.send(:include, Model::Constructor)    if constructor
+        object.send(:include, Model::MassAssignment) if mass_assignment
+        object.send(:define_singleton_method, :attribute, attribute_proc)
+      end
+    end
+
+    # @api private
+    def add_extended_hook
+      attribute_proc  = attribute_method(configuration)
+      mass_assignment = configuration.mass_assignment
+      extensions      = core_inclusions + core_extensions
+
+      self.module.define_singleton_method :extended do |object|
+        super(object)
+        extensions.each { |mod| object.extend(mod) }
+        object.extend(Model::MassAssignment) if mass_assignment
+        object.send :define_singleton_method, :attribute, attribute_proc
+      end
+    end
+
+    # Wrapper for the attribute method that is used in .add_included_hook
+    # The coercer is passed in the unused key :configured_coercer to allow the
+    # property encapsulation by Virtus::Attribute::Coercer, where the
+    # coercion method is known.
+    #
+    # @return [Proc(lambda)]
+    #
+    # @api private
+    def attribute_method(configuration)
+      module_options = self.module_options
+
+      lambda do |name, type, options = {}|
+        super(name, type, module_options.merge(options))
+      end
+    end
+
+    # @api private
+    def module_options
+      { :coerce             => configuration.coerce,
+        :strict             => configuration.strict,
+        :configured_coercer => configuration.coercer }
+    end
+
+    # @api private
+    def core_inclusions
+      [Model::Core]
+    end
+
+    # @api private
+    def core_extensions
+      []
+    end
+
+  end # class ExtensionBuilder
+
+  # @private
+  class ModelExtensionBuilder < ExtensionBuilder
+  end # ModelExtensionBuilder
+
+  # @private
+  class ModuleExtensionBuilder < ExtensionBuilder
+
+    # @api private
+    def add_included_hook
+      attribute_proc = attribute_method(configuration)
+      inclusions     = core_inclusions
+
+      inclusions << Model::Constructor    if configuration.constructor
+      inclusions << Model::MassAssignment if configuration.mass_assignment
+
+      self.module.define_singleton_method :included do |object|
+        super(object)
+        object.extend(ModuleExtensions)
+        object.instance_variable_set('@inclusions', inclusions)
+        object.send(:define_singleton_method, :attribute, attribute_proc)
+      end
+    end
+
+  end # ModuleExtensionBuilder
+
+  # @private
+  class ValueObjectExtensionBuilder < ExtensionBuilder
+
+    # @api private
+    def initialize(configuration, mod = Module.new)
+      super
+      @configuration.constructor = true
+    end
+
+    # @api private
+    def module_options
+      super.update(:writer => :private)
+    end
+
+    # @api private
+    def core_inclusions
+      super << ValueObject::AllowedWriterMethods << ValueObject::InstanceMethods
+    end
+
+    # @api private
+    def core_extensions
+      super << ValueObject::AllowedWriterMethods
+    end
+
+  end # ValueObjectBuilder
+
+end # module Virtus

data/lib/virtus/module_extensions.rb

@@ -2,7 +2,21 @@ module Virtus
 
   # Virtus module that can define attributes for later inclusion
   #
+  # @private
   module ModuleExtensions
+    include ConstMissingExtensions
+
+    # @api private
+    def self.extended(mod)
+      super
+      setup(mod)
+    end
+
+    # @api private
+    def self.setup(mod, inclusions = [Model], attribute_definitions = [])
+      mod.instance_variable_set('@inclusions', inclusions)
+      mod.instance_variable_set('@attribute_definitions', attribute_definitions)
+    end
 
     # Define an attribute in the module
     #
@@ -11,12 +25,12 @@ module Virtus
     # @return [self]
     #
     # @api private
-    def attribute(*args)
-      attribute_definitions << args
+    def attribute(name, type, options = {})
+      @attribute_definitions << [name, type, options]
       self
     end
 
-  private
+    private
 
     # Extend an object with Virtus methods and define attributes
     #
@@ -27,8 +41,9 @@ module Virtus
     # @api private
     def extended(object)
       super
-      object.extend(Virtus)
+      @inclusions.each { |mod| object.extend(mod) }
       define_attributes(object)
+      object.set_default_attributes
     end
 
     # Extend a class with Virtus methods and define attributes
@@ -40,17 +55,14 @@ module Virtus
     # @api private
     def included(object)
       super
-      object.module_eval { include Virtus }
-      define_attributes(object)
-    end
 
-    # Return attribute definitions
-    #
-    # @return [Array<Hash>]
-    #
-    # @api private
-    def attribute_definitions
-      @_attribute_definitions ||= []
+      if Class === object
+        @inclusions.each { |mod| object.send(:include, mod) }
+        define_attributes(object)
+      else
+        object.extend(ModuleExtensions)
+        ModuleExtensions.setup(object, @inclusions, @attribute_definitions)
+      end
     end
 
     # Define attributes on a class or instance
@@ -61,7 +73,7 @@ module Virtus
     #
     # @api private
     def define_attributes(object)
-      attribute_definitions.each do |attribute_args|
+      @attribute_definitions.each do |attribute_args|
         object.attribute(*attribute_args)
       end
     end

data/lib/virtus/support/equalizer.rb

@@ -105,7 +105,7 @@ module Virtus
       #
       # @api public
       def eql?(other)
-        instance_of?(other.class) and cmp?(__method__, other)
+        instance_of?(other.class) && cmp?(__method__, other)
       end
 
       # Compare the object with other object for equivalency
@@ -120,8 +120,7 @@ module Virtus
       #
       # @api public
       def ==(other)
-        return false unless self.class <=> other.class
-        cmp?(__method__, other)
+        other.kind_of?(self.class) && cmp?(__method__, other)
       end
 
     end # module Methods

data/lib/virtus/support/type_lookup.rb

@@ -81,7 +81,7 @@ module Virtus
     # @api private
     def determine_type_from_primitive(primitive)
       type = nil
-      descendants.reverse_each do |descendant|
+      descendants.select(&:primitive).reverse_each do |descendant|
         descendant_primitive = descendant.primitive
         next unless primitive <= descendant_primitive
         type = descendant if type.nil? or type.primitive > descendant_primitive

data/lib/virtus/value_object.rb

@@ -31,10 +31,13 @@ module Virtus
     #
     # @api private
     def self.included(base)
+      Virtus.warn "Virtus::ValueObject is deprecated and will be removed in 1.0.0 #{caller.first}"
+
       base.instance_eval do
         include ::Virtus
         include InstanceMethods
         extend ClassMethods
+        extend AllowedWriterMethods
         private :attributes=
       end
     end
@@ -43,19 +46,6 @@ module Virtus
 
     module InstanceMethods
 
-      # the #get_attributes method accept a Proc object that will filter
-      # out an attribute when the block returns false. the ValueObject
-      # needs all the attributes, so we allow every attribute.
-      FILTER_NONE = proc { true }
-
-      def initialize(attributes = {})
-        set_attributes(attributes)
-      end
-
-      def with(attribute_updates)
-        self.class.new(get_attributes(&FILTER_NONE).merge(attribute_updates))
-      end
-
       # ValueObjects are immutable and can't be cloned
       #
       # They always represent the same value
@@ -74,6 +64,22 @@ module Virtus
 
     end
 
+    module AllowedWriterMethods
+      # 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 = super
+            allowed_writer_methods += attribute_set.map{|attr| "#{attr.name}="}
+            allowed_writer_methods.to_set.freeze
+          end
+      end
+    end
+
     module ClassMethods
 
       # Define an attribute on the receiver
@@ -94,10 +100,9 @@ module Virtus
       # @return [self]
       #
       # @api public
-      def attribute(name, *args)
+      def attribute(name, type, options = {})
         equalizer << name
-        options = args.last.kind_of?(Hash) ? args.pop : {}
-        super name, *args << options.merge(:writer => :private)
+        super name, type, options.merge(:writer => :private)
       end
 
       # Define and include a module that provides Value Object semantics
@@ -116,26 +121,14 @@ module Virtus
       def equalizer
         @equalizer ||=
           begin
-            equalizer = Equalizer.new(name || inspect)
+            equalizer = Virtus::Equalizer.new(name || inspect)
             include equalizer
             equalizer
           end
       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 = super
-            allowed_writer_methods += attribute_set.map{|attr| "#{attr.name}="}
-            allowed_writer_methods.to_set.freeze
-          end
-      end
-
     end # module ClassMethods
+
   end # module ValueObject
+
 end # module Virtus