virtus 0.5.5 → 1.0.0.beta3

data/lib/virtus/attribute/accessor.rb

@@ -0,0 +1,91 @@
+module Virtus
+  class Attribute
+
+    # Accessor extension provides methods to read and write attributes
+    #
+    # @example
+    #
+    #   attribute = Virtus::Attribute.build(String, :name => :email)
+    #   model     = Class.new { attr_reader :email }
+    #   object    = model.new
+    #
+    #   attribute.set(object, 'jane@doe.com')
+    #   attribute.get(object) # => 'jane@doe.com'
+    #
+    module Accessor
+
+      # Return name of this accessor attribute
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      attr_reader :name
+
+      # Return instance_variable_name used by this accessor
+      #
+      # @api private
+      attr_reader :instance_variable_name
+
+      # Return value of the attribute
+      #
+      # @param [Object] instance
+      #
+      # @return [Object]
+      #
+      # @api public
+      def get(instance)
+        instance.instance_variable_get(instance_variable_name)
+      end
+
+      # Set value of the attribute
+      #
+      # @param [Object] instance
+      # @param [Object] value
+      #
+      # @return [Object] value that was set
+      #
+      # @api public
+      def set(instance, value)
+        instance.instance_variable_set(instance_variable_name, value)
+      end
+
+      # Set default value
+      #
+      # @param [Object] instance
+      #
+      # @return [Object] value that was set
+      #
+      # @api public
+      def set_default_value(instance)
+        set(instance, default_value.call(instance, self))
+      end
+
+      # Returns a Boolean indicating whether the reader method is public
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def public_reader?
+        options[:reader] == :public
+      end
+
+      # Returns a Boolean indicating whether the writer method is public
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def public_writer?
+        options[:writer] == :public
+      end
+
+      # @api private
+      def finalize
+        @name                   = options.fetch(:name).to_sym
+        @instance_variable_name = "@#{@name}"
+        super
+      end
+
+    end # Accessor
+
+  end # Attribute
+end # Virtus

data/lib/virtus/attribute/boolean.rb

@@ -14,9 +14,13 @@ module Virtus
     #   post = Post.new(:published => false)
     #   post.published?  # => false
     #
-    class Boolean < Object
-      primitive       TrueClass
-      coercion_method :to_boolean
+    class Boolean < Attribute
+      primitive TrueClass
+
+      # @api private
+      def self.build_type(*)
+        Axiom::Types::Boolean
+      end
 
       # Returns if the given value is either true or false
       #
@@ -31,20 +35,19 @@ module Virtus
       #
       # @api public
       def value_coerced?(value)
-        value.equal?(true) or value.equal?(false)
+        value.equal?(true) || value.equal?(false)
       end
 
       # Creates an attribute reader method as a query
       #
       # @param [Module] mod
       #
-      # @return [self]
+      # @return [undefined]
       #
       # @api private
-      def define_reader_method(mod)
+      def define_accessor_methods(attribute_set)
         super
-        mod.define_reader_method(self, "#{name}?", @reader_visibility)
-        self
+        attribute_set.define_reader_method(self, "#{name}?", options[:reader])
       end
 
     end # class Boolean

data/lib/virtus/attribute/builder.rb

@@ -0,0 +1,120 @@
+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)
+    #
+    # @private
+    class Builder
+      attr_reader :attribute
+
+      # @api private
+      def self.call(*args)
+        new(*args).attribute
+      end
+
+      # @api private
+      def self.determine_type(klass, default = nil)
+        type = Attribute.determine_type(klass)
+
+        if klass.is_a?(Class)
+          type ||=
+            if klass < Axiom::Types::Type
+              determine_type(klass.primitive)
+            elsif EmbeddedValue.handles?(klass)
+              EmbeddedValue.determine_type(klass)
+            elsif klass < Enumerable
+              Collection
+            end
+        end
+
+        type || default
+      end
+
+      # @api private
+      def initialize(type, options)
+        initialize_primitive(type)
+        initialize_class
+        initialize_type(:type => type, :primitive => @primitive)
+        initialize_options(options)
+        initialize_default_value
+        initialize_coercer
+        initialize_attribute
+      end
+
+      private
+
+      # @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
+      end
+
+      # @api private
+      def initialize_default_value
+        @options.update(:default_value => DefaultValue.build(@options[:default]))
+      end
+
+      # @api private
+      def initialize_coercer
+        @options.update(:coercer => @options.fetch(:coercer) { build_coercer })
+      end
+
+      # @api private
+      def initialize_primitive(type)
+        @primitive =
+          if type.instance_of?(String) || type.instance_of?(Symbol)
+            begin
+              Object.const_get(type)
+            rescue
+              type
+            end
+          elsif not type.is_a?(Class)
+            type.class
+          else
+            type
+          end
+      end
+
+      # @api private
+      def initialize_class
+        @klass = self.class.determine_type(@primitive, Attribute)
+      end
+
+      # @api private
+      def initialize_type(options)
+        @type = @klass.build_type(options)
+      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)
+      end
+
+      # @api private
+      def build_coercer
+        Coercer.new(
+          @options.fetch(:configured_coercer) { Virtus.coercer },
+          @type.coercion_method
+        )
+      end
+
+    end # class Builder
+
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/coercer.rb

