virtus 0.0.2 → 0.0.3

data/.gitignore

@@ -2,3 +2,6 @@
 .bundle
 Gemfile.lock
 pkg/*
+measurements/
+tmp/
+profiling/

data/.rvmrc

@@ -1 +1 @@
-rvm --create use 1.9.2@virtus
+rvm use @$(basename `pwd`) --create

data/Gemfile

@@ -1,7 +1,26 @@
 source "http://rubygems.org"
 
+group :virtus do
+  gem 'virtus',    File.read('VERSION'), :path => File.dirname(__FILE__)
+end
+
 group :development do
   gem "jeweler",   "~> 1.5.2"
   gem "rspec",     "~> 2.6.0"
-  gem "simplecov", "~> 0.4.2", :platforms => [ :mri_19 ]
+end
+
+platforms :mri_18 do
+  group :metrics do
+    gem 'flay',      '~> 1.4.2'
+    gem 'flog',      '~> 2.5.1'
+    gem 'heckle',    '~> 1.4.3'
+    gem 'json',      '~> 1.5.1'
+    gem 'metric_fu', '~> 2.1.1'
+    gem 'mspec',     '~> 1.5.17'
+    gem 'rcov',      '~> 0.9.9'
+    gem 'reek',      '~> 1.2.8', :git => 'git://github.com/dkubb/reek.git'
+    gem 'roodi',     '~> 2.1.0'
+    gem 'ruby2ruby', '=  1.2.2'
+    gem 'yardstick', '~> 0.4.0'
+  end
 end

data/History.txt

@@ -0,0 +1,21 @@
+=== v0.0.3 2011-06-09
+
+* [BREAKING CHANGE] Attribute classes were moved to Virtus::Attribute namespace
+* [BREAKING CHANGE] Attribute instance no longer holds the reference to a model
+* [BREAKING CHANGE] #typecast no longer receives an instance of a model (override #set which calls #typecast if you need that)
+* [changed] Adding reader/writer methods was moved from the attribute constructor to Virtus::ClassMethods.attribute
+* [changed] Typecast logic has been moved into separate classes (see Virtus::Typecast)
+* [added] Virtus::Attribute::DateTime#typecast supports objects which implement #to_datetime
+* [general] Internals have been cleaned up, simplified and properly documented
+
+Details: https://github.com/solnic/virtus/compare/v0.0.2...v0.0.3
+
+=== v0.0.2 2011-06-06
+
+* [bugfix] Fixed #typecast in custom attribute classes
+
+Details: https://github.com/solnic/virtus/compare/v0.0.1...v0.0.2
+
+=== v0.0.1 2011-06-04
+
+First public release :)

data/README.markdown

@@ -47,10 +47,10 @@ attributes that require typecasting and/or validations.
 
     module MyApp
       module Attributes
-        class JSON < Virtus::Attributes::Object
+        class JSON < Virtus::Attribute::Object
           primitive Hash
 
-          def typecast(value, model = nil)
+          def typecast(value)
             ::JSON.parse(value)
           end
         end

data/Rakefile

@@ -20,8 +20,7 @@ end
 
 Jeweler::GemcutterTasks.new
 
-desc "Run specs"
-RSpec::Core::RakeTask.new
+FileList['tasks/**/*.rake'].each { |task| import task }
 
 desc 'Default: run specs.'
 task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/config/flay.yml

@@ -0,0 +1,3 @@
+---
+threshold: 19.0
+total_score: 191

data/config/flog.yml

@@ -0,0 +1,2 @@
+---
+threshold: 18.2

data/config/roodi.yml

