virtus 0.5.2 → 0.5.3

data/lib/virtus/support/descendants_tracker.rb

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

data/spec/rcov.opts

@@ -1,7 +0,0 @@
---exclude-only "spec/,^/"
---sort coverage
---callsites
---xrefs
---profile
---text-summary
---failure-threshold 100

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::Object, '.descendants' do
-  subject { described_class.descendants.map { |c| c.to_s }.sort }
-
-  before { pending 'Remove this spec in favor of Virtus::DescentantsTracker spec' }
-
-  let(:known_descendants) do
-    [ Virtus::Attribute::EmbeddedValue, Virtus::Attribute::Symbol,
-      Virtus::Attribute::Time,          Virtus::Attribute::String,
-      Virtus::Attribute::Integer,       Virtus::Attribute::Hash,
-      Virtus::Attribute::Float,         Virtus::Attribute::Decimal,
-      Virtus::Attribute::Numeric,       Virtus::Attribute::DateTime,
-      Virtus::Attribute::Date,          Virtus::Attribute::Boolean,
-      Virtus::Attribute::Set,           Virtus::Attribute::Array,
-      Virtus::Attribute::Collection,    Virtus::Attribute::Class ].map { |a| a.to_s }.sort
-  end
-
-  it 'should return all known attribute classes' do
-    subject.should eql(known_descendants)
-  end
-end

data/spec/unit/virtus/descendants_tracker/add_descendant_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::DescendantsTracker, '#add_descendant' do
-  subject { object.add_descendant(descendant) }
-
-  let(:described_class) { Class.new { extend Virtus::DescendantsTracker } }
-  let(:object)          { Class.new(described_class)                      }
-  let(:descendant)      { Class.new                                       }
-
-  it { should equal(object) }
-
-  it 'prepends the class to the descendants' do
-    object.descendants << original = Class.new
-    expect { subject }.to change { object.descendants.dup }.
-      from([ original ]).
-      to([ descendant, original ])
-  end
-
-  it 'prepends the class to the superclass descendants' do
-    expect { subject }.to change { object.superclass.descendants.dup }.
-      from([ object ]).
-      to([ descendant, object ])
-  end
-end

data/spec/unit/virtus/descendants_tracker/descendants_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::DescendantsTracker, '#descendants' do
-  subject { object.descendants }
-
-  let(:described_class) { Class.new { extend Virtus::DescendantsTracker } }
-  let(:object)          { described_class                                 }
-
-  context 'when there are no descendants' do
-    it_should_behave_like 'an idempotent method'
-
-    it { should be_empty }
-  end
-
-  context 'when there are descendants' do
-    let!(:descendant) { Class.new(object) }  # trigger the class inhertance
-
-    it_should_behave_like 'an idempotent method'
-
-    it { should eql([ descendant ]) }
-  end
-end

data/tasks/metrics/ci.rake

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

data/tasks/metrics/flay.rake

@@ -1,41 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,208 +0,0 @@
-$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 } }
-
-    aliases['Virtus::ValueObject::InstanceMethods']['dup'] = 'clone'
-
-    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?
-          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_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

data/tasks/metrics/metric_fu.rake

@@ -1,29 +0,0 @@
-begin
-  require 'metric_fu'
-  require 'json'
-
-  # XXX: temporary hack until metric_fu is fixed
-  MetricFu::Saikuro.class_eval { include FileUtils }
-
-  MetricFu::Configuration.run do |config|
-    config.rcov = {
-      :environment => 'test',
-      :test_files  => %w[ spec/**/*_spec.rb ],
-      :rcov_opts   => %w[
-        --sort coverage
-        --no-html
-        --text-coverage
-        --no-color
-        --profile
-        --exclude spec/,^/
-        --include lib:spec
-      ],
-    }
-  end
-rescue LoadError
-  namespace :metrics do
-    task :all do
-      abort 'metric_fu is not available. In order to run metrics:all, you must: gem install metric_fu'
-    end
-  end
-end