@@ -0,0 +1,51 @@
+module Virtus
+  class Attribute
+
+    # Coercer accessor wrapper
+    #
+    # @api private
+    class Coercer
+      attr_reader :method
+
+      # Initialize a new coercer object
+      #
+      # @param [Object] coercers accessor
+      # @param [Symbol] coercion method
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(coercers, method)
+        @coercers = coercers
+        @method   = method
+      end
+
+      # Coerce given value
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call(value)
+        self[value.class].public_send(@method, value)
+      rescue ::Coercible::UnsupportedCoercion
+        value
+      end
+
+      # @api public
+      def success?(primitive, value)
+        self[primitive].coerced?(value)
+      end
+
+      # Return coercer object for the given type
+      #
+      # @return [Object]
+      #
+      # @api private
+      def [](type)
+        @coercers[type]
+      end
+
+    end # class Coercer
+
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/coercible.rb

@@ -0,0 +1,14 @@
+module Virtus
+  class Attribute
+
+    module Coercible
+
+      # @api public
+      def set(instance, value)
+        super(instance, coerce(value))
+      end
+
+    end # Coercible
+
+  end # Attribute
+end # Virtus

data/lib/virtus/attribute/collection.rb

@@ -6,111 +6,65 @@ module Virtus
     # Handles coercing members to the designated member type.
     #
     # @abstract
-    class Collection < Object
+    class Collection < Attribute
+      default Proc.new { |_, attribute| attribute.type.primitive.new }
 
-      # The type to which members of this collection will be coerced
-      #
-      # @example
-      #
-      #   class Post
-      #     include Virtus
-      #
-      #     attribute :tags, Array[String]
-      #   end
-      #
-      #   Post.attributes[:tags].member_type # => Virtus::Attribute::String
-      #
-      # @return [Virtus::Attribute]
-      #
-      # @api public
-      attr_reader :member_type
+      # FIXME: temporary hack, remove when Axiom::Type works with EV as member_type
+      Type = Struct.new(:primitive, :member_type) do
+        def self.infer(type, primitive)
+          return type if type.is_a?(Class) && type < Axiom::Types::Type
 
-      # Handles collection with member_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 NotImplementedError, "build SumType from list of types (#{type.inspect})"
-        else
-          options.merge(:member_type => type.first)
+          klass  = Axiom::Types.infer(type)
+          member = infer_member_type(type) || Object
+
+          if EmbeddedValue.handles?(member)
+            Type.new(primitive, member)
+          else
+            klass.new {
+              primitive primitive
+              member_type Axiom::Types.infer(member)
+            }
+          end
         end
-      end
 
-      # Init an instance of Virtus::Attribute::Collection
-      #
-      # @api private
-      def initialize(*)
-        super
-        @member_type = @options.fetch(:member_type, Virtus::Attribute::Object)
-        @member_type_instance = Attribute.build(@name, @member_type)
-      end
+        def self.infer_member_type(type)
+          return unless type.respond_to?(:count)
 
-      # Coerce a collection with members
-      #
-      # @param [Object]
-      #
-      # @return [Object]
-      #
-      # @api private
-      def coerce(value)
-        coerced = super
-        return coerced unless coerced.respond_to?(:inject)
-        coerced.inject(new_collection) do |*args|
-          coerce_and_append_member(*args)
+          if type.count > 1
+            raise NotImplementedError, "build SumType from list of types (#{type})"
+          else
+            type.first
+          end
+        end
+
+        def coercion_method
+          :to_array
         end
       end
 
-      # Return an instance of the collection
-      #
-      # @return [Enumerable]
-      #
       # @api private
-      def new_collection
-        self.class.primitive.new
+      def self.build_type(options)
+        Type.infer(options.fetch(:type), options.fetch(:primitive))
       end
 
-      # Coerce entry and add it to the collection
-      #
-      # @abstract
-      #
-      # @raise NotImplementedError
-      #
-      # @return [undefined]
-      #
       # @api private
-      def coerce_and_append_member(collection, entry)
-        raise NotImplementedError,
-          "#{self.class}#coerce_and_append_member has not been implemented"
+      def self.merge_options!(type, options)
+        unless options.key?(:member_type)
+          options[:member_type] = Attribute.build(type.member_type)
+        end
       end
 
-      # Default coercion method for collection members used by Array and Set
-      module MemberCoercion
-
-        # Coerce a member of a source collection and append it to the target collection
-        #
-        # @param [Array, Set] collection
-        #   target collection to which the coerced member should be appended
-        #
-        # @param [Object] entry
-        #   the member that should be coerced and appended
-        #
-        # @return [Array, Set]
-        #   collection with the coerced member appended to it
-        #
-        # @api private
-        def coerce_and_append_member(collection, entry)
-          collection << @member_type_instance.coerce(entry)
+      # @api public
+      def coerce(*)
+        super.each_with_object(primitive.new) do |entry, collection|
+          collection << member_type.coerce(entry)
         end
-      end # module MemberCoercion
+      end
+
+      def member_type
+        @options[:member_type]
+      end
 
-    end # class Array
+    end # class Collection
   end # class Attribute
 end # module Virtus