motion_virtus 1.0.0.beta0

data/lib/project/attribute/accessor_method.rb

@@ -0,0 +1,73 @@
+module Virtus
+  class Attribute
+
+    # Abstract accessor method class
+    #
+    # @api public
+    #
+    # @abstract
+    class AccessorMethod
+      #include Adamantium::Flat
+
+      #include AbstractType
+
+      #abstract_method :call
+      def call(*)
+        raise NotImplementedError, "#{self.class.inspect}##{name} is not implemented"
+      end
+
+      #abstract_method :define_method
+      def call(*)
+        raise NotImplementedError, "#{self.class.inspect}##{name} is not implemented"
+      end
+
+      
+      # Return name
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      attr_reader :name
+
+      # Return visibility
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      attr_reader :visibility
+
+      # Return instance variable name
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      attr_reader :instance_variable_name
+
+      # Initialize accessor method instance
+      #
+      # @param [#to_sym] name
+      #
+      # @param [Hash] options
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(name, options = {})
+        @name                   = name.to_sym
+        @visibility             = options.fetch(:visibility, :public)
+        @instance_variable_name = "@#{name}".to_sym
+      end
+
+      # Return if the accessor is public
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @api private
+      def public?
+        visibility == :public
+      end
+
+    end # class AccessorMethod
+
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/array.rb

@@ -0,0 +1,24 @@
+motion_require 'collection.rb'
+
+module Virtus
+  class Attribute
+
+    # Array
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :tags, Array
+    #   end
+    #
+    #   post = Post.new(:tags => %w(red green blue))
+    #
+    class Array < Collection
+      primitive       ::Array
+      coercion_method :to_array
+      default         primitive.new
+
+    end # class Array
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/boolean.rb

@@ -0,0 +1,52 @@
+module Virtus
+  class Attribute
+
+    # Boolean attribute allows true or false values to be set
+    # Additionally it adds boolean reader method, like "admin?"
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :published, Boolean
+    #   end
+    #
+    #   post = Post.new(:published => false)
+    #   post.published?  # => false
+    #
+    class Boolean < Object
+      primitive       TrueClass
+      coercion_method :to_boolean
+
+      # Returns if the given value is either true or false
+      #
+      # @example
+      #   boolean = Virtus::Attribute::Boolean.new(:bool)
+      #   boolean.value_coerced?(true)    # => true
+      #   boolean.value_coerced?(false)   # => true
+      #   boolean.value_coerced?(1)       # => false
+      #   boolean.value_coerced?('true')  # => false
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def value_coerced?(value)
+        value.equal?(true) || value.equal?(false)
+      end
+
+      # Creates an attribute reader method as a query
+      #
+      # @param [Module] mod
+      #
+      # @return [self]
+      #
+      # @api private
+      def define_accessor_methods(mod)
+        super
+        mod.define_reader_method(accessor, "#{name}?", reader.visibility)
+        self
+      end
+
+    end # class Boolean
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/class.rb

@@ -0,0 +1,23 @@
+motion_require 'object'
+
+module Virtus
+  class Attribute
+
+    # Class
+    #
+    # @example
+    #   class Entity
+    #     include Virtus
+    #
+    #     attribute :model, Class
+    #   end
+    #
+    #   post = Entity.new(:model => Model)
+    #
+    class Class < Object
+      primitive       ::Class
+      coercion_method :to_constant
+
+    end # class Class
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/coercer.rb

@@ -0,0 +1,43 @@
+module Virtus
+  class Attribute
+
+    # Coercer accessor wrapper
+    #
+    # @api private
+    class Coercer
+
+      # 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)
+      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/project/attribute/collection/coercible_writer.rb

