virtus 0.5.5 → 1.0.0.beta3

data/lib/virtus/attribute/default_value/from_callable.rb

@@ -20,7 +20,7 @@ module Virtus
 
         # Evaluates the value via value#call
         #
-        # @param [Object]
+        # @param [Object] args
         #
         # @return [Object] evaluated value
         #

data/lib/virtus/attribute/default_value/from_clonable.rb

@@ -17,12 +17,7 @@ module Virtus
         #
         # @api private
         def self.handle?(value)
-          case value
-          when *SINGLETON_CLASSES
-            false
-          else
-            true
-          end
+          SINGLETON_CLASSES.none? { |klass| value.kind_of?(klass) }
         end
 
         # Evaluates the value via value#clone

data/lib/virtus/attribute/default_value/from_symbol.rb

@@ -15,7 +15,7 @@ module Virtus
         #
         # @api private
         def self.handle?(value)
-          value.is_a?(::Symbol)
+          value.is_a?(Symbol)
         end
 
         # Evaluates the value via instance#public_send(value)
@@ -25,8 +25,8 @@ module Virtus
         # @return [Object] evaluated value
         #
         # @api private
-        def call(instance, *)
-          instance.respond_to?(@value) ? instance.public_send(@value) : @value
+        def call(instance, _)
+          instance.respond_to?(@value, true) ? instance.send(@value) : @value
         end
 
       end # class FromSymbol

data/lib/virtus/attribute/embedded_value.rb

@@ -22,46 +22,55 @@ module Virtus
     #   user = User.new(:address => {
     #     :street => 'Street 1/2', :zipcode => '12345', :city => 'NYC' })
     #
-    class EmbeddedValue < Object
-      primitive ::OpenStruct
+    class EmbeddedValue < Attribute
+      TYPES = [Struct, OpenStruct, Virtus].freeze
+
+      class FromStruct < self
+
+        # @api public
+        def coerce(input)
+          if input.kind_of?(primitive)
+            input
+          elsif not input.nil?
+            primitive.new(*input)
+          end
+        end
+      end # FromStruct
+
+      class FromOpenStruct < self
+
+        # @api public
+        def coerce(input)
+          if input.kind_of?(primitive)
+            input
+          elsif not input.nil?
+            primitive.new(input)
+          end
+        end
+      end # FromOpenStruct
 
-      # @see Attribute.merge_options
-      #
-      # @return [Hash]
-      #   an updated options hash for configuring an EmbeddedValue instance
-      #
       # @api private
-      def self.merge_options(type, options)
-        options.merge(:primitive => type)
+      def self.handles?(klass)
+        klass.is_a?(Class) && TYPES.any? { |type| klass <= type }
       end
 
-      # Determine type based on class
-      #
-      # Virtus::EmbeddedValue.determine_type(Struct) # => Virtus::EmbeddedValue::FromStruct
-      # Virtus::EmbeddedValue.determine_type(VirtusClass) # => Virtus::EmbeddedValue::FromOpenStruct
-      #
-      # @param [Class] klass
-      #
-      # @return [Virtus::Attribute::EmbeddedValue]
-      #
       # @api private
       def self.determine_type(klass)
-        if klass <= Virtus || klass <= OpenStruct
+        if klass < Virtus || klass <= OpenStruct
           FromOpenStruct
-        elsif klass <= Struct
+        elsif klass < Struct
           FromStruct
         end
       end
 
-      # Coerce attributes into a virtus object
-      #
-      # @param [Hash,Virtus]
-      #
-      # @return [Virtus]
-      #
       # @api private
-      def coerce(value)
-        value if value.kind_of?(@primitive)
+      def self.build_type(options)
+        Axiom::Types::Object.new { primitive options[:type] }
+      end
+
+      # @api public
+      def primitive
+        type.primitive
       end
 
     end # class EmbeddedValue

data/lib/virtus/attribute/hash.rb

@@ -12,90 +12,88 @@ module Virtus
     #
     #   Post.new(:meta => { :tags => %w(foo bar) })
     #
