virtus 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use 1.9.2@virtus

data/.travis.yml

@@ -0,0 +1,6 @@
+script: "bundle exec rspec spec/"
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - jruby
+  - rbx

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "jeweler",   "~> 1.5.2"
+  gem "rspec",     "~> 2.6.0"
+  gem "simplecov", "~> 0.4.2", :platforms => [ :mri_19 ]
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Piotr Solnica
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,83 @@
+# Virtus [![Build Status](http://travis-ci.org/solnic/virtus.png)](http://travis-ci.org/solnic/virtus)
+
+This is a partial extraction of the DataMapper [Property
+API](http://rubydoc.info/github/datamapper/dm-core/master/DataMapper/Property)
+with various modifications. My goal is to provide a common API to define
+attributes on a model along with (auto-)validations so all ORMs/ODMs could use
+it instead of reinventing the wheel all over again. It would be also suitable
+for any other usecase where you need to extend your ruby objects with various
+attributes that require typecasting and/or validations.
+
+## Installation
+
+    gem i virtus
+
+## Basic Usage
+
+    require 'virtus'
+
+    class User
+      include Virtus
+
+      attribute :name,     String
+      attribute :age,      Integer
+      attribute :birthday, DateTime
+    end
+
+    # setting attributes in the constructor
+    user = User.new(:age => 28)
+
+    # attribute readers
+    user.name # => "Piotr"
+
+    # hash of attributes
+    user.attributes # => { :name => "Piotr" }
+
+    # automatic typecasting
+    user.age = '28'
+    user.age # => 28
+
+    user.birthday = 'November 18th, 1983'
+    user.birthday # => #<DateTime: 1983-11-18T00:00:00+00:00 (4891313/2,0/1,2299161)>
+
+## Custom Attributes
+
+    require 'virtus'
+    require 'json'
+
+    module MyApp
+      module Attributes
+        class JSON < Virtus::Attributes::Object
+          primitive Hash
+
+          def typecast(value, model = nil)
+            ::JSON.parse(value)
+          end
+        end
+      end
+
+      class User
+        include Virtus
+
+        attribute :info, Attributes::JSON
+      end
+    end
+
+    user = MyApp::User.new
+
+    user.info = '{"email" : "john@domain.com" }'
+    user.info # => {"email"=>"john@domain.com"}
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2011 Piotr Solnica. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+require 'jeweler'
+require 'rspec/core/rake_task'
+
+Jeweler::Tasks.new do |gem|
+  gem.name        = "virtus"
+  gem.platform    = Gem::Platform::RUBY
+  gem.authors     = ["Piotr Solnica"]
+  gem.email       = ["piotr@rubyverse.com"]
+  gem.homepage    = "https://github.com/solnic/virtus"
+  gem.summary     = %q{Attributes for your plain ruby objects}
+  gem.description = gem.summary
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+end
+
+Jeweler::GemcutterTasks.new
+
+desc "Run specs"
+RSpec::Core::RakeTask.new
+
+desc 'Default: run specs.'
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/virtus.rb

@@ -0,0 +1,61 @@
+require 'pathname'
+require 'set'
+require 'date'
+require 'time'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module Virtus
+  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
+
+    # 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
+    end
+  end
+end
+
+dir = Pathname(__FILE__).dirname.expand_path
+
+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'

data/lib/virtus/attributes/array.rb

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

data/lib/virtus/attributes/attribute.rb

@@ -0,0 +1,214 @@
+module Virtus
+  module Attributes
+    class Attribute
+      attr_reader :name, :model, :options, :instance_variable_name,
+        :reader_visibility, :writer_visibility
+
+      OPTIONS = [ :primitive, :complex, :accessor, :reader, :writer ].freeze
+
+      DEFAULT_ACCESSOR = :public.freeze
+
+      class << self
+        # Returns an array of valid options
+        #
+        # @return [Array]
+        #   the array of valid option names
+        #
+        # @api public
+        def accepted_options
+          @accepted_options ||= []
+        end
+
+        # Defines which options are valid for a given attribute class.
+        #
+        # Example:
+        #
+        #   class MyAttribute < Virtus::Attributes::Object
+        #     accept_options :foo, :bar
+        #   end
+        #
+        # @api public
+        def accept_options(*args)
+          accepted_options.concat(args)
+
+          # create methods for each new option
+          args.each do |attribute_option|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{attribute_option}(value = Undefined)          # def self.unique(value = Undefined)
+              return @#{attribute_option} if value.equal?(Undefined) #   return @unique if value.equal?(Undefined)
+              @#{attribute_option} = value                           #   @unique = value
+            end                                                      # end
+            RUBY
+          end
+
+          descendants.each { |descendant| descendant.accepted_options.concat(args) }
+        end
+
+        # Returns all the descendant classes
+        #
+        # @return [Array]
+        #   the array of descendants
+        #
+        # @api public
+        def descendants
+          @descendants ||= []
+        end
+
+        # Returns default options hash for a give attribute class.
+        #
+        # @return [Hash]
+        #   a hash of default option values
+        #
+        # @api public
+        def options
+          options = {}
+          accepted_options.each do |method|
+            value = send(method)
+            options[method] = value unless value.nil?
+          end
+          options
+        end
+
+        # Adds descendant to descendants array and inherits default options
+        #
+        # @api private
+        def inherited(descendant)
+          descendants << descendant
+          descendant.accepted_options.concat(accepted_options)
+          options.each { |key, value| descendant.send(key, value) }
+        end
+      end
+
+      accept_options *OPTIONS
+
+      # Returns if an attribute is a complex one.
+      #
+      # @return [TrueClass, FalseClass]
+      #
+      # @api semipublic
+      def complex?
+        options[:complex]
+      end
+
+      # Initializes an attribute instance
+      # 
+      # @param [Symbol] name
+      #   the name of an attribute
+      #
+      # @param [Class] model
+      #   the object's class
+      #
+      # @param [Hash] options
+      #   hash of extra options which overrides defaults set on an attribute class
+      #
+      # @api private
+      def initialize(name, model, options = {})
+        @name    = name
+        @model   = model
+        @options = self.class.options.merge(options).freeze
+
+        @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)
+
+        _create_reader
+        _create_writer
+      end
+
+      # Returns if the given value's class is an attribute's primitive
+      #
+      # @return [TrueClass, FalseClass]
+      #
+      # @api private
+      def primitive?(value)
+        value.kind_of?(self.class.primitive)
+      end
+
+      # Converts the given value to the primitive type unless it's already
+      # the primitive or nil
+      #
+      # @param [Object] value
+      #   the value
+      #
+      # @api private
+      def typecast(value, model = nil)
+        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, model)
+        value
+      end
+
+      # Returns value of an attribute for the given model
+      #
+      # @api private
+      def get(model)
+        get!(model)
+      end
+
+      # Returns the instance variable of the attribute
+      #
+      # @api private
+      def get!(model)
+        model.instance_variable_get(instance_variable_name)
+      end
+
+      # Sets the value on the model
+      #
+      # @api private
+      def set(model, value)
+        return if value.nil?
+        set!(model, primitive?(value) ? value : typecast(value, model))
+      end
+
+      # Sets instance variable of the attribute
+      #
+      # @api private
+      def set!(model, value)
+        model.instance_variable_set(instance_variable_name, value)
+      end
+
+      # Creates an attribute reader method
+      #
+      # @api private
+      def _create_reader
+        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
+      #
+      # @api private
+      def _create_writer
+        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 # Attributes
+end # Virtus