abstract_type 0.0.1

data/lib/abstract_type/version.rb

@@ -0,0 +1,3 @@
+module AbstractType
+  VERSION = '0.0.1'.freeze
+end

data/spec/rcov.opts

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

data/spec/shared/command_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'a command method' do
+  it 'returns self' do
+    should equal(object)
+  end
+end

data/spec/shared/each_method_behaviour.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+shared_examples_for 'an #each method' do
+  it_should_behave_like 'a command method'
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected values' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+end

data/spec/shared/hash_method_behavior.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+shared_examples_for 'a hash method' do
+  it_should_behave_like 'an idempotent method'
+
+  specification = proc do
+    should be_instance_of(Fixnum)
+  end
+
+  it 'is a fixnum' do
+    instance_eval(&specification)
+  end
+
+  it 'memoizes the hash code' do
+    subject.should eql(object.memoized(:hash))
+  end
+end

data/spec/shared/idempotent_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/shared/invertible_method_behaviour.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+shared_examples_for 'an invertible method' do
+  it_should_behave_like 'an idempotent method'
+
+  it 'is invertible' do
+    subject.inverse.should equal(object)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--loadby random
+--format profile

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'abstract_type'
+require 'spec'
+require 'spec/autorun'
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require f }
+
+Spec::Runner.configure do |config|
+end

data/spec/support/config_alias.rb

@@ -0,0 +1,3 @@
+require 'rbconfig'
+
+::Config = RbConfig unless defined?(::Config)

data/spec/unit/abstract_type/class_methods/abstract_method_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe AbstractType::ClassMethods, '#abstract_method' do
+  subject { object.some_method }
+
+  let(:abstract_type) do
+    Class.new do
+      include AbstractType
+
+      abstract_method :some_method
+    end
+  end
+
+  let(:class_under_test)do
+    Class.new(abstract_type) do
+      def self.name; 'TheClassName'; end
+    end
+  end
+
+  let(:object) { class_under_test.new }
+
+  it 'creates an abstract method' do
+    expect { subject }.to raise_error(NotImplementedError,'TheClassName#some_method is not implemented')
+  end
+end

data/spec/unit/abstract_type/class_methods/abstract_singleton_method_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe AbstractType::ClassMethods, '#abstract_method' do
+  subject { object.some_method }
+
+  let(:object) do
+    Class.new do
+      include AbstractType
+
+      abstract_singleton_method :some_method
+
+      def self.name; 'TheClassName'; end
+    end
+  end
+
+  it 'creates an abstract method' do
+    expect { subject }.to raise_error(NotImplementedError, 'TheClassName.some_method is not implemented')
+  end
+end

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe AbstractType::ClassMethods, '#new' do
+  subject { object.new }
+
+  let(:abstract_type) { Class.new { include AbstractType } }
+
+  context 'called on a subclass' do
+    let(:object) { Class.new(abstract_type) }
+
+    it { should be_instance_of(object) }
+  end
+
+  context 'called on the class' do
+    let(:object) { abstract_type }
+
+    specify { expect { subject }.to raise_error(NotImplementedError, "#{object} is an abstract type") }
+  end
+end

data/tasks/metrics/ci.rake

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+desc 'Run metrics with Heckle'
+task :ci => %w[ ci:metrics metrics:heckle ]
+
+namespace :ci do
+  desc 'Run metrics (except heckle) and spec'
+  task :metrics => %w[ spec metrics:verify_measurements metrics:flog metrics:flay metrics:reek metrics:roodi metrics:all ]
+end

data/tasks/metrics/flay.rake

@@ -0,0 +1,45 @@
+# 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')).sort
+
+  namespace :metrics do
+    # 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) || 0
+      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
+  end
+rescue LoadError
+  task :flay do
+    $stderr.puts 'Flay is not available. In order to run flay, you must: gem install flay'
+  end
+end

data/tasks/metrics/flog.rake

@@ -0,0 +1,49 @@
+# 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)
+
+  namespace :metrics do
+    # 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 }
+
+      if totals.any?
+        max = totals.last[1]
+        unless max >= threshold
+          raise "Adjust flog score down to #{max}"
+        end
+      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
+  end
+rescue LoadError
+  task :flog do
+    $stderr.puts 'Flog is not available. In order to run flog, you must: gem install flog'
+  end
+end

data/tasks/metrics/heckle.rake

@@ -0,0 +1,208 @@
+# 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 '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
+
+  namespace :metrics do
+    desc 'Heckle each module and class'
+    task :heckle => :coverage 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 'abstract_type'
+
+      root_module_regexp = Regexp.union('AbstractType')
+
+      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] = [] }
+      uncovered_methods = 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}"
+          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
+                  uncovered_methods += 1
+              end
+            end
+          end
+        end
+      end
+
+      if uncovered_methods > 0
+        error_message_lines = [ "*************\n" ]
+
+        error_message_lines << "Heckle found #{uncovered_methods} " \
+          "method#{"s" unless uncovered_methods == 1} " \
+          "where mutations 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
+  end
+rescue LoadError
+  namespace :metrics do
+    task :heckle => :coverage do
+      $stderr.puts 'Heckle or mspec is not available. In order to run heckle, you must: gem install heckle mspec'
+    end
+  end
+end