virtus 0.0.3 → 0.0.4

data/lib/virtus/instance_methods.rb

@@ -1,9 +1,11 @@
 module Virtus
+
   # Instance methods that are added when you include Virtus
   module InstanceMethods
+
     # Set attributes during initialization of an object
     #
-    # @param [Hash] attributes
+    # @param [#to_hash] attributes
     #   the attributes hash to be set
     #
     # @return [Object]
@@ -23,7 +25,7 @@ module Virtus
     #   end
     #
     #   user = User.new(:name => 'John')
-    #   user.attribute_get(:name) # => "john"
+    #   user[:name] # => "john"
     #
     # @param [Symbol] name
     #   a name of an attribute
@@ -32,8 +34,8 @@ module Virtus
     #   a value of an attribute
     #
     # @api public
-    def attribute_get(name)
-      __send__(name)
+    def [](name)
+      attribute_get(name)
     end
 
     # Sets a value of the attribute with the given name
@@ -46,7 +48,7 @@ module Virtus
     #   end
     #
     #   user = User.new
-    #   user.attribute_set(:name) # => "john"
+    #   user[:name] = "john" # => "john"
     #   user.name # => "john"
     #
     # @param [Symbol] name
@@ -59,11 +61,11 @@ module Virtus
     #   the value set on an object
     #
     # @api public
-    def attribute_set(name, value)
-      __send__("#{name}=", value)
+    def []=(name, value)
+      attribute_set(name, value)
     end
 
-    # Mass-assign of attribute values
+    # Returns a hash of all publicly accessible attributes
     #
     # @example
     #   class User
@@ -73,23 +75,25 @@ module Virtus
     #     attribute :age,  Integer
     #   end
     #
-    #   user = User.new
-    #   user.attributes = { :name => 'John', :age => 28 }
-    #
-    # @param [Hash] attributes
-    #   a hash of attribute values to be set on an object
+    #   user = User.new(:name => 'John', :age => 28)
+    #   user.attributes # => { :name => 'John', :age => 28 }
     #
     # @return [Hash]
     #   the attributes
     #
     # @api public
-    def attributes=(attributes)
-      attributes.each do |name, value|
-        attribute_set(name, value) if respond_to?("#{name}=")
+    def attributes
+      attributes = {}
+
+      self.class.attributes.each do |attribute|
+        name = attribute.name
+        attributes[name] = attribute_get(name) if respond_to?(name)
       end
+
+      attributes
     end
 
-    # Returns a hash of all publicly accessible attributes
+    # Mass-assign of attribute values
     #
     # @example
     #   class User
@@ -99,21 +103,41 @@ module Virtus
     #     attribute :age,  Integer
     #   end
     #
-    #   user = User.new(:name => 'John', :age => 28)
-    #   user.attributes # => { :name => 'John', :age => 28 }
+    #   user = User.new
+    #   user.attributes = { :name => 'John', :age => 28 }
+    #
+    # @param [#to_hash] attributes
+    #   a hash of attribute values to be set on an object
     #
     # @return [Hash]
     #   the attributes
     #
     # @api public
-    def attributes
-      attributes = {}
-
-      self.class.attributes.each_key do |name|
-        attributes[name] = attribute_get(name) if respond_to?(name)
+    def attributes=(attributes)
+      attributes.to_hash.each do |name, value|
+        attribute_set(name, value) if respond_to?("#{name}=")
       end
+    end
 
-      attributes
+  private
+
+    # Returns a value of the attribute with the given name
+    #
+    # @see Virtus::InstanceMethods#[]
+    #
+    # @api private
+    def attribute_get(name)
+      __send__(name)
     end
-  end # InstanceMethods
-end # Virtus
+
+    # Sets a value of the attribute with the given name
+    #
+    # @see Virtus::InstanceMethods#[]=
+    #
+    # @api private
+    def attribute_set(name, value)
+      __send__("#{name}=", value)
+    end
+
+  end # module InstanceMethods
+end # module Virtus

data/lib/virtus/support/descendants_tracker.rb

