virtus 0.0.2 → 0.0.3

data/spec/unit/virtus/attribute/numeric/class_methods/descendants_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Numeric, '.descendants' do
+  subject { described_class.descendants }
+
+  let(:known_descendants) do
+    [ Virtus::Attribute::Decimal,
+      Virtus::Attribute::Float,
+      Virtus::Attribute::Integer ]
+  end
+
+  it "should return all known attribute classes" do
+    subject.should eql(known_descendants)
+  end
+end

data/spec/unit/virtus/attribute/object/class_methods/descendants_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Object, '.descendants' do
+  subject { described_class.descendants }
+
+  let(:known_descendants) do
+    [ Virtus::Attribute::Array,   Virtus::Attribute::Boolean,
+      Virtus::Attribute::Date,    Virtus::Attribute::DateTime,
+      Virtus::Attribute::Numeric, Virtus::Attribute::Hash,
+      Virtus::Attribute::String,  Virtus::Attribute::Time ]
+  end
+
+  it "should return all known attribute classes" do
+    subject.should eql(known_descendants)
+  end
+end

data/spec/unit/virtus/{attributes → attribute}/string_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::String do
+describe Virtus::Attribute::String do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :email }
     let(:attribute_value)       { 'red john' }
@@ -15,6 +15,6 @@ describe Virtus::Attributes::String do
 
     subject { attribute.typecast(value) }
 
-    it { should == typecast_value }
+    it { should eql(typecast_value) }
   end
 end

data/spec/unit/virtus/{attributes → attribute}/time_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Time do
+describe Virtus::Attribute::Time do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :birthday }
     let(:attribute_value)       { Time.now }
@@ -9,7 +9,7 @@ describe Virtus::Attributes::Time do
 
   describe '#typecast' do
     let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:birthday, Virtus::Attributes::Time) }
+    let(:attribute) { model.attribute(:birthday, Virtus::Attribute::Time) }
 
     let(:year)  { 1983 }
     let(:month) { 11 }
@@ -22,12 +22,22 @@ describe Virtus::Attributes::Time do
 
     shared_examples_for "a correct time" do
       it          { should be_kind_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   }
+      its(:year)  { should eql(year)  }
+      its(:month) { should eql(month) }
+      its(:day)   { should eql(day)   }
+      its(:hour)  { should eql(hour)  }
+      its(:min)   { should eql(min)   }
+      its(:sec)   { should eql(sec)   }
+    end
+
+    context 'with a date' do
+      let(:hour) { 0 }
+      let(:min)  { 0 }
+      let(:sec)  { 0 }
+
+      it_should_behave_like "a correct time" do
+        let(:value) { DateTime.new(year, month, day, hour, min, sec) }
+      end
     end
 
     context 'with a date time' do
@@ -65,7 +75,7 @@ describe Virtus::Attributes::Time do
 
     context 'with a non-date value' do
       let(:value) { '2999' }
-      it { should == value }
+      it { should equal(value) }
     end
   end
 end

data/spec/unit/virtus/class_methods/new_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes, '.new' do
+describe Virtus::Attribute, '.new' do
   let(:model) do
     Class.new do
       include Virtus
@@ -11,9 +11,9 @@ describe Virtus::Attributes, '.new' do
       attr_accessor :age
 
       def self.new(attributes)
-        model = super
-        model.age = 28
-        model
+        instance = super
+        instance.age = 28
+        instance
       end
 
       def initialize(attributes = {})
@@ -28,14 +28,14 @@ describe Virtus::Attributes, '.new' do
   end
 
   it "sets the attributes" do
-    object.name.should == "john"
+    object.name.should eql("john")
   end
 
   it "calls custom #initialize" do
-    object.email.should == "john@domain.com"
+    object.email.should eql("john@domain.com")
   end
 
   it "calls custom .new" do
-    object.age.should == 28
+    object.age.should eql(28)
   end
 end

data/spec/unit/virtus/determine_type_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe Virtus, '.determine_type' do
 
-  (Virtus::Attributes::Object.descendants - [
-   Virtus::Attributes::Boolean,
-   Virtus::Attributes::Object,
-   Virtus::Attributes::Numeric ]).each do |attribute_class|
+  (Virtus::Attribute::Object.descendants - [
+   Virtus::Attribute::Boolean,
+   Virtus::Attribute::Object,
+   Virtus::Attribute::Numeric ]).each do |attribute_class|
 
     context "with #{attribute_primitive = attribute_class.primitive}" do
       subject { described_class.determine_type(attribute_primitive) }

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

@@ -17,6 +17,6 @@ describe Virtus::InstanceMethods, '#attribute_get' do
   end
 
   it "returns the value of an attribute" do
