dkubb-yardstick 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,8 @@
+*.sw?
+.DS_Store
+.yardoc
+coverage
+rdoc
+doc
+pkg
+tmp

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Dan Kubb
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,16 @@
+= yardstick
+
+Yardstick is a tool that verifies YARD coverage of ruby code.
+
+It will measure the source and provide feedback on what is missing from
+the documentation and what can be improved.
+
+== Usage
+
+From the command-line:
+
+  yardstick lib/**/*.rb
+
+== Copyright
+
+Copyright (c) 2009 Dan Kubb. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'rake'
+require 'pathname'
+
+Pathname.glob('tasks/**/*.rake').each { |task| load task.expand_path }
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name              = 'yardstick'
+    gem.summary           = 'A tool for verifying YARD documentation coverage'
+    gem.email             = 'dan.kubb@gmail.com'
+    gem.homepage          = 'http://github.com/dkubb/yardstick'
+    gem.authors           = [ 'Dan Kubb' ]
+    gem.rubyforge_project = 'yardstick'
+
+    gem.add_dependency('yard', '~>0.2')
+  end
+
+  Jeweler::RubyforgeTasks.new
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler'
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/yardstick

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -KU
+
+require 'rubygems'
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent.join('lib', 'yardstick')
+
+Yardstick::CLI.run(*ARGV)

data/lib/yardstick/autoload.rb

@@ -0,0 +1,7 @@
+module Yardstick
+  autoload :CLI,         'yardstick/cli'
+  autoload :Measurable,  'yardstick/measurable'
+  autoload :Measurement, 'yardstick/measurement'
+  autoload :Method,      'yardstick/method'
+  autoload :Processor,   'yardstick/processor'
+end # module Yardstick

data/lib/yardstick/cli.rb

@@ -0,0 +1,78 @@
+require 'optparse'
+
+module Yardstick
+  class CLI
+
+    # Parse the command line options, and run the command
+    #
+    # @example
+    #   Yardstick::CLI.run(%w[ article.rb ])  # => [ Measurement ]
+    #
+    # @param [Array] *args
+    #   arguments passed in from the command line
+    #
+    # @return [Array(Measurement)]
+    #   the measurement for each file
+    #
+    # @api private
+    def self.run(*args)
+      Yardstick.measure(*parse_options(args)).each do |measurement|
+        measurement.warn
+      end
+    end
+
+    # Parse the options provided from the command-line
+    #
+    # @param [Array<String>] args
+    #   the command-line options
+    #
+    # @return [Array(Array<String>, Hash)]
+    #   the list of files, and options parsed from the command-line
+    #
+    # @api private
+    def self.parse_options(args)
+      args << '--help' if args.empty?
+      options = {}
+      option_parser(options).parse!(args)
+      [ args, options ]
+    rescue OptionParser::InvalidOption => error
+      display_exit(error.message << "\n" << args.inspect)
+    end
+
+    # Return an OptionParser instance for the command-line app
+    #
+    # @param [Hash] options
+    #   the options to set when parsing the command-line arguments
+    #
+    # @return [OptionParser]
+    #   the option parser instance
+    #
+    # @api private
+    def self.option_parser(options)
+      opts = OptionParser.new
+      opts.on_tail('-v', '--version', 'print version information and exit') { display_exit("#{opts.program_name} #{Yardstick::VERSION}") }
+      opts.on_tail('-h', '--help',    'display this help and exit')         { display_exit(opts) }
+      opts
+    end
+
+    # Display a message and exit
+    #
+    # @param [#to_str] message
+    #   the message to display
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.display_exit(message)
+      puts message.to_str
+      exit
+    end
+
+    class << self
+      private :option_parser
+      private :parse_options
+      private :display_exit
+    end
+
+  end # module CLI
+end # module Yardstick

data/lib/yardstick/core_ext/object.rb

@@ -0,0 +1,13 @@
+class Object  #:nodoc:
+
+  # Return the meta class for this instance
+  #
+  # @return [Class]
+  #   the meta class
+  #
+  # @api private
+  def meta_class
+    class << self; self end
+  end
+
+end # class Object

data/lib/yardstick/measurable.rb

