virtus2 2.0.1

data/lib/virtus/attribute/strict.rb

@@ -0,0 +1,26 @@
+module Virtus
+  class Attribute
+
+    # Attribute extension which raises CoercionError when coercion failed
+    #
+    module Strict
+
+      # @see [Attribute#coerce]
+      #
+      # @raises [CoercionError] when coercer failed
+      #
+      # @api public
+      def coerce(*)
+        output = super
+
+        if value_coerced?(output) || !required? && output.nil?
+          output
+        else
+          raise CoercionError.new(output, self)
+        end
+      end
+
+    end # Strict
+
+  end # Attribute
+end # Virtus

data/lib/virtus/attribute.rb

@@ -0,0 +1,245 @@
+module Virtus
+
+  # Attribute objects handle coercion and provide interface to hook into an
+  # attribute set instance that's included into a class or object
+  #
+  # @example
+  #
+  #   # non-strict mode
+  #   attr = Virtus::Attribute.build(Integer)
+  #   attr.coerce('1')
+  #   # => 1
+  #
+  #   # strict mode
+  #   attr = Virtus::Attribute.build(Integer, :strict => true)
+  #   attr.coerce('not really coercible')
+  #   # => Virtus::CoercionError: Failed to coerce "not really coercible" into Integer
+  #
+  class Attribute
+    extend DescendantsTracker, Options, TypeLookup
+
+    include Equalizer.new(inspect) << :type << :options
+
+    accept_options :primitive, :accessor, :default, :lazy, :strict, :required, :finalize, :nullify_blank
+
+    strict false
+    required true
+    accessor :public
+    finalize true
+    nullify_blank false
+
+    # @see Virtus.coerce
+    #
+    # @deprecated
+    #
+    # @api public
+    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
+
+    # Return type of this attribute
+    #
+    # @return [Axiom::Types::Type]
+    #
+    # @api public
+    attr_reader :type
+
+    # @api private
+    attr_reader :primitive, :options, :default_value, :coercer
+
+    # Builds an attribute instance
+    #
+    # @param [Class,Array,Hash,String,Symbol] type
+    #   this can be an explicit class or an object from which virtus can infer
+    #   the type
+    #
+    # @param [#to_hash] options
+    #   optional extra options hash
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def self.build(type, options = {})
+      Builder.call(type, options)
+    end
+
+    # @api private
+    def self.build_coercer(type, options = {})
+      Coercer.new(type, options.fetch(:configured_coercer) { Virtus.coercer })
+    end
+
+    # @api private
+    def self.build_type(definition)
+      Axiom::Types.infer(definition.primitive)
+    end
+
+    # @api private
+    def self.merge_options!(*)
+      # noop
+    end
+
+    # @api private
+    def initialize(type, options)
+      @type          = type
+      @primitive     = type.primitive
+      @options       = options
+      @default_value = options.fetch(:default_value)
+      @coercer       = options.fetch(:coercer)
+    end
+
+    # Coerce the input into the expected type
+    #
+    # @example
+    #
+    #   attr = Virtus::Attribute.build(String)
+    #   attr.coerce(:one) # => 'one'
+    #
+    # @param [Object] input
+    #
+    # @api public
+    def coerce(input)
+      coercer.call(input)
+    end
+
+    # Return a new attribute with the new name
+    #
+    # @param [Symbol] name
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def rename(name)
+      self.class.build(type, options.merge(:name => name))
+    end
+
+    # Return if the given value was coerced
+    #
+    # @param [Object] value
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def value_coerced?(value)
+      coercer.success?(primitive, value)
+    end
+
+    # Return if the attribute is coercible
+    #
+    # @example
+    #
+    #   attr = Virtus::Attribute.build(String, :coerce => true)
+    #   attr.coercible? # => true
+    #
+    #   attr = Virtus::Attribute.build(String, :coerce => false)
+    #   attr.coercible? # => false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def coercible?
+      kind_of?(Coercible)
+    end
+
+    # Return if the attribute has lazy default value evaluation
+    #
+    # @example
+    #
+    #   attr = Virtus::Attribute.build(String, :lazy => true)
+    #   attr.lazy? # => true
+    #
+    #   attr = Virtus::Attribute.build(String, :lazy => false)
+    #   attr.lazy? # => false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def lazy?
+      kind_of?(LazyDefault)
+    end
+
+    # Return if the attribute is in the strict coercion mode
+    #
+    # @example
+    #
+    #   attr = Virtus::Attribute.build(String, :strict => true)
+    #   attr.strict? # => true
+    #
+    #   attr = Virtus::Attribute.build(String, :strict => false)
+    #   attr.strict? # => false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def strict?
+      kind_of?(Strict)
+    end
+
+    # Return if the attribute is in the nullify blank coercion mode
+    #
+    # @example
+    #
+    #   attr = Virtus::Attribute.build(String, :nullify_blank => true)
+    #   attr.nullify_blank? # => true
+    #
+    #   attr = Virtus::Attribute.build(String, :nullify_blank => false)
+    #   attr.nullify_blank? # => false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def nullify_blank?
+      kind_of?(NullifyBlank)
+    end
+
+    # Return if the attribute is accepts nil values as valid coercion output
+    #
+    # @example
+    #
+    #   attr = Virtus::Attribute.build(String, :required => true)
+    #   attr.required? # => true
+    #
+    #   attr = Virtus::Attribute.build(String, :required => false)
+    #   attr.required? # => false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def required?
+      options[:required]
+    end
+
+    # Return if the attribute was already finalized
+    #
+    # @example
+    #
+    #   attr = Virtus::Attribute.build(String, :finalize => true)
+    #   attr.finalized? # => true
+    #
+    #   attr = Virtus::Attribute.build(String, :finalize => false)
+    #   attr.finalized? # => false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def finalized?
+      frozen?
+    end
+
+    # @api private
+    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
+
+    # @api private
+    def finalize
+      freeze
+      self
+    end
+
+  end # class Attribute
+
+end # module Virtus

