virtus 0.0.10 → 0.1.0

data/spec/unit/virtus/coercion/string/class_methods/to_time_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
+shared_examples_for 'a correct time object' do
+  it { should be_instance_of(Time) }
+
+  its(:year)  { should == year  }
+  its(:month) { should == month }
+  its(:day)   { should == day   }
+  its(:hour)  { should == hour  }
+  its(:min)   { should == min   }
+  its(:sec)   { should == sec   }
+end
+
 describe Virtus::Coercion::String, '.to_time' do
   subject { object.to_time(string) }
 
   let(:object) { described_class }
 
-  shared_examples_for 'a correct time object' do
-    it { should be_instance_of(Time) }
-
-    its(:year)  { should == year  }
-    its(:month) { should == month }
-    its(:day)   { should == day   }
-    its(:hour)  { should == hour  }
-    its(:min)   { should == min   }
-    its(:sec)   { should == sec   }
-  end
-
   context 'with a valid time string' do
     let(:year)  { 2011 }
     let(:month) { 7    }
@@ -28,7 +28,7 @@ describe Virtus::Coercion::String, '.to_time' do
       let(:min)  { 0 }
       let(:sec)  { 0 }
 
-      it_behaves_like 'a correct time object'
+      it_should_behave_like 'a correct time object'
     end
 
     context 'including time part' do
@@ -38,7 +38,7 @@ describe Virtus::Coercion::String, '.to_time' do
       let(:min)  { 44 }
       let(:sec)  { 50 }
 
-      it_behaves_like 'a correct time object'
+      it_should_behave_like 'a correct time object'
     end
   end
 

data/spec/unit/virtus/coercion/time/class_methods/to_time_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::Time, '.to_time' do
+  subject { object.to_time(time) }
+
+  let(:object) { described_class        }
+  let(:time)   { Time.local(2012, 1, 1) }
+
+  it { should equal(time) }
+end

data/spec/unit/virtus/coercion/true_class/class_methods/to_string_spec.rb

@@ -4,7 +4,7 @@ describe Virtus::Coercion::TrueClass, '.to_string' do
   subject { object.to_string(true_class) }
 
   let(:object)     { described_class }
-  let(:true_class) { true           }
+  let(:true_class) { true            }
 
   it { should be_instance_of(String) }
 

data/spec/unit/virtus/instance_methods/attributes_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
-# TODO: split this into separate files - solnic
-describe Virtus do
+describe Virtus::InstanceMethods do
   let(:model) do
     Class.new do
       include Virtus
@@ -9,36 +8,94 @@ describe Virtus do
       attribute :name,  String
       attribute :age,   Integer
       attribute :email, String, :accessor => :private
+
+      attr_accessor :non_attribute
     end
   end
 
-  let(:object) do
-    model.new(attributes)
-  end
+  let(:attributes) { { :name => 'john', :age => 28 } }
+
+  describe '#attributes' do
+    subject { object.attributes }
 
-  let(:attributes) do
-    { :name => 'john', :age => 28 }
+    let(:object) { model.new(attributes) }
+
+    it { should be_instance_of(Hash) }
+
+    it { should eql(attributes) }
   end
 
-  describe '#attributes' do
-    it "returns a hash of attributes" do
-      object.attributes.should eql(attributes)
+  describe '#attributes=' do
+    subject { object.attributes = attribute_values }
+
+    let(:object) { model.new }
+
+    context 'when given values for publicly writable attributes' do
+      let(:attribute_values) { attributes }
+
+      it { should be(attribute_values) }
+
+      it 'sets all provided attribute values' do
+        object.attributes.should eql(:age => nil, :name => nil)
+        subject
+        object.attributes.should eql(attributes)
+      end
     end
-  end
 
-  describe '#to_hash' do
-    it 'returns attributes' do
-      object.to_hash.should == object.attributes
+    context 'when given string keys for attributes' do
+      let(:attribute_values) { { 'name' => 'john', 'age' => 28 } }
+
+      it { should be(attribute_values) }
+
+      it 'sets values for publicly accessible attributes' do
+        object.attributes.should eql(:age => nil, :name => nil)
+        subject
+        object.attributes.should eql(attributes)
+      end
+    end
+
+    context 'when given values for privately writable attributes' do
+      let(:attribute_values) { attributes.merge(:email => 'john@domain.tld') }
+
+      it { should be(attribute_values) }
+
+      it 'only sets values for publicly accessible attributes' do
+        object.attributes.should eql(:age => nil, :name => nil)
+        subject
+        object.attributes.should eql(attributes)
+      end
     end