@@ -0,0 +1,18 @@
+---
+AbcMetricMethodCheck:            { score: 11.8 }
+AssignmentInConditionalCheck:    { }
+CaseMissingElseCheck:            { }
+ClassLineCountCheck:             { line_count: 390 }
+ClassNameCheck:                  { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
+ClassVariableCheck:              { }
+CyclomaticComplexityBlockCheck:  { complexity: 2 }
+CyclomaticComplexityMethodCheck: { complexity: 5 }
+EmptyRescueBodyCheck:            { }
+ForLoopCheck:                    { }
+# TODO: decrease line_count to 5 to 10
+MethodLineCountCheck:            { line_count: 20 }
+MethodNameCheck:                 { pattern: !ruby/regexp /\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|[+*&|-])\z/ }
+ModuleLineCountCheck:            { line_count: 392 }
+ModuleNameCheck:                 { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
+# TODO: decrease parameter_count to 2 or less
+ParameterNumberCheck:            { parameter_count: 3 }

data/config/site.reek

@@ -0,0 +1,91 @@
+---
+UncommunicativeParameterName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+LargeClass:
+  max_methods: 15  # TODO: decrease max_methods to 10-15 or less
+  exclude: []
+  enabled: true
+  max_instance_variables: 5
+UncommunicativeMethodName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^[a-z]$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+LongParameterList:
+  max_params: 3  # TODO: decrease max_params to 2
+  exclude: []
+  enabled: true
+  overrides: {}
+FeatureEnvy:
+  exclude: []
+  enabled: true
+ClassVariable:
+  exclude: []
+  enabled: true
+BooleanParameter:
+  exclude: []
+  enabled: true
+IrresponsibleModule:
+  exclude: []
+  enabled: true
+UncommunicativeModuleName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+NestedIterators:
+  ignore_iterators: []
+  exclude: []
+  enabled: true
+  max_allowed_nesting: 1
+LongMethod:
+  max_statements: 7  # TODO: decrease max_statements to 5 or less
+  exclude: []
+  enabled: true
+Duplication:
+  allow_calls: []
+  exclude: []
+  enabled: true
+  max_calls: 1
+UtilityFunction:
+  max_helper_calls: 1
+  exclude: []
+  enabled: true
+Attribute:
+  exclude: []
+  enabled: false
+UncommunicativeVariableName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+SimulatedPolymorphism:
+  exclude: []
+  enabled: true
+  max_ifs: 1
+DataClump:
+  exclude: []
+  enabled: true
+  max_copies: 1
+  min_clump_size: 2
+ControlCouple:
+  exclude: []
+  enabled: true
+LongYieldList:
+  max_params: 2
+  exclude: []
+  enabled: true

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100.0

data/lib/virtus.rb

@@ -5,57 +5,63 @@ require 'time'
 require 'bigdecimal'
 require 'bigdecimal/util'
 
+# Base module which adds Attribute API to your classes
 module Virtus
+  # Represents an undefined parameter used by auto-generated option methods
   module Undefined; end
 
-  class << self
-    # Extends base class with Attributes and Chainable modules
-    #
-    # @param [Object] base
-    #
-    # @api private
-    def included(base)
-      base.extend(ClassMethods)
-      base.send(:include, InstanceMethods)
-      base.extend(Support::Chainable)
-    end
+  # Extends base class with Attributes and Chainable modules
+  #
+  # @param [Class] base
+  #
+  # @return [Class]
+  #
+  # @api private
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+    base.extend(Support::Chainable)
+  end
 
-    # Returns a Virtus::Attributes::Object sub-class based on a name or class.
-    #
-    # @param [Class,String] class_or_name
-    #   name of a class or a class itself
-    #
-    # @return [Class]
-    #   one of the Virtus::Attributes::Object sub-class
-    #
-    # @api semipublic
-    def determine_type(class_or_name)
-      if class_or_name.is_a?(Class) && class_or_name < Attributes::Object
-        class_or_name
-      elsif Attributes.const_defined?(name = class_or_name.to_s)
-        Attributes.const_get(name)
-      end
+  # Returns a Virtus::Attributes::Object sub-class based on a name or class
+  #
+  # @example
+  #   Virtus.determine_type('String') # => Virtus::Attribute::String
+  #
+  # @param [Class,String] class_or_name
+  #   name of a class or a class itself
+  #
+  # @return [Class]
+  #   one of the Virtus::Attributes::Object sub-class
+  #
+  # @api semipublic
+  def self.determine_type(class_or_name)
+    if class_or_name.is_a?(Class) && class_or_name < Attribute::Object
+      class_or_name
+    elsif Attribute.const_defined?(name = class_or_name.to_s)
+      Attribute.const_get(name)
     end
   end
 end
 
-dir = Pathname(__FILE__).dirname.expand_path
+require 'virtus/support/chainable'
+require 'virtus/class_methods'
+require 'virtus/instance_methods'
+
+require 'virtus/typecast/boolean'
+require 'virtus/typecast/numeric'
+require 'virtus/typecast/time'
 
-require dir + 'virtus/support/chainable'
-require dir + 'virtus/class_methods'
-require dir + 'virtus/instance_methods'
-require dir + 'virtus/attributes/typecast/numeric'
-require dir + 'virtus/attributes/typecast/time'
-require dir + 'virtus/attributes/attribute'
-require dir + 'virtus/attributes/object'
-require dir + 'virtus/attributes/array'
-require dir + 'virtus/attributes/boolean'
-require dir + 'virtus/attributes/date'
-require dir + 'virtus/attributes/date_time'
-require dir + 'virtus/attributes/numeric'
-require dir + 'virtus/attributes/decimal'
-require dir + 'virtus/attributes/float'
-require dir + 'virtus/attributes/hash'
-require dir + 'virtus/attributes/integer'
-require dir + 'virtus/attributes/string'
-require dir + 'virtus/attributes/time'
+require 'virtus/attribute'
+require 'virtus/attribute/object'
+require 'virtus/attribute/array'
+require 'virtus/attribute/boolean'
+require 'virtus/attribute/date'
+require 'virtus/attribute/date_time'
+require 'virtus/attribute/numeric'
+require 'virtus/attribute/decimal'
+require 'virtus/attribute/float'
+require 'virtus/attribute/hash'
+require 'virtus/attribute/integer'
+require 'virtus/attribute/string'
+require 'virtus/attribute/time'

data/lib/virtus/attribute.rb

@@ -0,0 +1,301 @@
+module Virtus
+  # Abstract class implementing base API for attribute types
+  #
+  # @abstract
+  class Attribute
+    # Returns default options hash for a given attribute class
+    #
+    # @example
+    #   Virtus::Attribute::String.options
+    #   # => {:primitive => String, :complex => false}
+    #
+    # @return [Hash]
+    #   a hash of default option values
+    #
+    # @api public
+    def self.options
+      options = {}
+      accepted_options.each do |method|
+        value = send(method)
+        options[method] = value unless value.nil?
+      end
+      options
+    end
+
+    # Returns an array of valid options
+    #
+    # @example
+    #   Virtus::Attribute::String.accepted_options
+    #   # => [:primitive, :complex, :accessor, :reader, :writer]
+    #
+    # @return [Array]
+    #   the array of valid option names
+    #
+    # @api public
+    def self.accepted_options
+      @accepted_options ||= []
+    end
+
+    # Defines which options are valid for a given attribute class
+    #
+    # @example
+    #   class MyAttribute < Virtus::Attribute::Object
+    #     accept_options :foo, :bar
+    #   end
+    #
+    # @return [Array]
+    #   All accepted options
+    #
+    # @api public
+    def self.accept_options(*args)
+      accepted_options.concat(args)
+
+      # create methods for each new option
+      args.each { |option| add_option_method(option) }
+
+      # add new options to all descendants
+      descendants.each { |descendant| descendant.accepted_options.concat(args) }
+
+      accepted_options
+    end
+
+    # Adds a reader/writer method for the give option name
+    #
+    # @return [NilClass]
+    #
+    # @api private
+    def self.add_option_method(option)
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{option}(value = Undefined)          # def self.unique(value = Undefined)
+          return @#{option} if value.equal?(Undefined) #   return @unique if value.equal?(Undefined)
+          @#{option} = value                           #   @unique = value
+        end                                            # end
+      RUBY
+    end
+    private_class_method :add_option_method
+
+    # Returns all the descendant classes
+    #
+    # @example
+    #   Virtus::Attribute::Numeric.descendants
+    #   # => [Virtus::Attribute::Decimal, Virtus::Attribute::Float, Virtus::Attribute::Integer]
+    #
+    # @return [Array]
+    #   the array of descendants
+    #
+    # @api public
+    def self.descendants
+      @descendants ||= []
+    end
+
+    # Adds descendant to descendants array and inherits default options
+    #
+    # @param [Class]
+    #
+    # @return [Class]
+    #
+    # @api private
+    def self.inherited(descendant)
+      descendants << descendant
+      descendant.accepted_options.concat(accepted_options)
+      options.each { |key, value| descendant.send(key, value) }
+      descendant
+    end
+
+    # Returns name of the attribute
+    #
+    # @example
+    #   User.attributes[:age].name # => :age
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    attr_reader :name
+
+    # Returns primitive class of the attribute
+    #
+    # @return [Class]
+    #
+    # @api private
+    attr_reader :primitive
+
+    # Returns options hash for the attribute
+    #
+    # @return [Hash]
+    #
+    # @api private
+    attr_reader :options
+
+    # Returns instance variable name of the attribute
+    #
+    # @return [String]
+    #
+    # @api private
+    attr_reader :instance_variable_name
+
+    # Returns reader visibility
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    attr_reader :reader_visibility
+
+
+    # Returns write visibility
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    attr_reader :writer_visibility
+
+    DEFAULT_ACCESSOR = :public.freeze
+
+    OPTIONS = [ :primitive, :complex, :accessor, :reader, :writer ].freeze
+
+    accept_options *OPTIONS
+
+    # Initializes an attribute instance
+    #
+    # @param [Symbol] name
+    #   the name of an attribute
+    #
+    # @param [Hash] options
+    #   hash of extra options which overrides defaults set on an attribute class
+    #
+    # @api private
+    def initialize(name, options = {})
+      @name    = name
+      @options = self.class.options.merge(options).freeze
+
+      @primitive = @options[:primitive]
+
+      @instance_variable_name = "@#{@name}".freeze
+
+      default_accessor   = @options.fetch(:accessor, DEFAULT_ACCESSOR)
+      @reader_visibility = @options.fetch(:reader, default_accessor)
+      @writer_visibility = @options.fetch(:writer, default_accessor)
+    end
+
+    # Returns if an attribute is a complex one
+    #
+    # @example
+    #   Virtus::Attribute::String.complex? # => false
+    #   Virtus::Attribute::Array.complex? # => true
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    # @api semipublic
+    def complex?
+      options[:complex]
+    end
+
+    # Returns if the given value's class is an attribute's primitive
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    # @api private
+    def primitive?(value)
+      value.kind_of?(primitive)
+    end
+
+    # Converts the given value to the primitive type
+    #
+    # @param [Object] value
+    #   the value
+    #
+    # @return [Object]
+    #   nil, original value or value converted to the primitive type
+    #
+    # @api private
+    def typecast(value)
+      if value.nil? || primitive?(value)
+        value
+      else
+        typecast_to_primitive(value)
+      end
+    end
+
+    # Converts the given value to the primitive type
+    #
+    # @api private
+    def typecast_to_primitive(value)
+      value
+    end
+
+    # Returns value of an attribute for the given instance
+    #
+    # @return [Object]
+    #   value of an attribute
+    #
+    # @api private
+    def get(instance)
+      get!(instance)
+    end
+
+    # Returns the instance variable of the attribute
+    #
+    # @return [Object]
+    #   value of an attribute
+    #
+    # @api private
+    def get!(instance)
+      instance.instance_variable_get(instance_variable_name)
+    end
+
+    # Sets the value on the instance
+    #
+    # @return [Object]
+    #   value of an attribute
+    #
+    # @api private
+    def set(instance, value)
+      set!(instance, typecast(value)) unless value.nil?
+    end
+
+    # Sets instance variable of the attribute
+    #
+    # @return [Object]
+    #   value of an attribute
+    #
+    # @api private
+    def set!(instance, value)
+      instance.instance_variable_set(instance_variable_name, value)
+    end
+
+    # Creates an attribute reader method
+    #
+    # @return [NilClass]
+    #
+    # @api private
+    def add_reader_method(model)
+      model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        chainable(:attribute) do
+          #{reader_visibility}
+
+          def #{name}
+            return #{instance_variable_name} if defined?(#{instance_variable_name})
+            attribute = self.class.attributes[#{name.inspect}]
+            #{instance_variable_name} = attribute ? attribute.get(self) : nil
+          end
+        end
+      RUBY
+    end
+
+    # Creates an attribute writer method
+    #
+    # @return [NilClass]
+    #
+    # @api private
+    def add_writer_method(model)
+      model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        chainable(:attribute) do
+          #{writer_visibility}
+
+          def #{name}=(value)
+            self.class.attributes[#{name.inspect}].set(self, value)
+          end
+        end
+      RUBY
+    end
+  end # Attribute
+end # Virtus