-    object.attribute_get(:name).should == value
+    object.attribute_get(:name).should eql(value)
   end
 end

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

@@ -21,10 +21,10 @@ describe Virtus::InstanceMethods, '#attribute_set' do
   end
 
   it "returns the value" do
-    object.attribute_set(:name, value).should == value
+    object.attribute_set(:name, value).should eql(value)
   end
 
   it "sets value of an attribute" do
-    object.name.should == value
+    object.name.should eql(value)
   end
 end

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

@@ -21,7 +21,7 @@ describe Virtus do
 
   describe '#attributes' do
     it "returns a hash of attributes" do
-      object.attributes.should == attributes
+      object.attributes.should eql(attributes)
     end
   end
 
@@ -31,7 +31,7 @@ describe Virtus do
     end
 
     it "sets attribute values for publicly accessible attributes" do
-      object.attributes.should == attributes
+      object.attributes.should eql(attributes)
     end
   end
 end

data/tasks/metrics/ci.rake

@@ -0,0 +1,7 @@
+desc 'Run metrics with Heckle'
+task :ci => [ 'ci:metrics', :heckle ]
+
+namespace :ci do
+  desc 'Run metrics'
+  task :metrics => [ :verify_measurements, :flog, :flay, :reek, :roodi, 'metrics:all' ]
+end

data/tasks/metrics/flay.rake

@@ -0,0 +1,41 @@
+begin
+  require 'flay'
+  require 'yaml'
+
+  config      = YAML.load_file(File.expand_path('../../../config/flay.yml', __FILE__)).freeze
+  threshold   = config.fetch('threshold').to_i
+  total_score = config.fetch('total_score').to_f
+  files       = Flay.expand_dirs_to_files(config.fetch('path', 'lib'))
+
+  # original code by Marty Andrews:
+  # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
+  desc 'Analyze for code duplication'
+  task :flay do
+    # run flay once without a threshold to ensure the max mass matches the threshold
+    flay = Flay.new(:fuzzy => false, :verbose => false, :mass => 0)
+    flay.process(*files)
+
+    max = flay.masses.map { |hash, mass| mass.to_f / flay.hashes[hash].size }.max
+    unless max >= threshold
+      raise "Adjust flay threshold down to #{max}"
+    end
+
+    total = flay.masses.reduce(0.0) { |total, (hash, mass)| total + (mass.to_f / flay.hashes[hash].size) }
+    unless total == total_score
+      raise "Flay total is now #{total}, but expected #{total_score}"
+    end
+
+    # run flay a second time with the threshold set
+    flay = Flay.new(:fuzzy => false, :verbose => false, :mass => threshold.succ)
+    flay.process(*files)
+
+    if flay.masses.any?
+      flay.report
+      raise "#{flay.masses.size} chunks of code have a duplicate mass > #{threshold}"
+    end
+  end
+rescue LoadError
+  task :flay do
+    abort 'Flay is not available. In order to run flay, you must: gem install flay'
+  end
+end

data/tasks/metrics/flog.rake

@@ -0,0 +1,43 @@
+begin
+  require 'flog'
+  require 'yaml'
+
+  class Float
+    def round_to(n)
+      (self * 10**n).round.to_f * 10**-n
+    end
+  end
+
+  config    = YAML.load_file(File.expand_path('../../../config/flog.yml', __FILE__)).freeze
+  threshold = config.fetch('threshold').to_f.round_to(1)
+
+  # original code by Marty Andrews:
+  # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
+  desc 'Analyze for code complexity'
+  task :flog do
+    flog = Flog.new
+    flog.flog Array(config.fetch('path', 'lib'))
+
+    totals = flog.totals.select  { |name, score| name[-5, 5] != '#none' }.
+                         map     { |name, score| [ name, score.round_to(1) ] }.
+                         sort_by { |name, score| score }
+
+    max = totals.last[1]
+    unless max >= threshold
+      raise "Adjust flog score down to #{max}"
+    end
+
+    bad_methods = totals.select { |name, score| score > threshold }
+    if bad_methods.any?
+      bad_methods.reverse_each do |name, score|
+        puts '%8.1f: %s' % [ score, name ]
+      end
+
+      raise "#{bad_methods.size} methods have a flog complexity > #{threshold}"
+    end
+  end
+rescue LoadError
+  task :flog do
+    abort 'Flog is not available. In order to run flog, you must: gem install flog'
+  end
+end

data/tasks/metrics/heckle.rake