@@ -0,0 +1,83 @@
+module Virtus
+  class Attribute
+    class Collection
+
+      # Coercible writer for collection attributes
+      #
+      class CoercibleWriter < Attribute::Writer::Coercible
+
+        # Return member type
+        #
+        # @return [Class]
+        #
+        # @api private
+        attr_reader :member_type
+
+        # Return writer for collection members
+        #
+        #
+        # @return [Writer::Coercible]
+        #
+        # @api private
+        attr_reader :member_coercer
+
+        # Initialize a new writer instance
+        #
+        # @param [Symbol] name
+        #
+        # @param [::Hash] options
+        #
+        # @api private
+        def initialize(name, options)
+          super
+          @member_type    = options.fetch(:member_type, ::Object)
+          @member_coercer = Attribute.determine_type(@member_type).coercer(@member_type)
+        end
+
+        # Coerce a collection with members
+        #
+        # @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_collection) do |entry, collection|
+            coerce_and_append_member(collection, entry)
+          end
+        end
+
+        private
+
+        # Return an instance of the collection
+        #
+        # @return [Enumerable]
+        #
+        # @api private
+        def new_collection
+          primitive.new
+        end
+
+        # 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_coercer.call(entry)
+        end
+
+      end # class CoercibleWriter
+
+    end # class Collection
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/collection.rb

@@ -0,0 +1,56 @@
+motion_require 'object'
+
+module Virtus
+  class Attribute
+
+    # Abstract superclass for collection Attributes.
+    #
+    # Handles coercing members to the designated member type.
+    #
+    # @abstract
+    class Collection < Object
+
+      # Handles collection with member_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?(:count)
+          merged_options
+        elsif type.count > 1
+          raise NotImplementedError, "build SumType from list of types (#{type.inspect})"
+        else
+          merged_options.merge!(:member_type => type.first)
+        end
+
+        merged_options
+      end
+
+      # @see Virtus::Attribute.coercible_writer_class
+      #
+      # @return [::Class]
+      #
+      # @api private
+      def self.coercible_writer_class(_type, options)
+        options[:member_type] ? CoercibleWriter : super
+      end
+
+      # @see Virtus::Attribute.writer_option_names
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api private
+      def self.writer_option_names
+        super << :member_type
+      end
+
+    end # class Collection
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/date.rb

@@ -0,0 +1,36 @@
+motion_require 'object'
+
+module Virtus
+  class Attribute
+
+    # Date
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :published_on, Date
+    #   end
+    #
+    #   Post.new(:published_on => Date.today)
+    #
+    #   # typecasting from a string
+    #   Post.new(:published_on => '2011/06/09')
+    #
+    #   # typecasting from a hash
+    #   Post.new(:published_on => {
+    #     :year  => 2011,
+    #     :month => 6,
+    #     :day   => 9,
+    #   })
+    #
+    #   # typecasting from an object which implements #to_date
+    #   Post.new(:published_on => DateTime.now)
+    #
+    class Date < Object
+      primitive       ::Date
+      coercion_method :to_date
+
+    end # class Date
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/date_time.rb

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

data/lib/project/attribute/decimal.rb

@@ -0,0 +1,23 @@
+motion_require 'object'
+
+module Virtus
+  class Attribute
+
+    # Decimal
+    #
+    # @example
+    #   class ExchangeRate
+    #     include Virtus
+    #
+    #     attribute :dollar, Decimal
+    #   end
+    #
+    #   ExchangeRate.new(:dollar => '2.6948')
+    #
+    class Decimal < Numeric
+      primitive       ::BigDecimal
+      coercion_method :to_decimal
+
+    end # class Decimal
+  end # class Attribute
+end # module Virtus

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

@@ -0,0 +1,37 @@
+motion_require 'from_clonable'
+
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a callable object
+      #
+      # @api private
+      class FromCallable < DefaultValue
+
+        # Return if the class can handle the value
+        #
+        # @param [Object] value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(value)
+          value.respond_to?(:call)
+        end
+
+        # Evaluates the value via value#call
+        #
+        # @param [Object] args
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def call(*args)
+          @value.call(*args)
+        end
+
+      end # class FromCallable
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

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

