motion_virtus 1.0.0.beta0

data/lib/project/attribute/embedded_value.rb

@@ -0,0 +1,69 @@
+motion_require 'object'
+
+module Virtus
+  class Attribute
+
+    # EmbeddedValue
+    #
+    # @example
+    #
+    #   class Address
+    #     include Virtus
+    #
+    #     attribute :street,  String
+    #     attribute :zipcode, String
+    #     attribute :city,    String
+    #   end
+    #
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :address, Address
+    #   end
+    #
+    #   user = User.new(:address => {
+    #     :street => 'Street 1/2', :zipcode => '12345', :city => 'NYC' })
+    #
+    class EmbeddedValue < Object
+      primitive ::OpenStruct
+
+      # @see Attribute.merge_options
+      #
+      # @return [Hash]
+      #   an updated options hash for configuring an EmbeddedValue instance
+      #
+      # @api private
+      def self.merge_options(type, _options)
+        super.update(:primitive => 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 || klass <= Struct
+          self
+        end
+      end
+
+      # @api private
+      def self.coercer(type, _options = {})
+        if type <= Virtus || type <= OpenStruct
+          OpenStructCoercer.new(type)
+        elsif type <= Struct
+          StructCoercer.new(type)
+        else
+          super
+        end
+      end
+
+    end # class EmbeddedValue
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/float.rb

@@ -0,0 +1,30 @@
+module Virtus
+  class Attribute
+
+    # Float
+    #
+    # @example
+    #   class ExchangeRate
+    #     include Virtus
+    #
+    #     attribute :dollar, Float
+    #   end
+    #
+    #   ExchangeRate.new(:dollar => 2.69)
+    #
+    #   # typecasting from a string
+    #   ExchangeRate.new(:dollar => '2.69')
+    #
+    #   # typecasting from an integer
+    #   ExchangeRate.new(:dollar => 2)
+    #
+    #   # typecasting from an object which implements #to_f
+    #   ExchangeRate.new(:dollar => BigDecimal.new('2.69')
+    #
+    class Float < Numeric
+      primitive       ::Float
+      coercion_method :to_float
+
+    end # class Float
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/hash/coercible_writer.rb

@@ -0,0 +1,78 @@
+motion_require '../hash.rb'
+
+module Virtus
+  class Attribute
+    class Hash
+
+      # Coercible writer for Hash attributes
+      #
+      class CoercibleWriter < Attribute::Writer::Coercible
+
+        # The type to which keys of this hash will be coerced
+        #
+        # @return [Virtus::Attribute]
+        #
+        # @api private
+        attr_reader :key_type
+
+        # The type to which values of this hash will be coerced
+        #
+        # @return [Virtus::Attribute]
+        #
+        # @api private
+        attr_reader :value_type
+
+        # Return writer for hash keys
+        #
+        # @return [Writer::Coercible]
+        #
+        # @api private
+        attr_reader :key_coercer
+
+        # Return writer for hash values
+        #
+        # @return [Writer::Coercible]
+        #
+        # @api private
+        attr_reader :value_coercer
+
+        # @api private
+        def initialize(name, options)
+          super
+          @key_type      = options.fetch(:key_type,   ::Object)
+          @value_type    = options.fetch(:value_type, ::Object)
+          @key_coercer   = Attribute.determine_type(@key_type).coercer(@key_type)
+          @value_coercer = Attribute.determine_type(@value_type).coercer(@value_type)
+        end
+
+        # Coerce a hash with keys and values
+        #
+        # @param [Object] value
+        #
+        # @return [Object]
+        #
+        # @api private
+        def coerce(_value)
+          coerced = super
+          return coerced unless coerced.respond_to?(:each_with_object)
+          coerced.each_with_object(new_hash) do |(key, value), hash|
+            hash[key_coercer.call(key)] = value_coercer.call(value)
+          end
+        end
+
+        private
+
+        # Return an instance of the hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def new_hash
+          primitive.new
+        end
+
+      end # class CoercibleWriter
+
+    end # class Collection
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/hash.rb

@@ -0,0 +1,66 @@
+motion_require 'object'
+
+module Virtus
+  class Attribute
+
+    # Hash
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :meta, Hash
+    #   end
+    #
+    #   Post.new(:meta => { :tags => %w(foo bar) })
+    #
+    class Hash < Object
+      primitive       ::Hash
+      coercion_method :to_hash
+      default         primitive.new
+
+      # Handles hashes with [key_type => value_type] syntax
+      #
+      # @param [Class] type
+      #
+      # @param [Hash] options
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def self.merge_options(type, _options)
+        merged_options = super
+
+        if !type.respond_to?(:size)
+          merged_options
+        elsif type.size > 1
+          raise ArgumentError, "more than one [key => value] pair in `#{type.inspect}`"
+        else
+          key_type, value_type = type.first
+          merged_options.merge!(:key_type => key_type, :value_type => value_type)
+        end
+
+        merged_options
+      end
+
+      # @see Virtus::Attribute.coercible_writer_class
+      #
+      # @return [::Class]
+      #
+      # @api private
+      def self.coercible_writer_class(_type, options)
+        options[:key_type] && options[:value_type] ? CoercibleWriter : super
+      end
+
+      # @see Virtus::Attribute.writer_option_names
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api private
+      def self.writer_option_names
+        super << :key_type << :value_type
+      end
+
+    end # class Hash
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/integer.rb

@@ -0,0 +1,27 @@
+module Virtus
+  class Attribute
+
+    # Integer
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :read_count, Integer
+    #   end
+    #
+    #   Post.new(:read_count => 100)
+    #
+    #   # typecasting from a string
+    #   Post.new(:read_count => '100')
+    #
+    #   # typecasting from an object that implements #to_i
+    #   Post.new(:read_count => 100.0)
+    #
+    class Integer < Numeric
+      primitive       ::Integer
+      coercion_method :to_integer
+
+    end # class Integer
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/numeric.rb

@@ -0,0 +1,25 @@
+motion_require 'object'
+
+module Virtus
+  class Attribute
+
+    # Base class for all numerical attributes
+    class Numeric < Object
+      primitive      ::Numeric
+      #accept_options :min, :max
+
+      def self.min(value=Undefined)
+        return @min if value.equal?(Undefined)
+        @min = value
+        self
+      end
+
+      def self.max(value=Undefined)
+        return @max if value.equal?(Undefined)
+        @max = value
+        self
+      end
+
+    end # class Numeric
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/object.rb

@@ -0,0 +1,13 @@
+motion_require '../attribute.rb'
+
+module Virtus
+  class Attribute
+
+    # Base class for every attribute
+    class Object < Attribute
+      primitive       ::Object
+      coercion_method :to_object
+
+    end # class Object
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/reader.rb

@@ -0,0 +1,39 @@
+motion_require 'accessor_method'
+
+module Virtus
+  class Attribute
+
+    # Reader method object
+    #
+    # @api public
+    class Reader < AccessorMethod
+
+      # Returns value of an attribute for the given instance
+      #
+      # @example
+      #   attribute.get(instance)  # => value
+      #
+      # @return [Object]
+      #   value of an attribute
+      #
+      # @api public
+      def call(instance)
+        instance.instance_variable_get(instance_variable_name)
+      end
+
+      # Creates an attribute reader method
+      #
+      # @param [Module] mod
+      #
+      # @return [self]
+      #
+      # @api private
+      def define_method(accessor, mod)
+        mod.define_reader_method(accessor, name, visibility)
+        self
+      end
+
+    end # class Reader
+
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/set.rb

@@ -0,0 +1,22 @@
+module Virtus
+  class Attribute
+
+    # Set
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :tags, Set
+    #   end
+    #
+    #   post = Post.new(:tags => %w(red green blue))
+    #
+    class Set < Collection
+      primitive       ::Set
+      coercion_method :to_set
+      default         primitive.new
+
+    end # class Set
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/string.rb

@@ -0,0 +1,24 @@
+module Virtus
+  class Attribute
+
+    # String
+    #
+    # @example
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :name, String
+    #   end
+    #
+    #   User.new(:name => 'John')
+    #
+    #   # typecasting from an object which implements #to_s
+    #   User.new(:name => :John)
+    #
+    class String < Object
+      primitive       ::String
+      coercion_method :to_string
+
+    end # class String
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/symbol.rb

@@ -0,0 +1,23 @@
+motion_require 'object'
+
+module Virtus
+  class Attribute
+
+    # Symbol
+    #
+    # @example
+    #   class Product
+    #     include Virtus
+    #
+    #     attribute :code, Symbol
+    #   end
+    #
+    #   product = Product.new(:code => :red)
+    #
+    class Symbol < Object
+      primitive       ::Symbol
+      coercion_method :to_symbol
+
+    end # class Symbol
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/time.rb

@@ -0,0 +1,36 @@
+module Virtus
+  class Attribute
+
+    # Time
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :published_at, Time
+    #   end
+    #
+    #   Post.new(:published_at => Time.now)
+    #
+    #   # typecasting from a string
+    #   Post.new(:published_at => '2011/06/09 11:08')
+    #
+    #   # typecasting from a hash
+    #   Post.new(:published_at => {
+    #     :year  => 2011,
+    #     :month => 6,
+    #     :day   => 9,
+    #     :hour  => 11,
+    #     :min   => 8,
+    #   })
+    #
+    #   # typecasting from an object which implements #to_time
+    #   Post.new(:published_at => DateTime.now)
+    #
+    class Time < Object
+      primitive       ::Time
+      coercion_method :to_time
+
+    end # class Time
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/writer/coercible.rb

@@ -0,0 +1,45 @@
+module Virtus
+  class Attribute
+    class Writer < AccessorMethod
+
+      class Coercible < self
+
+        # Return coercer object used by this writer
+        #
+        # @return [Object]
+        #
+        # @api private
+        attr_reader :coercer
+
+        # @api private
+        def initialize(name, options = {})
+          super
+          @coercer = options.fetch(:coercer)
+        end
+
+        # @api private
+        def call(instance, value)
+          super(instance, coerce(value))
+        end
+
+        # Converts the given value to the primitive type
+        #
+        # @example
+        #   attribute.coerce(value)  # => primitive_value
+        #
+        # @param [Object] value
+        #   the value
+        #
+        # @return [Object]
+        #   nil, original value or value converted to the primitive type
+        #
+        # @api public
+        def coerce(value)
+          coercer.call(value)
+        end
+
+      end # class Coercible
+
+    end # class Writer
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/writer.rb

@@ -0,0 +1,73 @@
+motion_require 'accessor_method'
+
+module Virtus
+  class Attribute
+
+    # Writer method object
+    #
+    # @api public
+    class Writer < AccessorMethod
+
+      # Return primitive
+      #
+      # @return [Class]
+      #
+      # @api private
+      attr_reader :primitive
+
+      # Return default value instance
+      #
+      # @return [DefaultValue]
+      #
+      # @api private
+      attr_reader :default_value
+
+      # Initialize a writer instance
+      #
+      # @param [#to_sym] name
+      #
+      # @param [Hash] options
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(name, options = {})
+        super
+        @name          = "#{name}=".to_sym
+        @primitive     = options.fetch(:primitive, ::Object)
+        @default_value = DefaultValue.build(options[:default])
+      end
+
+      # Sets instance variable of the attribute
+      #
+      # @example
+      #   attribute.set!(instance, value)  # => value
+      #
+      # @return [self]
+      #
+      # @api public
+      def call(instance, value)
+        instance.instance_variable_set(instance_variable_name, value)
+      end
+
+      # @api private
+      def set_default_value(instance, attribute)
+        call(instance, default_value.call(instance, attribute))
+      end
+
+      # Creates an attribute writer method
+      #
+      # @param [Module] mod
+      #
+      # @return [self]
+      #
+      # @api private
+      def define_method(accessor, mod)
+        mod.define_writer_method(accessor, name, visibility)
+        self
+      end
+
+    end # class Writer
+
+  end # class Attribute
+end # module Virtus