@@ -0,0 +1,95 @@
+module Yardstick
+  module Measurable
+    include Measurement::UtilityMethods
+
+    module ClassMethods
+
+      # List of measurement types for this class
+      #
+      # @return [Array<Array(String, Symbol)>]
+      #   the measurements for this class
+      #
+      # @api private
+      def measurements
+        @measurements ||= []
+      end
+
+      # Set the description for the measurement
+      #
+      # @param [#to_str] description
+      #   the measurement description
+      #
+      # @yield []
+      #   the measurement to perform
+      #
+      # @yieldreturn [Boolean]
+      #   return true if successful, false if not
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def measurement(description, &block)
+        measurements << [ description, block ]
+      end
+
+    private
+
+      # Include the class or module with measurable class methods
+      #
+      # @param [Module] mod
+      #   the module to include within
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def included(mod)
+        mod.extend(ClassMethods)
+        copy_measurements(mod)
+      end
+
+      # Extend the docstring meta class with measurable class methods
+      #
+      # @param [YARD::Docstring] docstring
+      #   the docstring to extend
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def extended(docstring)
+        meta_class = docstring.meta_class
+        meta_class.extend(ClassMethods)
+        copy_measurements(meta_class)
+      end
+
+      # Copy measurements from the ancestor to the descendant
+      #
+      # @param [Module] descendant
+      #   the descendant module or class
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def copy_measurements(descendant)
+        descendant.measurements.concat(measurements).uniq!
+      end
+    end # module ClassMethods
+
+    extend ClassMethods
+
+    # Return a list of measurements for this docstring instance
+    #
+    # @example
+    #   docstring.measure  # => [ Measurement ]
+    #
+    # @return [Array<Measurement>]
+    #   a collection of measurements
+    #
+    # @api public
+    def measure
+      meta_class.measurements.map do |(description, block)|
+        Measurement.new(description, self, &block)
+      end
+    end
+
+  end # module Measurable
+end # module Yardstick

data/lib/yardstick/measurement.rb

@@ -0,0 +1,176 @@
+module Yardstick
+  class Measurement
+
+    # Return a Measurement instance
+    #
+    # @example
+    #   measurement = Measurement.new('The description', docstring, :successful_method)
+    #
+    # @param [#to_str] description
+    #   the measurement description
+    # @param [YARD::Docstring] docstring
+    #   the docstring to measure
+    #
+    # @yield []
+    #   the measurement to perform
+    #
+    # @return [Yardstick::Measurement]
+    #   the measurement instance
+    #
+    # @api public
+    def initialize(description, docstring, &block)
+      @description = description.to_str
+      @docstring   = docstring
+      @block       = block
+      @result      = measure
+    end
+
+    # Return true if the measurement was successful
+    #
+    # @example Measurement successful
+    #   measurement.ok?  # => true
+    #
+    # @example Measurement unsuccessful
+    #   measurement.ok?  # => false
+    #
+    # @return [Boolean]
+    #   true if the measurement was successful, false if not
+    #
+    # @api public
+    def ok?
+      @result == true || skip?
+    end
+
+    # Return true if the measurement was skipped
+    #
+    # @example Measurement skipped
+    #   measurement.skip?  # => true
+    #
+    # @example Measurement not skipped
+    #   measurement.skip?  # => false
+    #
+    # @return [Boolean]
+    #   true if the measurement was skipped, false if not
+    #
+    # @api public
+    def skip?
+      @result == :skip
+    end
+
+    # Return true if the measurement is not implemented
+    #
+    # @example Measurement not implemented
+    #   measurement.todo?  # => true
+    #
+    # @example Measurement implemented
+    #   measurement.todo?  # => false
+    #
+    # @return [Boolean]
+    #   true if the measurement is not implemented, false if not
+    #
+    # @api public
+    def todo?
+      @result == :todo
+    end
+
+    # Warns the results the measurement if it was not successful
+    #
+    # @example
+    #   measurement.warn  # (outputs results if not successful)
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def warn
+      unless ok?
+        Kernel.warn("#{file}:#{line}: #{path}: #{@description}")
+      end
+    end
+
+  private
+
+    # Measure the docstring using the method provided to the constructor
+    #
+    # @return [Boolean, Symbol]
+    #   true if the test is successful, false if not
+    #   :todo if the test is not implemented
+    #   :skip if the test does not apply
+    #
+    # @api private
+    def measure
+      catch :measurement do
+        @docstring.instance_eval(&@block)
+      end
+    end
+
+    # The code object for the docstring
+    #
+    # @return [YARD::CodeObjects::Base]
+    #   the code object
+    #
+    # @api private
+    def object
+      @docstring.object
+    end
+
+    # The filename for the code
+    #
+    # @return [Pathname]
+    #   the filename
+    #
+    # @api private
+    def file
+      Pathname(object.file)
+    end
+
+    # The line number for the code
+    #
+    # @return [Integer]
+    #   the line number
+    #
+    # @api private
+    def line
+      object.line
+    end
+
+    # The class and method name for the code
+    #
+    # @return [String]
+    #   the class and method name
+    #
+    # @api private
+    def path
+      object.path.sub(/\A::/, '')
+    end
+
+    module UtilityMethods  #:nodoc:
+      private
+
+      # Throw a :skip measurement message to the caller
+      #
+      # This method allows you to short-circuit measurement methods when
+      # the measurement does not apply due to specific object states.
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def skip
+        throw :measurement, :skip
+      end
+
+      # Throw a :todo measurement message to the caller
+      #
+      # This method allows you to short-circuit measurement methods when
+      # the measurement is not implemented.
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def todo
+        throw :measurement, :todo
+      end
+
+    end # module UtilityMethods
+
+  end # class Measurement
+end # module Yardstick