@@ -0,0 +1,30 @@
+module Virtus
+
+  # A module that adds descendant tracking to a class
+  module DescendantsTracker
+
+    # Hook called when class is inherited
+    #
+    # @param [Class] descendant
+    #
+    # @return [self]
+    #
+    # @api private
+    def inherited(descendant)
+      superclass = self.superclass
+      superclass.inherited(descendant) if superclass.respond_to?(:descendants)
+      descendants.unshift(descendant)
+      self
+    end
+
+    # Return the descendants of this class
+    #
+    # @return [Array<Class>]
+    #
+    # @api private
+    def descendants
+      @descendants ||= []
+    end
+
+  end # module DescendantsTracker
+end # module Virtus

data/lib/virtus/typecast/boolean.rb

@@ -1,12 +1,13 @@
 module Virtus
   module Typecast
+
     # Typecast defined values into true or false.
     # See TRUE_VALUES and FALSE_VALUES constants for a reference.
     class Boolean
+
       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
+      BOOLEAN_MAP  = Hash[ TRUE_VALUES.product([ true ]) + FALSE_VALUES.product([ false ]) ].freeze
 
       # Typecast value to TrueClass or FalseClass
       #
@@ -22,6 +23,7 @@ module Virtus
       def self.call(value)
         BOOLEAN_MAP.fetch(value, value)
       end
-    end # Boolean
-  end # Typecast
-end # Virtus
+
+    end # class Boolean
+  end # module Typecast
+end # module Virtus

data/lib/virtus/typecast/numeric.rb

@@ -1,14 +1,18 @@
 module Virtus
   module Typecast
+
     # Typecast numeric values. Supports Integer, Float and BigDecimal
     class Numeric
+
+      REGEXP = /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/.freeze
+
       # Typecast value to integer
       #
       # @example
       #   Virtus::Typecast::Numeric.to_i('1') # => 1
       #   Virtus::Typecast::Numeric.to_i(1.2) # => 1
       #
-      # @param [Object]
+      # @param [Object] value
       #
       # @return [Integer]
       #
@@ -23,7 +27,7 @@ module Virtus
       #   Virtus::Typecast::Numeric.to_f('1.2') # => 1.2
       #   Virtus::Typecast::Numeric.to_f(1)     # => 1.0
       #
-      # @param [Object]
+      # @param [Object] value
       #
       # @return [Float]
       #
@@ -38,7 +42,7 @@ module Virtus
       #   Virtus::Typecast::Numeric.to_d('1.2') # => #<BigDecimal:b72157d4,'0.12E1',8(8)>
       #   Virtus::Typecast::Numeric.to_d(1)     # => #<BigDecimal:b7212e08,'0.1E1',4(8)>
       #
-      # @param [Object]
+      # @param [Object] value
       #
       # @return [BigDecimal]
       #
@@ -51,7 +55,7 @@ module Virtus
         end
       end
 
-      private
+    private
 
       # Match numeric string
       #
@@ -66,7 +70,7 @@ module Virtus
       # @api private
       def self.call(value, method)
         if value.respond_to?(:to_str)
-          if value.to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
+          if value.to_str =~ REGEXP
             $1.send(method)
           else
             value
@@ -77,6 +81,7 @@ module Virtus
           value
         end
       end
-    end # Numeric
-  end # Typecast
-end # Virtus
+
+    end # class Numeric
+  end # module Typecast
+end # module Virtus

data/lib/virtus/typecast/string.rb

@@ -0,0 +1,24 @@
+module Virtus
+  module Typecast
+
+    # Typecast any object to a string
+    class String
+
+      # Typecast value to a string
+      #
+      # @example
+      #   Virtus::Typecast::String.call(1)  # => '1'
+      #   Virtus::Typecast::String.call([]) # => '[]'
+      #
+      # @param [Object] value
+      #
+      # @return [String]
+      #
+      # @api public
+      def self.call(value)
+        value.to_s
+      end
+
+    end # class String
+  end # module Typecast
+end # module Virtus

data/lib/virtus/typecast/time.rb

@@ -1,5 +1,6 @@
 module Virtus
   module Typecast
