ice_nine 0.1.0

data/spec/unit/ice_nine/freezer/class_methods/element_reference_spec.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer'
+require 'ice_nine/freezer/struct'
+
+describe IceNine::Freezer, '.[]' do
+  subject { object[mod] }
+
+  let(:object)  { described_class }
+  let(:freezer) { object          }
+
+  describe 'when the module matches a descendant' do
+    let(:freezer) { Class.new(object) }
+    let(:mod)     { Class             }
+
+    before do
+      object.const_set(mod.name, freezer)
+    end
+
+    after do
+      object.send(:remove_const, mod.name)
+    end
+
+    it 'returns the freezer' do
+      should be(freezer)
+    end
+  end
+
+  describe 'when the module matches a descendant inside a namespace' do
+    let(:namespace) { Class.new(object) }
+    let(:freezer)   { Class.new(object) }
+    let(:mod)       { Application::User }
+
+    before :all do
+      module ::Application
+        class User; end
+      end
+    end
+
+    after :all do
+      ::Application.send(:remove_const, :User)
+      Object.send(:remove_const, :Application)
+    end
+
+    before do
+      namespace.const_set(:User, freezer)
+      object.const_set(:Application, namespace)
+    end
+
+    after do
+      namespace.send(:remove_const, :User)
+      object.send(:remove_const, :Application)
+    end
+
+    it 'returns the freezer' do
+      should be(freezer)
+    end
+  end
+
+  describe 'when the module is a struct' do
+    let(:mod)     { Struct.new(:a)           }
+    let(:freezer) { IceNine::Freezer::Struct }
+
+    it 'returns the freezer' do
+      should be(freezer)
+    end
+  end
+
+  describe 'when the module does not match a descendant' do
+    let(:mod) { Object }
+
+    it 'returns the freezer' do
+      should be(freezer)
+    end
+  end
+
+  describe 'when the module is anonymous' do
+    let(:mod) { Class.new }
+
+    it 'returns the freezer' do
+      should be(freezer)
+    end
+  end
+end

data/spec/unit/ice_nine/freezer/false_class/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer/no_freeze'
+
+describe IceNine::Freezer::FalseClass, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with a false object' do
+    let(:value) { false }
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'does not freeze the object' do
+      expect { subject }.should_not change(value, :frozen?).from(false)
+    end
+  end
+end

data/spec/unit/ice_nine/freezer/hash/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine'
+
+describe IceNine::Freezer::Hash, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with a Hash object' do
+    let(:value) { { Object.new => Object.new } }
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'freezes the object' do
+      expect { subject }.should change(value, :frozen?).from(false).to(true)
+    end
+
+    it 'freezes each key in the Hash' do
+      subject.keys.select(&:frozen?).should == subject.keys
+    end
+
+    it 'freezes each value in the Hash' do
+      subject.values.select(&:frozen?).should == subject.values
+    end
+
+    if RUBY_VERSION >= '1.9' and RUBY_ENGINE == 'rbx'
+      it 'does not freeze the Hash state' do
+        subject.instance_variable_get(:@state).should_not be_frozen
+      end
+
+      it 'does not freeze the Hash entries' do
+        subject.instance_variable_get(:@entries).should_not be_frozen
+      end
+    end
+  end
+end

data/spec/unit/ice_nine/freezer/nil_class/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer/no_freeze'
+
+describe IceNine::Freezer::NilClass, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with a nil object' do
+    let(:value) { nil }
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'does not freeze the object' do
+      expect { subject }.should_not change(value, :frozen?).from(false)
+    end
+  end
+end

data/spec/unit/ice_nine/freezer/no_freeze/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer/no_freeze'
+
+describe IceNine::Freezer::NoFreeze, '.deep_freeze' do
+   subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+  let(:value)  { stub('value')   }
+
+  it 'returns the object' do
+    should be(value)
+  end
+
+  it 'does not freeze the object' do
+    expect { subject }.should_not change(value, :frozen?).from(false)
+  end
+end

data/spec/unit/ice_nine/freezer/numeric/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer/no_freeze'
+
+describe IceNine::Freezer::Numeric, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  [ 0.0, 0, 0x7fffffffffffffff ].each do |value|
+    context "with a #{value.class} object" do
+      let(:value) { value }
+
+      it 'returns the object' do
+        should be(value)
+      end
+
+      it 'does not freeze the object' do
+        expect { subject }.should_not change(value, :frozen?).from(false)
+      end
+    end
+  end
+end

data/spec/unit/ice_nine/freezer/range/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine'
+
+describe IceNine::Freezer::Range, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with a Range' do
+    let(:value) { 'a'..'z' }
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'freezes the object' do
+      expect { subject }.should change(value, :frozen?).from(false).to(true)
+    end
+
+    it 'freeze the first object in the Range' do
+      subject.begin.should be_frozen
+    end
+
+    it 'freeze the last object in the Range' do
+      subject.end.should be_frozen
+    end
+  end
+end

data/spec/unit/ice_nine/freezer/struct/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine'
+
+describe IceNine::Freezer::Struct, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with a Struct' do
+    let(:value) { klass.new('1') }
+    let(:klass) { Struct.new(:a) }
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'freezes the object' do
+      expect { subject }.should change(value, :frozen?).from(false).to(true)
+    end
+
+    it 'freezes each value in the Struct' do
+      subject.values.select(&:frozen?).should == subject.values
+    end
+  end
+end

data/spec/unit/ice_nine/freezer/symbol/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer/no_freeze'
+
+describe IceNine::Freezer::Symbol, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with a Symbol object' do
+    let(:value) { :symbol }
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'does not freeze the object' do
+      expect { subject }.should_not change(value, :frozen?).from(false)
+    end
+  end
+end

data/spec/unit/ice_nine/freezer/true_class/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer/no_freeze'
+
+describe IceNine::Freezer::TrueClass, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with a true object' do
+    let(:value) { true }
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'does not freeze the object' do
+      expect { subject }.should_not change(value, :frozen?).from(false)
+    end
+  end
+end

data/tasks/metrics/ci.rake

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+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.nil? || 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,46 @@
+# encoding: utf-8
+
+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                       }
+
+    last = totals.last
+    max  = last[1] if last
+    unless max.nil? || 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,210 @@
+# encoding: utf-8
+
+$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 '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 'ice_nine'
+
+    root_module_regexp = Regexp.union(
+      'IceNine'
+    )
+
+    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
+
+      spec_class_methods -= other_class_methods
+
+      # 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}"
+          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?
+          raise "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 => e
+  task :heckle do
+    abort 'Heckle or mspec is not available. In order to run heckle, you must: gem install heckle mspec' << e
+  end
+end