data/lib/yardstick/method.rb

@@ -0,0 +1,106 @@
+module Yardstick
+  module Method
+    include Measurable
+
+    measurement 'The method summary should be specified' do
+      skip if has_tag?('see')
+      summary != ''
+    end
+
+    measurement 'The method summary should be less than 80 characters in length' do
+      summary.length <= 78
+    end
+
+    measurement 'The method summary should be a single line' do
+      !summary.include?("\n")
+    end
+
+    measurement 'The method summary should not end in a period' do
+      summary[0, -1] != '.'
+    end
+
+    measurement 'The public/semipublic method should have an example specified' do
+      skip unless api?(%w[ public semipublic ]) && tag_types('return') != %w[ undefined ]
+      has_tag?('example')
+    end
+
+    measurement 'The @api tag should be specified' do
+      has_tag?('api')
+    end
+
+    measurement 'The @api tag must be either public, semipublic or private' do
+      %w[ public semipublic private ].include?(tag_text('api'))
+    end
+
+    measurement 'A method with public visibility must have an @api tag of public, semipublic or private' do
+      skip unless visibility == :public
+      api?(%w[ public semipublic private ])
+    end
+
+    measurement 'A method with protected visibility must have an @api tag of semipublic or private' do
+      skip unless visibility == :protected
+      api?(%w[ semipublic private ])
+    end
+
+    measurement 'A method with private visibility must have an @api tag of private' do
+      skip unless visibility == :private
+      api?(%w[ private ])
+    end
+
+    measurement 'The @return tag should be specified' do
+      has_tag?('return')
+    end
+
+  private
+
+    # The text for a specified tag
+    #
+    # @param [String] tag_name
+    #   the name of the tag
+    #
+    # @return [String, nil]
+    #   the tag text if the tag exists
+    #
+    # @api private
+    def tag_text(tag_name)
+      tag(tag_name).text if has_tag?(tag_name)
+    end
+
+    # The types for a specified tag
+    #
+    # @param [String] tag_name
+    #   the name of the tag
+    #
+    # @return [Array<String>, nil]
+    #   a collection of tag types if the tag exists
+    #
+    # @api private
+    def tag_types(tag_name)
+      tag(tag_name).types if has_tag?(tag_name)
+    end
+
+    # The method visibility: public, protected or private
+    #
+    # @return [Symbol]
+    #   the visibility of the method
+    #
+    # @api private
+    def visibility
+      object.visibility
+    end
+
+    # Check if the method API type matches
+    #
+    # @param [Array<String>] types
+    #   a collection of API types
+    #
+    # @return [Boolean]
+    #   true if the API type matches
+    #
+    # @api private
+    def api?(types)
+      types.include?(tag_text('api'))
+    end
+
+  end # module Method
+end # module Yardstick

data/lib/yardstick/processor.rb