-  end
 
-  describe "#attributes=" do
-    before do
-      object.attributes = attributes
+    context 'when given values for non-attribute setters' do
+      let(:attribute_values) { attributes.merge(:non_attribute => 'foobar') }
+
+      it { should be(attribute_values) }
+
+      it 'sets values for publicly accessible attributes' do
+        object.attributes.should eql(:age => nil, :name => nil)
+        subject
+        object.attributes.should eql(attributes)
+      end
+
+      it 'silently ignores publicly accessible non-Virtus attributes' do
+        expect { subject }.to_not change { object.non_attribute }
+      end
     end
 
-    it "sets attribute values for publicly accessible attributes" do
-      object.attributes.should eql(attributes)
+    context "when given values that don't correspond to attributes" do
+      let(:attribute_values) { attributes.merge(:quux => 'foobar') }
+
+      it { should be(attribute_values) }
+
+      it 'sets values for publicly accessible attributes' do
+        object.attributes.should eql(:age => nil, :name => nil)
+        subject
+        object.attributes.should eql(attributes)
+      end
+
+      it 'silently ignores non-attribute keys' do
+        expect { subject }.to_not raise_exception
+      end
     end
   end
 end

data/spec/unit/virtus/instance_methods/element_reference_spec.rb

@@ -18,7 +18,7 @@ describe Virtus::InstanceMethods, '#[]' do
     'john'
   end
 
-  it "returns the value of an attribute" do
+  it 'returns the value of an attribute' do
     should eql(value)
   end
 end

data/spec/unit/virtus/instance_methods/element_set_spec.rb

@@ -18,11 +18,11 @@ describe Virtus::InstanceMethods, '#[]=' do
     'john'
   end
 
-  it "returns the value" do
+  it 'returns the value' do
     should eql(value)
   end
 
-  it "sets value of an attribute" do
+  it 'sets value of an attribute' do
     expect { subject }.to change { object.name }.from(nil).to(value)
   end
 end

data/spec/unit/virtus/instance_methods/to_hash_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Virtus::InstanceMethods, '#to_hash' do
+  subject { object.to_hash }
+
+  class Model
+    include Virtus
+
+    attribute :name,  String
+    attribute :age,   Integer
+    attribute :email, String, :accessor => :private
+  end
+
+  let(:model)      { Model                           }
+  let(:object)     { model.new(attributes)           }
+  let(:attributes) { { :name => 'john', :age => 28 } }
+
+  it { should be_instance_of(Hash) }
+
+  it 'returns attributes' do
+    should eql(attributes)
+  end
+end

data/spec/unit/virtus/options/accept_options_spec.rb

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
-describe Virtus::Options, '.accept_options' do
-  let(:object) do
-    Class.new do
-      extend Virtus::DescendantsTracker
-      extend Virtus::Options
-    end
+describe Virtus::Options, '#accept_options' do
+  class Model
+    extend Virtus::DescendantsTracker
+    extend Virtus::Options
   end
 
+  let(:object)     { Model             }
   let(:descendant) { Class.new(object) }
-  let(:new_option) { :width }
+  let(:new_option) { :width            }
 
   specify { object.should     respond_to(:accept_options) }
   specify { descendant.should respond_to(:accept_options) }
@@ -20,19 +19,19 @@ describe Virtus::Options, '.accept_options' do
     object.accept_options(new_option)
   end
 
-  it "sets new accepted options on itself" do
+  it 'sets new accepted options on itself' do
     object.accepted_options.should include(new_option)
   end
 
-  it "sets new accepted option on its descendants" do
+  it 'sets new accepted option on its descendants' do
     descendant.accepted_options.should include(new_option)
   end
 
-  it "creates option accessors" do
+  it 'creates option accessors' do
     object.should respond_to(new_option)
   end
 
-  it "creates option accessors on descendant" do
+  it 'creates option accessors on descendant' do
     descendant.should respond_to(new_option)
   end
 end