+
     # Typecast various values into Date, DateTime or Time
     class Time
       SEGMENTS = [ :year, :month, :day, :hour, :min, :sec ].freeze
@@ -67,14 +68,14 @@ module Virtus
         call(value, :to_datetime)
       end
 
-      private
+    private
 
       # @api private
       def self.call(value, method)
         return value.send(method) if value.respond_to?(method)
 
         begin
-          if value.is_a?(::Hash)
+          if value.kind_of?(::Hash)
             from_hash(value, method)
           else
             from_string(value.to_s, method)
@@ -157,6 +158,7 @@ module Virtus
           Numeric.to_i(value.fetch(segment, now.send(segment)))
         end
       end
-    end # Time
-  end # Typecast
-end # Virtus
+
+    end # class Time
+  end # module Typecast
+end # module Virtus

data/spec/integration/virtus/class_methods/attribute_spec.rb

@@ -5,9 +5,9 @@ describe Virtus::ClassMethods, '.attribute' do
     Class.new { include Virtus }
   end
 
-  it { described_class.should respond_to(:attribute)  }
+  specify { described_class.should respond_to(:attribute)  }
 
-  describe ".attribute" do
+  context "in the class" do
     before do
       described_class.attribute(:name,    String)
       described_class.attribute(:email,   String,  :accessor => :private)
@@ -20,11 +20,11 @@ describe Virtus::ClassMethods, '.attribute' do
     let(:protected_instance_methods) { described_class.protected_instance_methods.map { |method| method.to_s } }
     let(:private_instance_methods)   { described_class.private_instance_methods.map   { |method| method.to_s } }
 
-    it "should create an attribute" do
-      described_class.attributes.should have_key(:name)
+    it "returns self" do
+      described_class.attribute(:name, String).should be(described_class)
     end
 
-    it "should create an attribute of a correct type" do
+    it "creates an attribute of a correct type" do
       described_class.attributes[:name].should be_instance_of(Virtus::Attribute::String)
     end
 
@@ -60,4 +60,16 @@ describe Virtus::ClassMethods, '.attribute' do
       protected_instance_methods.should include('bday=')
     end
   end
+
+  context "in the descendants" do
+    subject { described_class.attribute(:name, String).attributes[:name] }
+
+    let(:descendant) { Class.new(described_class) }
+
+    it 'updates the descendant attributes' do
+      descendant.attributes.to_a.should be_empty
+      @attribute = subject
+      descendant.attributes.to_a.should eql([ @attribute ])
+    end
+  end
 end

data/spec/integration/virtus/class_methods/attributes_spec.rb

@@ -15,11 +15,8 @@ describe Virtus::ClassMethods, '.attributes' do
 
     subject { described_class.attributes }
 
-    it "returns an attributes hash" do
-      subject.should eql(
-        :name => described_class.attributes[:name],
-        :age  => described_class.attributes[:age]
-      )
+    it "returns a set of attributes" do
+      subject.should be_kind_of(Virtus::AttributeSet)
     end
   end
 end

data/spec/shared/idempotent_method_behaviour.rb

@@ -0,0 +1,5 @@
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/spec_helper.rb

@@ -9,3 +9,18 @@ ENV['TZ'] = 'UTC'
 SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
 
 Pathname.glob((SPEC_ROOT + '**/shared/**/*.rb').to_s).each { |file| require file }
+
+RSpec.configure do |config|
+
+  # Remove anonymous Attribute classes from Attribute descendants
+  config.after :all do
+    stack = [ Virtus::Attribute ]
+    while klass = stack.pop
+      klass.descendants.delete_if do |descendant|
+        descendant.name.nil? || descendant.name.empty?
+      end
+      stack.concat(klass.descendants)
+    end
+  end
+
+end

data/spec/unit/shared/attribute.rb

@@ -1,157 +1,8 @@
-# TODO: split this into separate files
-
 shared_examples_for "Attribute" do