@@ -0,0 +1,37 @@
+motion_require '../default_value.rb'
+
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a clonable object
+      #
+      # @api private
+      class FromClonable < DefaultValue
+        SINGLETON_CLASSES = [
+          ::NilClass, ::TrueClass, ::FalseClass, ::Numeric,  ::Symbol ].freeze
+
+        # Return if the class can handle the value
+        #
+        # @param [Object] value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(value)
+          SINGLETON_CLASSES.none? {|c| value.is_a?(c) }
+        end
+
+        # Evaluates the value via value#clone
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def call(*)
+          @value.clone
+        end
+
+      end # class FromClonable
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

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

@@ -0,0 +1,37 @@
+motion_require 'from_callable'
+
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a symbol
+      #
+      # @api private
+      class FromSymbol < DefaultValue
+
+        # Return if the class can handle the value
+        #
+        # @param [Object] value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(value)
+          value.is_a?(::Symbol)
+        end
+
+        # Evaluates the value via instance#public_send(value)
+        #
+        # Symbol value is returned if the instance doesn't respond to value
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def call(instance, *)
+          instance.respond_to?(@value, true) ? instance.send(@value) : @value
+        end
+
+      end # class FromSymbol
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/default_value.rb

@@ -0,0 +1,49 @@
+module Virtus
+  class Attribute
+
+    # Class representing the default value option
+    #
+    # @api private
+    class DefaultValue
+      extend DescendantsTracker
+
+      # Builds a default value instance
+      #
+      # @return [Virtus::Attribute::DefaultValue]
+      #
+      # @api private
+      def self.build(*args)
+        klass = descendants.detect { |descendant| descendant.handle?(*args) } || self
+        klass.new(*args)
+      end
+
+      # Returns the value instance
+      #
+      # @return [Object]
+      #
+      # @api private
+      attr_reader :value
+
+      # Initializes an default value instance
+      #
+      # @param [Object] value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(value)
+        @value = value
+      end
+
+      # Evaluates the value
+      #
+      # @return [Object] evaluated value
+      #
+      # @api private
+      def call(*)
+        value
+      end
+
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/embedded_value/open_struct_coercer.rb

@@ -0,0 +1,43 @@
+motion_require '../embedded_value.rb'
+
+module Virtus
+  class Attribute
+    class EmbeddedValue < Object
+
+      # EmbeddedValue coercer handling OpenStruct primitive or Virtus object
+      #
+      class OpenStructCoercer
+
+        # Return primitive class
+        #
+        # @return [::Class]
+        #
+        # @api private
+        attr_reader :primitive
+
+        # Initialize coercer object
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(primitive)
+          @primitive = primitive
+        end
+
+        # Build object from attribute hash
+        #
+        # @return [::Object]
+        #
+        # @api private
+        def call(attributes)
+          if attributes.kind_of?(primitive)
+            attributes
+          elsif not attributes.nil?
+            primitive.new(attributes)
+          end
+        end
+
+      end # class OpenStructCoercer
+    end # class EmbeddedValue
+  end # class Attribute
+end # module Virtus

data/lib/project/attribute/embedded_value/struct_coercer.rb

@@ -0,0 +1,42 @@
+motion_require '../embedded_value.rb'
+
+module Virtus
+  class Attribute
+    class EmbeddedValue < Object
+
+      # EmbeddedValue coercer handling Struct primitive
+      #
+      class StructCoercer
+        # Return primitive class
+        #
+        # @return [::Class]
+        #
+        # @api private
+        attr_reader :primitive
+
+        # Initialize coercer instance
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(primitive)
+          @primitive = primitive
+        end
+
+        # Build a struct object from attributes
+        #
+        # @return [Struct]
+        #
+        # @api private
+        def call(attributes)
+          if attributes.kind_of?(primitive)
+            attributes
+          elsif not attributes.nil?
+            primitive.new(*attributes)
+          end
+        end
+
+      end # class StructCoercer
+    end # class EmbeddedValue
+  end # class Attribute
+end # module Virtus