data/lib/virtus/attribute_set.rb

@@ -0,0 +1,240 @@
+module Virtus
+
+  # A set of Attribute objects
+  class AttributeSet < Module
+    include Enumerable
+
+    # @api private
+    def self.create(descendant)
+      if descendant.respond_to?(:superclass) && descendant.superclass.respond_to?(:attribute_set)
+        parent = descendant.superclass.public_send(:attribute_set)
+      end
+      descendant.instance_variable_set('@attribute_set', AttributeSet.new(parent))
+    end
+
+    # Initialize an AttributeSet
+    #
+    # @param [AttributeSet] parent
+    # @param [Array] attributes
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(parent = nil, attributes = [])
+      @parent     = parent
+      @attributes = attributes.dup
+      @index      = {}
+      reset
+    end
+
+    # Iterate over each attribute in the set
+    #
+    # @example
+    #   attribute_set = AttributeSet.new(attributes, parent)
+    #   attribute_set.each { |attribute| ... }
+    #
+    # @yield [attribute]
+    #
+    # @yieldparam [Attribute] attribute
+    #   each attribute in the set
+    #
+    # @return [self]
+    #
+    # @api public
+    def each
+      return to_enum unless block_given?
+      @index.each { |name, attribute| yield attribute if name.kind_of?(Symbol) }
+      self
+    end
+
+    # Adds the attributes to the set
+    #
+    # @example
+    #   attribute_set.merge(attributes)
+    #
+    # @param [Array<Attribute>] attributes
+    #
+    # @return [self]
+    #
+    # @api public
+    def merge(attributes)
+      attributes.each { |attribute| self << attribute }
+      self
+    end
+
+    # Adds an attribute to the set
+    #
+    # @example
+    #   attribute_set << attribute
+    #
+    # @param [Attribute] attribute
+    #
+    # @return [self]
+    #
+    # @api public
+    def <<(attribute)
+      self[attribute.name] = attribute
+      attribute.define_accessor_methods(self) if attribute.finalized?
+      self
+    end
+
+    # Get an attribute by name
+    #
+    # @example
+    #   attribute_set[:name]  # => Attribute object
+    #
+    # @param [Symbol] name
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def [](name)
+      @index[name]
+    end
+
+    # Set an attribute by name
+    #
+    # @example
+    #   attribute_set[:name] = attribute
+    #
+    # @param [Symbol] name
+    # @param [Attribute] attribute
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def []=(name, attribute)
+      @attributes << attribute
+      update_index(name, attribute)
+    end
+
+    # Reset the index when the parent is updated
+    #
+    # @return [self]
+    #
+    # @api private
+    def reset
+      merge_attributes(@parent) if @parent
+      merge_attributes(@attributes)
+      self
+    end
+
+    # Defines an attribute reader method
+    #
+    # @param [Attribute] attribute
+    # @param [Symbol] method_name
+    # @param [Symbol] visibility
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_reader_method(attribute, method_name, visibility)
+      define_method(method_name) { attribute.get(self) }
+      send(visibility, method_name)
+    end
+
+    # Defines an attribute writer method
+    #
+    # @param [Attribute] attribute
+    # @param [Symbol] method_name
+    # @param [Symbol] visibility
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_writer_method(attribute, method_name, visibility)
+      define_method(method_name) { |value| attribute.set(self, value) }
+      send(visibility, method_name)
+    end
+
+    # Get values of all attributes defined for this class, ignoring privacy
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def get(object)
+      each_with_object({}) do |attribute, attributes|
+        name = attribute.name
+        attributes[name] = object.__send__(name) if attribute.public_reader?
+      end
+    end
+
+    # Mass-assign attribute values
+    #
+    # @see Virtus::InstanceMethods#attributes=
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def set(object, attributes)
+      coerce(attributes).each do |name, value|
+        writer_name = "#{name}="
+        if object.allowed_writer_methods.include?(writer_name)
+          object.__send__(writer_name, value)
+        end
+      end
+    end
+
+    # Set default attributes
+    #
+    # @return [self]
+    #
+    # @api private
+    def set_defaults(object, filter = method(:skip_default?))
+      each do |attribute|
+        next if filter.call(object, attribute)
+        attribute.set_default_value(object)
+      end
+    end
+
+    # Coerce attributes received to a hash
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def coerce(attributes)
+      ::Hash.try_convert(attributes) or raise(
+        NoMethodError, "Expected #{attributes.inspect} to respond to #to_hash"
+      )
+    end
+
+    # @api private
+    def finalize
+      each do |attribute|
+        self << attribute.finalize unless attribute.finalized?
+      end
+    end
+
+    private
+
+    # @api private
+    def skip_default?(object, attribute)
+      attribute.lazy? || attribute.defined?(object)
+    end
+
+    # Merge the attributes into the index
+    #
+    # @param [Array<Attribute>] attributes
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def merge_attributes(attributes)
+      attributes.each { |attribute| update_index(attribute.name, attribute) }
+    end
+
+    # Update the symbol and string indexes with the attribute
+    #
+    # @param [Symbol] name
+    #
+    # @param [Attribute] attribute
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def update_index(name, attribute)
+      @index[name] = @index[name.to_s.freeze] = attribute
+    end
+
+  end # class AttributeSet
+end # module Virtus