dkubb-yardstick 0.0.1 → 0.1.0

data/lib/yardstick/method.rb

@@ -2,57 +2,62 @@ module Yardstick
   module Method
     include Measurable
 
-    measurement 'The method summary should be specified' do
+    rule 'The method summary should be specified' do
       skip if has_tag?('see')
-      summary != ''
+      summary_text != ''
     end
 
-    measurement 'The method summary should be less than 80 characters in length' do
-      summary.length <= 78
+    rule 'The method summary should be less than 80 characters in length' do
+      summary_text.split(//).length <= 80
     end
 
-    measurement 'The method summary should be a single line' do
-      !summary.include?("\n")
+    rule 'The method summary should not end in a period' do
+      summary_text[-1, 1] != '.'
     end
 
-    measurement 'The method summary should not end in a period' do
-      summary[0, -1] != '.'
+    rule 'The method summary should be a single line' do
+      !summary_text.include?("\n")
     end
 
-    measurement 'The public/semipublic method should have an example specified' do
-      skip unless api?(%w[ public semipublic ]) && tag_types('return') != %w[ undefined ]
+    rule 'The public/semipublic method should have an example specified' do
+      skip if api?(%w[ private ]) || tag_types('return') == %w[ undefined ]
       has_tag?('example')
     end
 
-    measurement 'The @api tag should be specified' do
+    rule 'The @api tag should be specified' do
       has_tag?('api')
     end
 
-    measurement 'The @api tag must be either public, semipublic or private' do
+    rule '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
+    rule '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
+    rule '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
+    rule 'The @return tag should be specified' do
       has_tag?('return')
     end
 
   private
 
+    # The raw text for the summary
+    #
+    # @return [String]
+    #   the summary text
+    #
+    # @api private
+    def summary_text
+      split(/\r?\n\r?\n/).first || ''
+    end
+
     # The text for a specified tag
     #
     # @param [String] tag_name

data/lib/yardstick/ordered_set.rb

@@ -0,0 +1,112 @@
+module Yardstick
+  class OrderedSet
+    include Enumerable
+
+    # Returns the OrderedSet instance
+    #
+    # @param [Array] entries
+    #   optional entries
+    #
+    # @return [OrderedSet]
+    #   the ordered set instance
+    #
+    # @api private
+    def initialize(entries = nil)
+      @entries = []
+      @index   = {}
+      merge(entries) if entries
+    end
+
+    # Append to the OrderedSet
+    #
+    # @param [Object] entry
+    #   the object to append
+    #
+    # @return [OrderedSet]
+    #   returns self
+    #
+    # @api private
+    def <<(entry)
+      unless include?(entry)
+        @index[entry] = @entries.length
+        @entries << entry
+      end
+      self
+    end
+
+    # Merge in another OrderedSet
+    #
+    # @param [#each] other
+    #   the other ordered set
+    #
+    # @return [OrderedSet]
+    #   returns self
+    #
+    # @api private
+    def merge(other)
+      other.each { |entry| self << entry }
+      self
+    end
+
+    # Iterate over each entry
+    #
+    # @yield [entry]
+    #   yield to the entry
+    #
+    # @yieldparam [Object] entry
+    #   an entry in the ordered set
+    #
+    # @return [OrderedSet]
+    #   returns self
+    #
+    # @api private
+    def each(&block)
+      @entries.each(&block)
+      self
+    end
+
+    # Check if there are any entries
+    #
+    # @return [Boolean]
+    #   true if there are no entries, false if there are
+    #
+    # @api private
+    def empty?
+      @entries.empty?
+    end
+
+    # The number of entries
+    #
+    # @return [Integer]
+    #   number of entries
+    #
+    # @api private
+    def length
+      @entries.length
+    end
+
+    # Check if the entry exists in the set
+    #
+    # @return [Boolean]
+    #   true if the entry exists in the set, false if not
+    #
+    # @api private
+    def include?(entry)
+      @index.key?(entry)
+    end
+
+    # Return the index for the entry in the set
+    #
+    # @param [Object] entry
+    #   the entry to check the set for
+    #
+    # @return [Integer, nil]
+    #   the index for the entry, or nil if it does not exist
+    #
+    # @api private
+    def index(entry)
+      @index[entry]
+    end
+
+  end # class OrderedSet
+end # module Yardstick

data/lib/yardstick/processor.rb

@@ -3,16 +3,16 @@ module Yardstick
 
     # Measure files provided
     #
-    # @param [Array<#to_str>] files
+    # @param [Array<#to_s>, #to_s] path
     #   the files to measure
     #
-    # @return [Array<Measurement>]
+    # @return [MeasurementSet]
     #   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)
+    def self.process_path(path)
+      YARD.parse(Array(path).map { |file| file.to_s })
+      measurements
     end
 
     # Measure string provided
@@ -20,13 +20,27 @@ module Yardstick
     # @param [#to_str] string
     #   the string to measure
     #
-    # @return [Array<Measurement>]
+    # @return [MeasurementSet]
     #   a collection of measurements
     #
     # @api private
     def self.process_string(string)
       YARD.parse_string(string.to_str)
-      measure_method_objects(method_objects)
+      measurements
+    end
+
+    # Measure method objects in YARD registry
+    #
+    # @return [MeasurementSet]
+    #   a collection of measurements
+    #
+    # @api private
+    def self.measurements
+      measurements = MeasurementSet.new
+      method_objects.each do |method_object|
+        measurements.merge(method_object.docstring.measure)
+      end
+      measurements
     end
 
     # Return method objects in YARD registry
@@ -43,24 +57,8 @@ module Yardstick
       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
+      private :measurements, :method_objects
     end
 
   end # class Processor

data/lib/yardstick/rule.rb

@@ -0,0 +1,61 @@
+module Yardstick
+  class Rule
+
+    # Return a Rule instance
+    #
+    # @param [#to_str] description
+    #   the description of the Rule
+    #
+    # @yield []
+    #   the measurement for the rule
+    #
+    # @return [Rule]
+    #   the rule instance
+    #
+    # @api private
+    def initialize(description, &block)
+      @description = description.to_str
+      @block       = block
+    end
+
+    # Return a Measurement for a docstring
+    #
+    # @param [YARD::Docstring] docstring
+    #   the docstring to measure
+    #
+    # @return [Measurement]
+    #   the measurement
+    #
+    # @api private
+    def measure(docstring)
+      Measurement.new(@description, docstring, &@block)
+    end
+
+    # Test if Rule is equal to another rule
+    #
+    # @example
+    #   rule == equal_rule  # => true
+    #
+    # @param [Rule] other
+    #   the other Rule
+    #
+    # @return [Boolean]
+    #   true if the Rule is equal to the other, false if not
+    #
+    # @api semipublic
+    def eql?(other)
+      @description.eql?(other.instance_variable_get(:@description))
+    end
+
+    # Return hash identifier for the Rule
+    #
+    # @return [Integer]
+    #   the hash identifier
+    #
+    # @api private
+    def hash
+      @description.hash
+    end
+
+  end # class Rule
+end # module Yardstick

data/lib/yardstick/rule_set.rb

@@ -0,0 +1,18 @@
+module Yardstick
+  class RuleSet < OrderedSet
+
+    # Measure a docstring with all Rules
+    #
+    # @param [YARD::Docstring] docstring
+    #   the docstring to measure
+    #
+    # @return [MeasurementSet]
+    #   a collection of measurements
+    #
+    # @api private
+    def measure(docstring)
+      MeasurementSet.new(map { |rule| rule.measure(docstring) })
+    end
+
+  end # class RuleSet
+end # module Yardstick

data/spec/public/yardstick/cli_spec.rb

@@ -0,0 +1,108 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.join('..', '..', 'spec_helper')
+
+shared_examples_for 'displays help' do
+  it 'should display the help message' do
+    @output.should == <<-OUTPUT.gsub(/^\s{6}/, '')
+      Usage: #{OptionParser.new.program_name} [options]
+          -v, --version                    print version information and exit
+          -h, --help                       display this help and exit
+    OUTPUT
+  end
+end
+
+shared_examples_for 'displays version' do
+  it 'should display the program and version' do
+    @output.should == "#{OptionParser.new.program_name} 0.0.1\n"
+  end
+end
+
+shared_examples_for 'displays coverage summary' do
+  it 'should output the coverage summary' do
+    @output.should == "\nCoverage: 100.0%  Success: 20  Failed: 0  Total: 20\n"
+  end
+end
+
+describe Yardstick::CLI do
+  def capture_display(&block)
+    capture_stdout do
+      block.should raise_error(SystemExit)
+    end
+  end
+
+  describe '.run' do
+    describe 'with no arguments' do
+      before do
+        capture_display { Yardstick::CLI.run }
+      end
+
+      it_should_behave_like 'displays help'
+    end
+
+    %w[ -h --help ].each do |help_option|
+      describe "with #{help_option} option" do
+        before do
+          capture_display { Yardstick::CLI.run(help_option) }
+        end
+
+        it_should_behave_like 'displays help'
+      end
+    end
+
+    %w[ -v --version ].each do |version_option|
+      describe "with #{version_option} option" do
+        before do
+          capture_display { Yardstick::CLI.run(version_option) }
+        end
+
+        it_should_behave_like 'displays version'
+      end
+    end
+
+    describe 'with a String path' do
+      before :all do
+        @measurements = capture_stderr { Yardstick::CLI.run(Yardstick::ROOT.join('lib', 'yardstick.rb').to_s) }
+      end
+
+      it_should_behave_like 'measured itself'
+      it_should_behave_like 'displays coverage summary'
+    end
+
+    describe 'with a Pathname' do
+      before :all do
+        @measurements = capture_stderr { Yardstick::CLI.run(Yardstick::ROOT.join('lib', 'yardstick.rb')) }
+      end
+
+      it_should_behave_like 'measured itself'
+      it_should_behave_like 'displays coverage summary'
+    end
+
+    describe 'with an Array of String objects' do
+      before :all do
+        @measurements = capture_stderr { Yardstick::CLI.run(*[ Yardstick::ROOT.join('lib', 'yardstick.rb').to_s ]) }
+      end
+
+      it_should_behave_like 'measured itself'
+      it_should_behave_like 'displays coverage summary'
+    end
+
+    describe 'with an Array of Pathname objects' do
+      before :all do
+        @measurements = capture_stderr { Yardstick::CLI.run(*[ Yardstick::ROOT.join('lib', 'yardstick.rb') ]) }
+      end
+
+      it_should_behave_like 'measured itself'
+      it_should_behave_like 'displays coverage summary'
+    end
+
+    describe 'with invalid option' do
+      before do
+        capture_display { Yardstick::CLI.run('--invalid') }
+      end
+
+      it 'should display the invalid option message' do
+        @output.should == "invalid option: --invalid\n"
+      end
+    end
+  end
+end