-  def attribute_name
-    raise "+attribute_name+ should be defined"
-  end
-
-  before :all do
-    Object.send(:remove_const, :SubAttribute) if Object.const_defined?(:SubAttribute)
-    Object.send(:remove_const, :User)         if Object.const_defined?(:User)
-  end
-
-  let(:sub_attribute) { class SubAttribute < described_class; end; SubAttribute }
-
-  let(:model) do
-    Class.new { include Virtus }
-  end
-
-  describe ".options" do
-    subject { described_class.options }
-    it { should be_instance_of(Hash) }
-  end
-
-  describe ".accepted_options" do
-    it "returns an array of accepted options" do
-      described_class.accepted_options.should be_instance_of(Array)
-    end
-
-    it "accepts base options" do
-      described_class.accepted_options.should include(*Virtus::Attribute::OPTIONS)
-    end
-  end
-
-  describe ".accept_options" do
-    let(:new_option) { :width }
-
-    before :all do
-      described_class.accepted_options.should_not include(new_option)
-      described_class.accept_options(new_option)
-    end
-
-    it "sets new accepted options on itself" do
-      described_class.accepted_options.should include(new_option)
-    end
-
-    it "sets new accepted option on its descendants" do
-      sub_attribute.accepted_options.should include(new_option)
-    end
-
-    it "creates option accessors" do
-      described_class.should respond_to(new_option)
-    end
-
-    it "creates option accessors on descendants" do
-      sub_attribute.should respond_to(new_option)
-    end
-
-    context 'with default option value' do
-      let(:option) { :height }
-      let(:value)  { 10 }
-
-      before :all do
-        sub_attribute.accept_options(option)
-        sub_attribute.height(value)
-      end
-
-      context "when new attribute is created" do
-        subject { sub_attribute.new(attribute_name) }
-
-        it "sets the default value" do
-          subject.options[option].should eql(value)
-        end
-      end
-
-      context "when new attribute is created and overrides option's default value" do
-        let(:new_value) { 11 }
-
-        subject { sub_attribute.new(attribute_name, option => new_value) }
-
-        it "sets the new value" do
-          subject.options[option].should eql(new_value)
-        end
-      end
-    end
-  end
-
-  describe "#set" do
-    let(:attribute) { model.attribute(attribute_name, described_class) }
-    let(:object)    { model.new }
-
-    context "with nil" do
-      subject { attribute.set(object, nil) }
-
-      it "doesn't set the ivar" do
-        subject
-        object.instance_variable_defined?(attribute.instance_variable_name).should be(false)
-      end
-
-      it "returns nil" do
-        subject.should be(nil)
-      end
-    end
-
-    context "with a primitive value" do
-      before { attribute.set(object, attribute_value) }
-
-      it "sets the value in an ivar" do
-        object.instance_variable_get(attribute.instance_variable_name).should eql(attribute_value)
-      end
-    end
-
-    context "with a non-primitive value" do
-      before { attribute.set(object, attribute_value_other) }
-
-      it "sets the value in an ivar converted to the primitive type" do
-        object.instance_variable_get(attribute.instance_variable_name).should be_kind_of(described_class.primitive)
-      end
-    end
-  end
-
-  describe "#get" do
-    let(:attribute) { model.attribute(attribute_name, described_class) }
-    let(:object)    { model.new }
-
-    context "when a non-nil value is set" do
-      before { attribute.set(object, attribute_value) }
-
-      subject { attribute.get(object) }
-
-      it { should eql(attribute_value) }
-    end
-
-    context "when nil is set" do
-      before { attribute.set(object, nil) }
-
-      subject { attribute.get(object) }
-
-      it { should be(nil) }
-    end
-  end
-
-  describe "#complex?" do
-    let(:attribute) { model.attribute(attribute_name, described_class, :complex => complex) }
-
-    subject { attribute.complex? }
-
-    context "when set to true" do
-      let(:complex) { true }
-      it { should be(true) }
-    end
-
-    context "when set to false" do
-      let(:complex) { false }
-      it { should be(false) }
-    end
-  end
+  it_behaves_like 'Attribute.options'
+  it_behaves_like 'Attribute.accept_options'
+  it_behaves_like 'Attribute.accepted_options'
+  it_behaves_like 'Attribute#set'
+  it_behaves_like 'Attribute#get'
+  it_behaves_like 'Attribute#complex?'
 end