data/spec/unit/virtus/options/accepted_options_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Options, '.accepted_options' do
+describe Virtus::Options, '#accepted_options' do
   subject { object.accepted_options }
 
   specify { object.should respond_to(:accepted_options) }

data/spec/unit/virtus/options/options_spec.rb

@@ -1,11 +1,34 @@
 require 'spec_helper'
 
-describe Virtus::Options, '.options' do
+describe Virtus::Options, '#options' do
   subject { object.options }
 
-  specify { object.should respond_to(:options) }
+  let(:object) do
+    Class.new do
+      extend Virtus::Options, Virtus::DescendantsTracker
+    end
+  end
 
-  let(:object) { Class.new { extend Virtus::Options } }
+  context 'with an option that has a default value' do
+    let(:default_value) { stub('default_value') }
 
-  it { should be_instance_of(Hash) }
+    before do
+      object.accept_options :name
+      object.name default_value
+    end
+
+    it { should be_instance_of(Hash) }
+
+    it { should eql(:name => default_value) }
+  end
+
+  context 'with an option that does not have a default value' do
+    before do
+      object.accept_options :name
+    end
+
+    it { should be_instance_of(Hash) }
+
+    it { should be_empty }
+  end
 end

data/tasks/metrics/ci.rake

@@ -1,4 +1,5 @@
-task :ci => %w[ ci:metrics ]
+desc 'Run metrics with Heckle'
+task :ci => %w[ ci:metrics heckle ]
 
 namespace :ci do
   desc 'Run metrics'

data/tasks/metrics/heckle.rake