@@ -0,0 +1,67 @@
+module Yardstick
+  class Processor
+
+    # Measure files provided
+    #
+    # @param [Array<#to_str>] files
+    #   the files to measure
+    #
+    # @return [Array<Measurement>]
+    #   a collection of measurements
+    #
+    # @api private
+    def self.process_files(files)
+      YARD.parse(Pathname.glob(files).map { |file| file.to_str })
+      measure_method_objects(method_objects)
+    end
+
+    # Measure string provided
+    #
+    # @param [#to_str] string
+    #   the string to measure
+    #
+    # @return [Array<Measurement>]
+    #   a collection of measurements
+    #
+    # @api private
+    def self.process_string(string)
+      YARD.parse_string(string.to_str)
+      measure_method_objects(method_objects)
+    end
+
+    # Return method objects in YARD registry
+    #
+    # @return [Array<YARD::CodeObjects::MethodObject>]
+    #   a collection of method objects
+    #
+    # @api private
+    def self.method_objects
+      YARD::Registry.all(:method).sort_by do |method_object|
+        [ method_object.file, method_object.line ]
+      end
+    ensure
+      YARD::Registry.clear
+    end
+
+    # Measure the method objects provided
+    #
+    # @param [Array<YARD::CodeObjects::MethodObject>] method_objects
+    #   a collection of method objects
+    #
+    # @return [Array<Measurement>]
+    #   a collection of measurements
+    #
+    # @api private
+    def self.measure_method_objects(method_objects)
+      method_objects.map do |method_object|
+        method_object.docstring.measure
+      end.flatten
+    end
+
+    class << self
+      private :method_objects
+      private :measure_method_objects
+    end
+
+  end # class Processor
+end # module Yardstick

data/lib/yardstick/yard_ext.rb

@@ -0,0 +1,25 @@
+module YARD  #:nodoc: all
+  module CodeObjects
+    class MethodObject
+
+      # Return the docstring associated with the method
+      #
+      # @example
+      #   method_object.docstring  # => YARD::Docstring instance
+      #
+      # @return [YARD::Docstring]
+      #   the docstring for this method
+      #
+      # @api public
+      def docstring
+        # TODO: update to use super() once reek does not flag it as
+        #   a utility method
+        @docstring.extend(Yardstick::Method)
+      end
+
+      # TODO: create an object to wrap tags, and extend each tag object with
+      # the matching module, if one exists under Yardstick::Tag::*
+
+    end # class MethodObject
+  end # module CodeObjects
+end # module YARD

data/lib/yardstick.rb

@@ -0,0 +1,52 @@
+require 'pathname'
+require 'yard'
+
+module Yardstick
+  VERSION = '0.0.1'.freeze
+  ROOT    = Pathname(__FILE__).dirname.parent.expand_path.freeze
+
+  # Measure a list of files
+  #
+  # @example
+  #   Yardstick.measure('article.rb')  # => [ Measurement ]
+  #
+  # @param [Array<#to_str>, #to_str] files
+  #   optional list of paths to measure
+  # @param [Hash] options
+  #   optional configuration
+  #
+  # @return [Array<Measurement>]
+  #   the measurements for each file
+  #
+  # @api public
+  def self.measure(files = 'lib/**/*.rb', options = {})
+    Yardstick::Processor.process_files(files)
+  end
+
+  # Measure a string of code and YARD documentation
+  #
+  # @example
+  #   string = "def my_method; end"
+  #
+  #   Yardstick.measure_string(string)  # => [ Measurement ]
+  #
+  # @param [#to_str] string
+  #   the string to measure
+  # @param [Hash] options
+  #   optional configuration
+  #
+  # @return [Array<Measurement>]
+  #   the measurements for the string
+  #
+  # @api public
+  def self.measure_string(string, options = {})
+    Yardstick::Processor.process_string(string)
+  end
+
+end # module Yardstick
+
+$LOAD_PATH << Yardstick::ROOT + 'lib'
+
+require 'yardstick/core_ext/object'
+require 'yardstick/yard_ext'
+require 'yardstick/autoload'

data/spec/public/yardstick/measurement_spec.rb

