virtus 0.0.1

data/lib/virtus/attributes/boolean.rb

@@ -0,0 +1,39 @@
+module Virtus
+  module Attributes
+    class Boolean < Object
+      primitive TrueClass
+
+      TRUE_VALUES  = [ 1, '1', 't', 'T', 'true',  'TRUE'  ].freeze
+      FALSE_VALUES = [ 0, '0', 'f', 'F', 'false', 'FALSE' ].freeze
+      BOOLEAN_MAP  = Hash[
+        TRUE_VALUES.product([ true ]) + FALSE_VALUES.product([ false ]) ].freeze
+
+      def primitive?(value)
+        value == true || value == false
+      end
+
+      def typecast_to_primitive(value, model = nil)
+        BOOLEAN_MAP.fetch(value, value)
+      end
+
+      private
+
+      # Creates standard and boolean attribute reader methods.
+      #
+      # @api private
+      def _create_reader
+        super
+
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          chainable(:attribute) do
+            #{reader_visibility}
+
+            def #{name}?
+              #{name}
+            end
+          end
+        RUBY
+      end
+    end # Boolean
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/date.rb

@@ -0,0 +1,44 @@
+module Virtus
+  module Attributes
+    class Date < Object
+      include Typecast::Time
+
+      primitive ::Date
+
+      # Typecasts an arbitrary value to a Date
+      # Handles both Hashes and Date instances.
+      #
+      # @param [Hash, #to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [Date]
+      #   Date constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value)
+        if value.respond_to?(:to_date)
+          value.to_date
+        elsif value.is_a?(::Hash)
+          typecast_hash_to_date(value)
+        else
+          ::Date.parse(value.to_s)
+        end
+      rescue ArgumentError
+        value
+      end
+
+      # Creates a Date instance from a Hash with keys :year, :month, :day
+      #
+      # @param [Hash, #to_mash] value
+      #   value to be typecast
+      #
+      # @return [Date]
+      #   Date constructed from hash
+      #
+      # @api private
+      def typecast_hash_to_date(value)
+        ::Date.new(*extract_time(value)[0, 3])
+      end
+    end # Date
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/date_time.rb

@@ -0,0 +1,43 @@
+module Virtus
+  module Attributes
+    class DateTime < Object
+      primitive ::DateTime
+
+      include Typecast::Time
+
+      # Typecasts an arbitrary value to a DateTime.
+      # Handles both Hashes and DateTime instances.
+      #
+      # @param [Hash, #to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [DateTime]
+      #   DateTime constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value, model = nil)
+        if value.is_a?(::Hash)
+          typecast_hash_to_datetime(value)
+        else
+          ::DateTime.parse(value.to_s)
+        end
+      rescue ArgumentError
+        value
+      end
+
+      # Creates a DateTime instance from a Hash with keys :year, :month, :day,
+      # :hour, :min, :sec
+      #
+      # @param [Hash, #to_mash] value
+      #   value to be typecast
+      #
+      # @return [DateTime]
+      #   DateTime constructed from hash
+      #
+      # @api private
+      def typecast_hash_to_datetime(value)
+        ::DateTime.new(*extract_time(value))
+      end
+    end # DateTime
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/decimal.rb

@@ -0,0 +1,24 @@
+module Virtus
+  module Attributes
+    class Decimal < Numeric
+      primitive ::BigDecimal
+
+      # Typecast a value to a BigDecimal
+      #
+      # @param [#to_str, #to_d, Integer] value
+      #   value to typecast
+      #
+      # @return [BigDecimal]
+      #   BigDecimal constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value, model = nil)
+        if value.kind_of?(::Integer)
+          value.to_s.to_d
+        else
+          typecast_to_numeric(value, :to_d)
+        end
+      end
+    end # Decimal
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/float.rb