-    class Hash < Object
-      primitive       ::Hash
-      coercion_method :to_hash
-      default         primitive.new
-
-      # The type to which keys of this hash will be coerced
-      #
-      # @example
-      #
-      #   class Request
-      #     include Virtus
-      #
-      #     attribute :headers, Hash[Symbol => String]
-      #   end
-      #
-      #   Post.attributes[:headers].key_type # => Virtus::Attribute::Symbol
-      #
-      # @return [Virtus::Attribute]
-      #
-      # @api public
-      attr_reader :key_type
-
-      # The type to which values of this hash will be coerced
-      #
-      # @example
-      #
-      #   class Request
-      #     include Virtus
-      #
-      #     attribute :headers, Hash[Symbol => String]
-      #   end
-      #
-      #   Post.attributes[:headers].value_type # => Virtus::Attribute::String
-      #
-      # @return [Virtus::Attribute]
-      #
-      # @api public
-      attr_reader :value_type
-
-      # Handles hashes with [key_type => value_type] syntax.
-      #
-      # @param [Class]
-      #
-      # @param [Hash]
-      #
-      # @return [Hash]
-      #
-      # @api private
-      def self.merge_options(type, options)
-        if !type.respond_to?(:size)
-          options
-        elsif type.size > 1
-          raise ArgumentError, "more than one [key => value] pair in `#{type.inspect}`"
-        else
-          options.merge(:key_type => type.keys.first, :value_type => type.values.first)
+    class Hash < Attribute
+      primitive ::Hash
+      default   primitive.new
+
+      # FIXME: remove this once axiom-types supports it
+      Type = Struct.new(:key_type, :value_type) do
+        def self.infer(type)
+          if type.is_a?(Class) && type < Axiom::Types::Type
+            new(type.key_type, type.value_type)
+          else
+            type_options = infer_key_and_value_types(type)
+            key_class    = determine_type(type_options.fetch(:key_type,   Object))
+            value_class  = determine_type(type_options.fetch(:value_type, Object))
+
+            new(key_class, value_class)
+          end
+        end
+
+        def self.determine_type(type)
+          if EmbeddedValue.handles?(type)
+            type
+          else
+            Axiom::Types.infer(type)
+          end
+        end
+
+        def self.infer_key_and_value_types(type)
+          return {} unless type.kind_of?(::Hash)
+
+          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 }
+          end
+        end
+
+        def coercion_method
+          :to_hash
+        end
+
+        def primitive
+          ::Hash
         end
       end
 
-      # Initializes an instance of {Virtus::Attribute::Hash}
-      #
       # @api private
-      def initialize(*)
-        super
-        @key_type   = @options[:key_type] || Object
-        @value_type = @options[:value_type] || Object
-        @key_type_instance   = Attribute.build(@name, @key_type)
-        @value_type_instance = Attribute.build(@name, @value_type)
+      def self.build_type(options)
+        Type.infer(options[:type])
       end
 
-      # Coerce a hash with keys and values
-      #
-      # @param [Object]
-      #
-      # @return [Object]
-      #
       # @api private
-      def coerce(value)
+      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
+      end
+
+      # @api public
+      def coerce(*)
         coerced = super
+
         return coerced unless coerced.respond_to?(:each_with_object)
+
         coerced.each_with_object({}) do |(key, value), hash|
-          hash[@key_type_instance.coerce(key)] = @value_type_instance.coerce(value)
+          hash[key_type.coerce(key)] = value_type.coerce(value)
         end
       end
 
+      # @api private
+      def key_type
+        @options[:key_type]
+      end
+
+      # @api private
+      def value_type
+        @options[:value_type]
+      end
+
     end # class Hash
   end # class Attribute
 end # module Virtus

data/lib/virtus/attribute/lazy_default.rb

@@ -0,0 +1,18 @@
+module Virtus
+  class Attribute
+
+    module LazyDefault
+
+      # @api public
+      def get(instance)
+        if instance.instance_variable_defined?(instance_variable_name)
+          super
+        else
+          set_default_value(instance)
+        end
+      end
+
+    end # LazyDefault
+
+  end # Attribute
+end # Virtus

data/lib/virtus/attribute/strict.rb

@@ -0,0 +1,16 @@
+module Virtus
+  class Attribute
+
+    module Strict
+
+      # @api public
+      def coerce(input)
+        coerced = super
+        raise ArgumentError unless coercer.success?(primitive, coerced)
+        coerced
+      end
+
+    end # Strict
+
+  end # Attribute
+end # Virtus

data/lib/virtus/attribute_set.rb

@@ -4,6 +4,14 @@ module Virtus
   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
@@ -13,9 +21,9 @@ module Virtus
     #
     # @api private
     def initialize(parent = nil, attributes = [])
-      @parent       = parent
-      @attributes   = attributes.dup
-      @index        = {}
+      @parent     = parent
+      @attributes = attributes.dup
+      @index      = {}
       reset
     end
 
@@ -67,7 +75,6 @@ module Virtus
     def <<(attribute)
       self[attribute.name] = attribute
       attribute.define_accessor_methods(self)
-      self
     end
 
     # Get an attribute by name
@@ -117,13 +124,12 @@ module Virtus
     # @param [Symbol] method_name
     # @param [Symbol] visibility
     #
-    # @return [self]
+    # @return [undefined]
     #
     # @api private
     def define_reader_method(attribute, method_name, visibility)
       define_method(method_name) { attribute.get(self) }
       send(visibility, method_name)
-      self
     end
 
     # Defines an attribute writer method
@@ -132,16 +138,82 @@ module Virtus
     # @param [Symbol] method_name
     # @param [Symbol] visibility
     #
-    # @return [self]
+    # @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)
-      self
     end
 
-  private
+    # 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|
+        if filter.call(object, attribute)
+          next
+        end
+        set_default(object, attribute)
+      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]
+    #
+    # @api private
+    def coerce(attributes)
+      ::Hash.try_convert(attributes) or raise(
+        NoMethodError, "Expected #{attributes.inspect} to respond to #to_hash"
+      )
+    end
+
+    private
+
+    # @api private
+    def skip_default?(object, attribute)
+      attribute.lazy? || object.instance_variable_defined?(attribute.instance_variable_name)
+    end
 
     # Merge the attributes into the index
     #