@@ -0,0 +1,196 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.join('..', '..', 'spec_helper')
+
+shared_examples_for 'measurement is successful' do
+  before :all do
+    @measurement = Yardstick::Measurement.new('successful', @docstring) { true }
+  end
+end
+
+shared_examples_for 'measurement is skipped' do
+  before :all do
+    @measurement = Yardstick::Measurement.new('skipped', @docstring) { skip }
+  end
+end
+
+shared_examples_for 'measurement is not successful' do
+  before :all do
+    @measurement = Yardstick::Measurement.new('not successful', @docstring) { false }
+  end
+end
+
+shared_examples_for 'measurement is not implemented' do
+  before :all do
+    @measurement = Yardstick::Measurement.new('not implemented', @docstring) { todo }
+  end
+end
+
+shared_examples_for 'measurement is warned' do
+  before :all do
+    $stderr = StringIO.new
+    @response = @measurement.warn
+    $stderr.rewind
+    @output = $stderr.read
+  end
+
+  it 'should return nil' do
+    @response.should be_nil
+  end
+end
+
+describe Yardstick::Measurement do
+  before :all do
+    YARD.parse_string('def test; end')
+    @docstring = YARD::Registry.all(:method).first.docstring
+  end
+
+  describe '.new' do
+    before :all do
+      @response = Yardstick::Measurement.new('test measurement', @docstring) { true }
+    end
+
+    it 'should return a Measurement' do
+      @response.should be_kind_of(Yardstick::Measurement)
+    end
+  end
+
+  describe '#ok?' do
+    describe 'when the measurement is successful' do
+      it_should_behave_like 'measurement is successful'
+
+      it 'should return true' do
+        @measurement.ok?.should be_true
+      end
+    end
+
+    describe 'when the measurement is skipped' do
+      it_should_behave_like 'measurement is skipped'
+
+      it 'should return true' do
+        @measurement.ok?.should be_true
+      end
+    end
+
+    describe 'when the measurement is not successful' do
+      it_should_behave_like 'measurement is not successful'
+
+      it 'should return false' do
+        @measurement.ok?.should be_false
+      end
+    end
+
+    describe 'when the measurement is not implemented' do
+      it_should_behave_like 'measurement is not implemented'
+
+      it 'should return false' do
+        @measurement.ok?.should be_false
+      end
+    end
+  end
+
+  describe '#skip?' do
+    describe 'when the measurement is successful' do
+      it_should_behave_like 'measurement is successful'
+
+      it 'should return false' do
+        @measurement.skip?.should be_false
+      end
+    end
+
+    describe 'when the measurement is skipped' do
+      it_should_behave_like 'measurement is skipped'
+
+      it 'should return true' do
+        @measurement.skip?.should be_true
+      end
+    end
+
+    describe 'when the measurement is not successful' do
+      it_should_behave_like 'measurement is not successful'
+
+      it 'should return false' do
+        @measurement.skip?.should be_false
+      end
+    end
+
+    describe 'when the measurement is not implemented' do
+      it_should_behave_like 'measurement is not implemented'
+
+      it 'should return false' do
+        @measurement.skip?.should be_false
+      end
+    end
+  end
+
+  describe '#todo?' do
+    describe 'when the measurement is successful' do
+      it_should_behave_like 'measurement is successful'
+
+      it 'should return false' do
+        @measurement.todo?.should be_false
+      end
+    end
+
+    describe 'when the measurement is skipped' do
+      it_should_behave_like 'measurement is skipped'
+
+      it 'should return false' do
+        @measurement.todo?.should be_false
+      end
+    end
+
+    describe 'when the measurement is not successful' do
+      it_should_behave_like 'measurement is not successful'
+
+      it 'should return false' do
+        @measurement.todo?.should be_false
+      end
+    end
+
+    describe 'when the measurement is not implemented' do
+      it_should_behave_like 'measurement is not implemented'
+
+      it 'should return true' do
+        @measurement.todo?.should be_true
+      end
+    end
+  end
+
+  describe '#warn' do
+    describe 'when the measurement is successful' do
+      it_should_behave_like 'measurement is successful'
+      it_should_behave_like 'measurement is warned'
+
+      it 'should not output a warning' do
+        @output.should == ''
+      end
+    end
+
+    describe 'when the measurement is skipped' do
+      it_should_behave_like 'measurement is skipped'
+      it_should_behave_like 'measurement is warned'
+
+      it 'should not output a warning' do
+        @output.should == ''
+      end
+    end
+
+    describe 'when the measurement is not successful' do
+      it_should_behave_like 'measurement is not successful'
+      it_should_behave_like 'measurement is warned'
+
+      it 'should output a warning' do
+        @output.should == "(stdin):1: #test: not successful\n"
+      end
+    end
+
+    describe 'when the measurement is not implemented' do
+      it_should_behave_like 'measurement is not implemented'
+      it_should_behave_like 'measurement is warned'
+
+      it 'should output a warning' do
+        @output.should == "(stdin):1: #test: not implemented\n"
+      end
+    end
+  end
+end