@@ -0,0 +1,261 @@
+$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 => :verify_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 'veritas'
+    root_module = 'Veritas'
+
+    spec_dir = Pathname('spec/unit')
+
+    NameMap::MAP.each do |op, method|
+      next if method.kind_of?(Hash)
+      NameMap::MAP[op] = { :default => method }
+    end
+
+    %w[
+      Veritas::Relation::Header
+      Veritas::Algebra::Difference::Methods
+      Veritas::Algebra::Intersection::Methods
+      Veritas::Algebra::Join::Methods
+      Veritas::Algebra::Product::Methods
+      Veritas::Algebra::Projection::Methods
+      Veritas::Algebra::Rename::Methods
+      Veritas::Algebra::Rename::Aliases
+      Veritas::Algebra::Restriction::Methods
+      Veritas::Algebra::Union::Methods
+    ].each do |mod|
+      NameMap::MAP['-'][mod] = 'difference'
+      NameMap::MAP['&'][mod] = 'intersect'
+      NameMap::MAP['+'][mod] = 'join'
+      NameMap::MAP['*'][mod] = 'product'
+      NameMap::MAP['|'][mod] = 'union'
+    end
+
+    NameMap::MAP['==']['Veritas::Relation::Operation::Order::Direction'] = 'eql'
+
+    NameMap::MAP['|']['Veritas::Relation::Operation::Order::DirectionSet'] = 'union'
+
+    %w[
+      Veritas::Function::Connective::Conjunction::Methods
+      Veritas::Function::Connective::Disjunction::Methods
+      Veritas::Function::Connective::Negation::Methods
+    ].each do |mod|
+      NameMap::MAP['&'][mod] = 'and'
+      NameMap::MAP['|'][mod] = 'or'
+      NameMap::MAP['-'][mod] = 'not'
+    end
+
+    aliases = Hash.new { |h,mod| h[mod] = Hash.new { |h,method| h[method] = method } }
+
+    aliases['Veritas::Attribute::Numeric']['range'] = 'size'
+    aliases['Veritas::Attribute::String']['range']  = 'length'
+
+    aliases['Veritas::Aggregate::Minimum::Methods']['min']              = 'minimum'
+    aliases['Veritas::Aggregate::Maximum::Methods']['max']              = 'maximum'
+    aliases['Veritas::Aggregate::Mean::Methods']['avg']                 = 'mean'
+    aliases['Veritas::Aggregate::Mean::Methods']['average']             = 'mean'
+    aliases['Veritas::Aggregate::Variance::Methods']['var']             = 'variance'
+    aliases['Veritas::Aggregate::StandardDeviation::Methods']['stddev'] = 'standard_deviation'
+
+    aliases['Veritas::Function::Numeric::Addition::Methods']['+']         = 'add'
+    aliases['Veritas::Function::Numeric::Subtraction::Methods']['-']      = 'subtract'
+    aliases['Veritas::Function::Numeric::Multiplication::Methods']['*']   = 'multiply'
+    aliases['Veritas::Function::Numeric::Division::Methods']['/']         = 'divide'
+    aliases['Veritas::Function::Numeric::Absolute::Methods']['abs']       = 'absolute'
+    aliases['Veritas::Function::Numeric::Exponentiation::Methods']['**']  = 'exponent'
+    aliases['Veritas::Function::Numeric::Exponentiation::Methods']['pow'] = 'exponent'
+    aliases['Veritas::Function::Numeric::Modulo::Methods']['%']           = 'modulo'
+    aliases['Veritas::Function::Numeric::Modulo::Methods']['mod']         = 'modulo'
+    aliases['Veritas::Function::Numeric::Random::Methods']['rand']        = 'random'
+    aliases['Veritas::Function::Numeric::SquareRoot::Methods']['sqrt']    = 'square_root'
+    aliases['Veritas::Function::Numeric::UnaryPlus::Methods']['+@']       = 'unary_plus'
+    aliases['Veritas::Function::Numeric::UnaryMinus::Methods']['-@']      = 'unary_minus'
+
+    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}(?::|\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?
+          raise "No spec file #{spec_file} for #{mod}.#{method}"
+        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?
+          raise "No spec file #{spec_file} for #{mod}##{method}"
+        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}(?::|\z)/ && mod >= descedant
+          descedant_spec_prefix = spec_dir.join(descedant.name.underscore)
+          descedant_specs.concat(Pathname.glob(descedant_spec_prefix.join('*_spec.rb')))
+
+          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}(?::|\z)/ && mod >= descedant
+          descedant_spec_prefix = spec_dir.join(descedant.name.underscore)
+          descedant_specs.concat(Pathname.glob(descedant_spec_prefix.join('class_methods/*_spec.rb')))
+        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