@@ -0,0 +1,20 @@
+module Virtus
+  module Attributes
+    class Float < Numeric
+      primitive ::Float
+
+      # Typecast a value to a Float
+      #
+      # @param [#to_str, #to_f] value
+      #   value to typecast
+      #
+      # @return [Float]
+      #   Float constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value, model = nil)
+        typecast_to_numeric(value, :to_f)
+      end
+    end # Float
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/hash.rb

@@ -0,0 +1,8 @@
+module Virtus
+  module Attributes
+    class Hash < Object
+      primitive ::Hash
+      complex   true
+    end # Integer
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/integer.rb

@@ -0,0 +1,20 @@
+module Virtus
+  module Attributes
+    class Integer < Numeric
+      primitive ::Integer
+
+      # Typecast a value to an Integer
+      #
+      # @param [#to_str, #to_i] value
+      #   value to typecast
+      #
+      # @return [Integer]
+      #   Integer constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value, model = nil)
+        typecast_to_numeric(value, :to_i)
+      end
+    end # Integer
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/numeric.rb

@@ -0,0 +1,9 @@
+module Virtus
+  module Attributes
+    class Numeric < Object
+      include Typecast::Numeric
+
+      accept_options :min, :max
+    end # Numeric
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/object.rb

@@ -0,0 +1,8 @@
+module Virtus
+  module Attributes
+    class Object < Attribute
+      primitive ::Object
+      complex   false
+    end # Object
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/string.rb

@@ -0,0 +1,11 @@
+module Virtus
+  module Attributes
+    class String < Object
+      primitive ::String
+
+      def typecast_to_primitive(value, model = nil)
+        value.to_s
+      end
+    end # String
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/time.rb

@@ -0,0 +1,45 @@
+module Virtus
+  module Attributes
+    class Time < Object
+      include Typecast::Time
+
+      primitive ::Time
+
+      # Typecasts an arbitrary value to a Time
+      # Handles both Hashes and Time instances.
+      #
+      # @param [Hash, #to_mash, #to_s] value
+      #   value to be typecast
+      #
+      # @return [Time]
+      #   Time constructed from value
+      #
+      # @api private
+      def typecast_to_primitive(value, model = nil)
+        if value.respond_to?(:to_time)
+          value.to_time
+        elsif value.is_a?(::Hash)
+          typecast_hash_to_time(value)
+        else
+          ::Time.parse(value.to_s)
+        end
+      rescue ArgumentError
+        value
+      end
+
+      # Creates a Time instance from a Hash with keys :year, :month, :day,
+      # :hour, :min, :sec
+      #
+      # @param [Hash, #to_mash] value
+      #   value to be typecast
+      #
+      # @return [Time]
+      #   Time constructed from hash
+      #
+      # @api private
+      def typecast_hash_to_time(value)
+        ::Time.local(*extract_time(value))
+      end
+    end # Time
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/typecast/numeric.rb

@@ -0,0 +1,32 @@
+module Virtus
+  module Attributes
+    module Typecast
+      module Numeric
+        # Match numeric string
+        #
+        # @param [#to_str, Numeric] value
+        #   value to typecast
+        # @param [Symbol] method
+        #   method to typecast with
+        #
+        # @return [Numeric]
+        #   number if matched, value if no match
+        #
+        # @api private
+        def typecast_to_numeric(value, method)
+          if value.respond_to?(:to_str)
+            if value.to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
+              $1.send(method)
+            else
+              value
+            end
+          elsif value.respond_to?(method)
+            value.send(method)
+          else
+            value
+          end
+        end
+      end # Numeric
+    end # Typecast
+  end # Attributes
+end # Virtus

data/lib/virtus/attributes/typecast/time.rb