data/spec/public/yardstick/method_spec.rb

@@ -0,0 +1,6 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.join('..', '..', 'spec_helper')
+
+describe Yardstick::Method do
+  it 'should be awesome'
+end

data/spec/public/yardstick_spec.rb

@@ -0,0 +1,6 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.join('..', 'spec_helper')
+
+describe Yardstick do
+  it 'should be awesome'
+end

data/spec/rcov.opts

@@ -0,0 +1,2 @@
+--exclude "spec"
+--sort coverage

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--color
+--loadby random
+--format profile
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'spec'
+require 'pathname'
+
+dir = Pathname(__FILE__).dirname.expand_path
+
+$LOAD_PATH.unshift(dir)
+$LOAD_PATH.unshift(dir.parent + 'lib')
+
+require 'yardstick'
+
+Spec::Runner.configure do |config|
+end

data/tasks/metrics.rake

@@ -0,0 +1 @@
+require 'metric_fu'

data/tasks/rdoc.rake

@@ -0,0 +1,15 @@
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+  version = if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    ''
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "yardstick #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/tasks/spec.rake

@@ -0,0 +1,75 @@
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+spec_defaults = lambda do |spec|
+  spec.pattern    = 'spec/**/*_spec.rb'
+  spec.libs      << 'lib' << 'spec'
+  spec.spec_opts << '--options' << 'spec/spec.opts'
+end
+
+Spec::Rake::SpecTask.new(:spec, &spec_defaults)
+
+Spec::Rake::SpecTask.new(:rcov) do |rcov|
+  spec_defaults.call(rcov)
+  rcov.rcov       = true
+  rcov.rcov_opts << File.readlines('spec/rcov.opts').map { |line| line.strip }
+end
+
+RCov::VerifyTask.new(:verify_rcov => :rcov) do |rcov|
+  rcov.threshold = 94.73
+end
+
+# original code by Ashley Moran:
+# http://aviewfromafar.net/2007/11/1/rake-task-for-heckling-your-specs
+desc 'Heckle each module and class'
+task :heckle => :verify_rcov do
+  root_module = 'Yardstick'
+  spec_files  = FileList['spec/**/*_spec.rb']
+
+  current_module = nil
+  current_method = nil
+
+  heckle_caught_modules = Hash.new { |hash, key| hash[key] = [] }
+  unhandled_mutations = 0
+
+  IO.popen("spec --heckle #{root_module} #{spec_files}") do |pipe|
+    while line = pipe.gets
+      case line = line.chomp
+        when /\A\*\*\*\s+(#{root_module}(?:::)?(?:\w+(?:::)?)*)#(\w+)\b/
+          current_module, current_method = $1, $2
+        when "The following mutations didn't cause test failures:"
+          heckle_caught_modules[current_module] << current_method
+        when '+++ mutation'
+          unhandled_mutations += 1
+      end
+
+      puts line
+    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
+
+task :default => :spec

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: dkubb-yardstick
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Dan Kubb
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-22 00:00:00 -07:00
+default_executable: yardstick
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.2"
+    version: 
+description: 
+email: dan.kubb@gmail.com
+executables: 
+- yardstick
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/yardstick
+- lib/yardstick.rb
+- lib/yardstick/autoload.rb
+- lib/yardstick/cli.rb
+- lib/yardstick/core_ext/object.rb
+- lib/yardstick/measurable.rb
+- lib/yardstick/measurement.rb
+- lib/yardstick/method.rb
+- lib/yardstick/processor.rb
+- lib/yardstick/yard_ext.rb
+- spec/public/yardstick/measurement_spec.rb
+- spec/public/yardstick/method_spec.rb
+- spec/public/yardstick_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/metrics.rake
+- tasks/rdoc.rake
+- tasks/spec.rake
+has_rdoc: false
+homepage: http://github.com/dkubb/yardstick
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: yardstick
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: A tool for verifying YARD documentation coverage
+test_files: 
+- spec/public/yardstick/measurement_spec.rb
+- spec/public/yardstick/method_spec.rb
+- spec/public/yardstick_spec.rb
+- spec/spec_helper.rb