virtus2 2.0.1

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

data/lib/virtus/builder.rb

@@ -0,0 +1,133 @@
+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.new(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 << ValueObject::AllowedWriterMethods << ValueObject::InstanceMethods
+    end
+
+    # @api private
+    def options
+      super.merge(:writer => :private)
+    end
+
+  end # ValueObjectBuilder
+
+end # module Virtus

data/lib/virtus/class_inclusions.rb

@@ -0,0 +1,48 @@
+module Virtus
+
+  # Class-level extensions
+  module ClassInclusions
+
+    # Extends a descendant with class and instance methods
+    #
+    # @param [Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.included(descendant)
+      super
+      descendant.extend(ClassMethods)
+      descendant.class_eval { include Methods }
+      descendant.class_eval { include InstanceMethods }
+      descendant.class_eval { include InstanceMethods::Constructor }
+      descendant.class_eval { include InstanceMethods::MassAssignment }
+    end
+    private_class_method :included
+
+    module Methods
+
+      # Return a list of allowed writer method names
+      #
+      # @return [Set]
+      #
+      # @api private
+      def allowed_writer_methods
+        self.class.allowed_writer_methods
+      end
+
+      private
+
+      # Return class' attribute set
+      #
+      # @return [Virtus::AttributeSet]
+      #
+      # @api private
+      def attribute_set
+        self.class.attribute_set
+      end
+
+    end # Methods
+
+  end # module ClassInclusions
+end # module Virtus

data/lib/virtus/class_methods.rb

@@ -0,0 +1,90 @@
+module Virtus
+
+  # Class methods that are added when you include Virtus
+  module ClassMethods
+    include Extensions::Methods
+    include ConstMissingExtensions
+
+    # Hook called when module is extended
+    #
+    # @param [Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.extended(descendant)
+      super
+      descendant.send(:include, AttributeSet.create(descendant))
+    end
+    private_class_method :extended
+
+    # Returns all the attributes defined on a Class
+    #
+    # @example
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :name, String
+    #     attribute :age,  Integer
+    #   end
+    #
+    #   User.attribute_set  # =>
+    #
+    #   TODO: implement inspect so the output is not cluttered - solnic
+    #
+    # @return [AttributeSet]
+    #
+    # @api public
+    def attribute_set
+      @attribute_set
+    end
+
+    # @see Virtus::ClassMethods.attribute_set
+    #
+    # @deprecated
+    #
+    # @api public
+    def attributes
+      warn "#{self}.attributes is deprecated. Use #{self}.attribute_set instead: #{caller.first}"
+      attribute_set
+    end
+
+    private
+
+    # Setup descendants' own Attribute-accessor-method-hosting modules
+    #
+    # Descendants inherit Attribute accessor methods via Ruby's inheritance
+    # mechanism: Attribute accessor methods are defined in a module included
+    # in a superclass. Attributes defined on descendants add methods to the
+    # descendant's Attributes accessor module, leaving the superclass's method
+    # table unaffected.
+    #
+    # @param [Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def inherited(descendant)
+      super
+      AttributeSet.create(descendant)
+      descendant.module_eval { include attribute_set }
+    end
+
+    # The list of allowed public methods
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    def allowed_methods
+      public_instance_methods.map(&:to_s)
+    end
+
+    # @api private
+    def assert_valid_name(name)
+      if instance_methods.include?(:attributes) && name.to_sym == :attributes
+        raise ArgumentError, "#{name.inspect} is not allowed as an attribute name"
+      end
+    end
+
+  end # module ClassMethods
+end # module Virtus

data/lib/virtus/coercer.rb

@@ -0,0 +1,41 @@
+module Virtus
+
+  # Abstract coercer class
+  #
+  class Coercer
+    include Equalizer.new(inspect) << :primitive << :type
+
+    # @api private
+    attr_reader :primitive, :type
+
+    # @api private
+    def initialize(type)
+      @type      = type
+      @primitive = type.primitive
+    end
+
+    # Coerce input value into expected primitive type
+    #
+    # @param [Object] input
+    #
+    # @return [Object] coerced input
+    #
+    # @api public
+    def call(input)
+      NotImplementedError.new("#{self.class}#call must be implemented")
+    end
+
+    # Return if the input value was successfuly coerced
+    #
+    # @param [Object] input
+    #
+    # @return [Object] coerced input
+    #
+    # @api public
+    def success?(primitive, input)
+      input.kind_of?(primitive)
+    end
+
+  end # Coercer
+
+end # Virtus

data/lib/virtus/configuration.rb

@@ -0,0 +1,72 @@
+module Virtus
+
+  # A Configuration instance
+  class Configuration
+
+    # Access the finalize setting for this instance
+    attr_accessor :finalize
+
+    # Access the coerce setting for this instance
+    attr_accessor :coerce
+
+    # Access the strict setting for this instance
+    attr_accessor :strict
+
+    # Access the nullify_blank setting for this instance
+    attr_accessor :nullify_blank
+
+    # Access the required setting for this instance
+    attr_accessor :required
+
+    # Access the constructor setting for this instance
+    attr_accessor :constructor
+
+    # Access the mass-assignment setting for this instance
+    attr_accessor :mass_assignment
+
+    # Initialized a configuration instance
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(options={})
+      @finalize        = options.fetch(:finalize, true)
+      @coerce          = options.fetch(:coerce, true)
+      @strict          = options.fetch(:strict, false)
+      @nullify_blank   = options.fetch(:nullify_blank, false)
+      @required        = options.fetch(:required, true)
+      @constructor     = options.fetch(:constructor, true)
+      @mass_assignment = options.fetch(:mass_assignment, true)
+      @coercer         = Coercible::Coercer.new
+
+      yield self if block_given?
+    end
+
+    # Access the coercer for this instance and optional configure a
+    # new coercer with the passed block
+    #
+    # @example
+    #   configuration.coercer do |config|
+    #     config.string.boolean_map = { true => '1', false => '0' }
+    #   end
+    #
+    # @return [Coercer]
+    #
+    # @api private
+    def coercer(&block)
+      @coercer = Coercible::Coercer.new(&block) if block_given?
+      @coercer
+    end
+
+    # @api private
+    def to_h
+      { :coerce             => coerce,
+        :finalize           => finalize,
+        :strict             => strict,
+        :nullify_blank      => nullify_blank,
+        :required           => required,
+        :configured_coercer => coercer }.freeze
+    end
+
+  end # class Configuration
+end # module Virtus

data/lib/virtus/const_missing_extensions.rb

@@ -0,0 +1,18 @@
+module Virtus
+  module ConstMissingExtensions
+
+    # Hooks into const missing process to determine types of attributes
+    #
+    # @param [String] name
+    #
+    # @return [Class]
+    #
+    # @api private
+    def const_missing(name)
+      Attribute::Builder.determine_type(name) or
+        Axiom::Types.const_defined?(name) && Axiom::Types.const_get(name) or
+        super
+    end
+
+  end
+end