@@ -0,0 +1,27 @@
+module Virtus
+  module Attributes
+    module Typecast
+      module Time
+        include Numeric
+
+        # Extracts the given args from the hash. If a value does not exist, it
+        # uses the value of Time.now.
+        #
+        # @param [Hash, #to_mash] value
+        #   value to extract time args from
+        #
+        # @return [Array]
+        #   Extracted values
+        #
+        # @api private
+        def extract_time(value)
+          now  = ::Time.now
+
+          [ :year, :month, :day, :hour, :min, :sec ].map do |segment|
+            typecast_to_numeric(value.fetch(segment, now.send(segment)), :to_i)
+          end
+        end
+      end # Time
+    end # Typecast
+  end # Attributes
+end # Virtus

data/lib/virtus/class_methods.rb

@@ -0,0 +1,60 @@
+module Virtus
+  module ClassMethods
+    # Defines an attribute on an object's class.
+    #
+    # Usage:
+    #
+    #    class Book
+    #      include Virtus
+    #
+    #      attribute :title,        String
+    #      attribute :author,       String
+    #      attribute :published_at, DateTime
+    #      attribute :page_count,   Integer
+    #    end
+    #
+    # @param [Symbol] name
+    #   the name of an attribute
+    #
+    # @param [Class] type
+    #   the type class of an attribute
+    #
+    # @param [Hash] options
+    #   the extra options hash
+    #
+    # @return [Virtus::Attributes::Object]
+    #
+    # @api public
+    def attribute(name, type, options = {})
+      attribute_klass  = Virtus.determine_type(type)
+      attributes[name] = attribute_klass.new(name, self, options)
+    end
+
+    # Returns all the attributes defined on a Class.
+    #
+    # @return [Hash]
+    #   an attributes hash indexed by attribute names
+    #
+    # @api public
+    def attributes
+      @attributes ||= {}
+    end
+
+    private
+
+    # Hooks into const missing process to determine types of attributes.
+    #
+    # It is used when an attribute is defined and a global class like String
+    # or Integer is provided as the type which needs to be mapped to
+    # Virtus::Attributes::String and Virtus::Attributes::Integer.
+    #
+    # @param [String] name
+    #
+    # @return [Class]
+    #
+    # @api private
+    def const_missing(name)
+      Virtus.determine_type(name) || super
+    end
+  end # ClassMethods
+end # Virtus

data/lib/virtus/instance_methods.rb

@@ -0,0 +1,80 @@
+module Virtus
+  module InstanceMethods
+    # Chains Class.new to be able to set attributes during initialization of
+    # an object.
+    #
+    # @param [Hash] attributes
+    #   the attributes hash to be set
+    #
+    # @return [Object]
+    #
+    # @api private
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    # Returns a value of the attribute with the given name
+    #
+    # @param [Symbol] name
+    #   a name of an attribute
+    #
+    # @return [Object]
+    #   a value of an attribute
+    #
+    # @api public
+    def attribute_get(name)
+      __send__(name)
+    end
+
+    # Sets a value of the attribute with the given name
+    #
+    # @param [Symbol] name
+    #   a name of an attribute
+    #
+    # @param [Object] value
+    #   a value to be set
+    #
+    # @return [Object]
+    #   the value set on an object
+    #
+    # @api public
+    def attribute_set(name, value)
+      __send__("#{name}=", value)
+    end
+
+    # Mass-assign of attribute values
+    #
+    # @param [Hash] attributes
+    #   a hash of attribute values to be set on an object
+    #
+    # @return [Hash]
+    #   the attributes
+    #
+    # @api public
+    def attributes=(attributes)
+      attributes.each do |name, value|
+        if self.class.public_method_defined?(writer_name = "#{name}=")
+          __send__(writer_name, value)
+        end
+      end
+    end
+
+    # Returns a hash of all publicly accessible attributes
+    #
+    # @return [Hash]
+    #   the attributes
+    #
+    # @api public
+    def attributes
+      attributes = {}
+
+      self.class.attributes.each do |name, attribute|
+        if self.class.public_method_defined?(name)
+          attributes[name] = __send__(attribute.name)
+        end
+      end
+
+      attributes
+    end
+  end # InstanceMethods
+end # Virtus