@@ -0,0 +1,207 @@
+$LOAD_PATH.unshift(File.expand_path('../../../lib', __FILE__))
+
+# original code by Ashley Moran:
+# http://aviewfromafar.net/2007/11/1/rake-task-for-heckling-your-specs
+
+begin
+  require 'pathname'
+  require 'backports'
+  require 'active_support/inflector'
+  require 'heckle'
+  require 'mspec'
+  require 'mspec/utils/name_map'
+
+  SKIP_METHODS = %w[ blank_slate_method_added ].freeze
+
+  class NameMap
+    def file_name(method, constant)
+      map  = MAP[method]
+      name = if map
+        map[constant] || map[:default]
+      else
+        method.gsub(/[?!=]\z/, '')
+      end
+      "#{name}_spec.rb"
+    end
+  end
+
+  desc 'Heckle each module and class'
+  task :heckle => :rcov do
+    unless Ruby2Ruby::VERSION == '1.2.2'
+      raise "ruby2ruby version #{Ruby2Ruby::VERSION} may not work properly, 1.2.2 *only* is recommended for use with heckle"
+    end
+
+    require 'virtus'
+
+    root_module_regexp = Regexp.union(
+      'Virtus'
+    )
+
+    spec_dir = Pathname('spec/unit')
+
+    NameMap::MAP.each do |op, method|
+      next if method.kind_of?(Hash)
+      NameMap::MAP[op] = { :default => method }
+    end
+
+    aliases = Hash.new { |h,mod| h[mod] = Hash.new { |h,method| h[method] = method } }
+    map     = NameMap.new
+
+    heckle_caught_modules = Hash.new { |hash, key| hash[key] = [] }
+    unhandled_mutations = 0
+
+    ObjectSpace.each_object(Module) do |mod|
+      next unless mod.name =~ /\A#{root_module_regexp}(?::|\z)/
+
+      spec_prefix = spec_dir.join(mod.name.underscore)
+
+      specs = []
+
+      # get the public class methods
+      metaclass  = class << mod; self end
+      ancestors  = metaclass.ancestors
+
+      spec_class_methods = mod.singleton_methods(false)
+
+      spec_class_methods.reject! do |method|
+        %w[ yaml_new yaml_tag_subclasses? included nesting constants ].include?(method.to_s)
+      end
+
+      if mod.ancestors.include?(Singleton)
+        spec_class_methods.reject! { |method| method.to_s == 'instance' }
+      end
+
+      # get the protected and private class methods
+      other_class_methods = metaclass.protected_instance_methods(false) |
+                            metaclass.private_instance_methods(false)
+
+      ancestors.each do |ancestor|
+        other_class_methods -= ancestor.protected_instance_methods(false) |
+                               ancestor.private_instance_methods(false)
+      end
+
+      other_class_methods.reject! do |method|
+        method.to_s == 'allocate' || SKIP_METHODS.include?(method.to_s)
+      end
+
+      other_class_methods.reject! do |method|
+        next unless spec_class_methods.any? { |specced| specced.to_s == $1 }
+
+        spec_class_methods << method
+      end
+
+      # get the instances methods
+      spec_methods = mod.public_instance_methods(false)
+
+      other_methods = mod.protected_instance_methods(false) |
+                      mod.private_instance_methods(false)
+
+      other_methods.reject! do |method|
+        next unless spec_methods.any? { |specced| specced.to_s == $1 }
+
+        spec_methods << method
+      end
+
+      # map the class methods to spec files
+      spec_class_methods.each do |method|
+        method = aliases[mod.name][method]
+        next if SKIP_METHODS.include?(method.to_s)
+
+        spec_file = spec_prefix.join('class_methods').join(map.file_name(method, mod.name))
+
+        unless spec_file.file?
+          warn "No spec file #{spec_file} for #{mod}.#{method}"
+          next
+        end
+
+        specs << [ ".#{method}", [ spec_file ] ]
+      end
+
+      # map the instance methods to spec files
+      spec_methods.each do |method|
+        method = aliases[mod.name][method]
+        next if SKIP_METHODS.include?(method.to_s)
+
+        spec_file = spec_prefix.join(map.file_name(method, mod.name))
+
+        unless spec_file.file?
+          warn "No spec file #{spec_file} for #{mod}##{method}"
+          next
+        end
+
+        specs << [ "##{method}", [ spec_file ] ]
+      end
+
+      # non-public methods are considered covered if they can be mutated
+      # and any spec fails for the current or descendant modules
+      other_methods.each do |method|
+        descedant_specs = []
+
+        ObjectSpace.each_object(Module) do |descedant|
+          next unless descedant.name =~ /\A#{root_module_regexp}(?::|\z)/ && mod >= descedant
+          descedant_spec_prefix = spec_dir.join(descedant.name.underscore)
+          descedant_specs << descedant_spec_prefix
+
+          if method.to_s == 'initialize'
+            descedant_specs.concat(Pathname.glob(descedant_spec_prefix.join('class_methods/new_spec.rb')))
+          end
+        end
+
+        specs << [ "##{method}", descedant_specs ]
+      end
+
+      other_class_methods.each do |method|
+        descedant_specs = []
+
+        ObjectSpace.each_object(Module) do |descedant|
+          next unless descedant.name =~ /\A#{root_module_regexp}(?::|\z)/ && mod >= descedant
+          descedant_specs << spec_dir.join(descedant.name.underscore).join('class_methods')
+        end
+
+        specs << [ ".#{method}", descedant_specs ]
+      end
+
+      specs.sort.each do |(method, spec_files)|
+        puts "Heckling #{mod}#{method}"
+        IO.popen("spec #{spec_files.join(' ')} --heckle '#{mod}#{method}'") do |pipe|
+          while line = pipe.gets
+            case line = line.chomp
+              when "The following mutations didn't cause test failures:"
+                heckle_caught_modules[mod.name] << method
+              when '+++ mutation'
+                unhandled_mutations += 1
+            end
+          end
+        end
+      end
+    end
+
+    if unhandled_mutations > 0
+      error_message_lines = [ "*************\n" ]
+
+      error_message_lines << "Heckle found #{unhandled_mutations} " \
+        "mutation#{"s" unless unhandled_mutations == 1} " \
+        "that didn't cause spec violations\n"
+
+      heckle_caught_modules.each do |mod, methods|
+        error_message_lines << "#{mod} contains the following " \
+          'poorly-specified methods:'
+        methods.each do |method|
+          error_message_lines << " - #{method}"
+        end
+        error_message_lines << ''
+      end
+
+      error_message_lines << 'Get your act together and come back ' \
+        'when your specs are doing their job!'
+
+      raise error_message_lines.join("\n")
+    else
+      puts 'Well done! Your code withstood a heckling.'
+    end
+  end
+rescue LoadError
+  task :heckle do
+    abort 'Heckle or mspec is not available. In order to run heckle, you must: gem install heckle mspec'
+  end
+end