fudge 0.0.5 → 0.1.0

data/lib/fudge/tasks/each_directory.rb

@@ -12,16 +12,10 @@ module Fudge
       end
 
       def run(options={})
-        # Allow either a string (usually "*") or an array of strings
-        # with directories
-        redir = @pattern.kind_of?(String) ? Dir[@pattern] : Dir[*@pattern]
-
-        redir.select { |path| File.directory? path }.each do |dir|
-          next if exclude && exclude.include?(dir)
-
-          Dir.chdir dir do
-            output_dir(dir)
-
+        output = options[:output] || $stdout
+        directories.each do |dir|
+          next if skip_directory?(dir)
+          WithDirectory.new(dir, output).inside do
             return false unless super
           end
         end
@@ -29,13 +23,17 @@ module Fudge
 
       private
 
-      def output_dir(dir)
-        message = ""
-        message << "--> In directory".foreground(:cyan)
-        message << " #{dir}:".foreground(:cyan).bright
+      def directories
+        # Allow either a string (usually "*") or an array of strings
+        # with directories
+        files = @pattern.kind_of?(String) ? Dir[@pattern] : Dir[*@pattern]
+        files.select { |path| File.directory? path }
+      end
 
-        puts message
+      def skip_directory?(dir)
+        exclude && exclude.include?(dir)
       end
+
     end
 
     register EachDirectory

data/lib/fudge/tasks/flay.rb

@@ -0,0 +1,64 @@
+module Fudge
+  module Tasks
+    # Allow use of Flay complexity analyser
+    #
+    #    task :flay
+    #
+    # runs flay with max score of 0
+    #
+    #    task :flay, :exclude => 'subpath/'
+    #
+    # excludes files matching :exclude from run
+    #
+    #    task :flay, :max => 20
+    #
+    # sets max score to 20
+    #
+    # Any and all options can be defined
+    #
+    class Flay < Shell
+      include Helpers::BundleAware
+
+      private
+
+      def cmd(options={})
+        bundle_cmd(flay_ruby_files, options)
+      end
+
+      def flay_ruby_files
+        finder = FileFinder.new(options)
+        finder.generate_command("flay", tty_options)
+      end
+
+      def check_for
+        [check_regex, method(:flay_checker)]
+      end
+
+      def check_regex
+        /Total score \(lower is better\) = (?<score>\d+)/
+      end
+
+      def flay_checker(matches)
+        score = matches[:score].to_i
+        if score > max_score
+          "Duplication Score Higher Than #{max_score}"
+        else
+          true
+        end
+      end
+
+      def max_score
+        options.fetch(:max, 0)
+      end
+
+      def tty_options
+        opts = []
+        opts << "--diff"
+        opts
+      end
+
+    end
+
+    register Flay
+  end
+end

data/lib/fudge/tasks/flog.rb

@@ -0,0 +1,89 @@
+module Fudge
+  module Tasks
+    # Allow use of Flog complexity analyser
+    #
+    #    task :flog
+    #
+    # runs flog with max score of 10.0 for a method, 5.0 average
+    #
+    #    task :flog, :exclude => 'subpath/'
+    #
+    # excludes files matching :exclude from run
+    #
+    #    task :flog, :max => 20.0
+    #
+    # sets max score for a method to 20.0
+    #
+    #    task :flog, :average => 10.0
+    #
+    # sets required average to 10.0
+    #
+    #    task :flog, :methods => true
+    #
+    # runs only scoring methods, not classes macros etc
+    #
+    # Any and all options can be defined
+    #
+    class Flog < Shell
+      include Helpers::BundleAware
+
+      private
+
+      def cmd(options={})
+        bundle_cmd(flog_ruby_files, options)
+      end
+
+      def flog_ruby_files
+        finder = FileFinder.new(options)
+        finder.generate_command("flog", tty_options)
+      end
+
+      def check_for
+        [check_regex, method(:flog_checker)]
+      end
+
+      def check_regex
+        /^\s*(?<score>\d+.\d+): (?<type>.*)$/
+      end
+
+      def flog_checker(matches)
+        average, max = extract_scores(matches)
+        if average > average_required
+          "Average Complexity Higher Than #{average_required}"
+        elsif max > max_score
+          "Maximum Complexity Higher Than #{max_score}"
+        else
+          true
+        end
+      end
+
+      def average_required
+        options.fetch(:average, 5.0).to_f
+      end
+
+      def max_score
+        options.fetch(:max, 10.0).to_f
+      end
+
+      def extract_scores(matches)
+        lines = extract_lines(matches)
+        _, average, max, _ = lines
+        [average.first.to_f, max.first.to_f]
+      end
+
+      def extract_lines(matches)
+        output = matches.string
+        output.scan(check_regex)
+      end
+
+      def tty_options
+        opts = []
+        opts << "-m" if options[:methods]
+        opts
+      end
+
+    end
+
+    register Flog
+  end
+end

data/lib/fudge/tasks/in_directory.rb

@@ -10,22 +10,11 @@ module Fudge
       end
 
       def run(options={})
-        Dir.chdir @directory do
-          output_dir(@directory)
-
+        output = options[:output] || $stdout
+        WithDirectory.new(@directory, output).inside do
           super
         end
       end
-
-      private
-
-      def output_dir(dir)
-        message = ""
-        message << "--> In directory".foreground(:cyan)
-        message << " #{dir}:".foreground(:cyan).bright
-
-        puts message
-      end
     end
 
     register InDirectory

data/lib/fudge/tasks/rspec.rb

@@ -19,6 +19,10 @@ module Fudge
         /((\d+\.\d+)%\) covered)/
       end
 
+      def check_regex
+        Regexp.union(coverage_regex, pre_conditions_regex)
+      end
+
       def cmd(options={})
         self.arguments = 'spec/' if arguments.blank?
         bundle_cmd("rspec#{tty_options} #{arguments}", options)
@@ -30,11 +34,7 @@ module Fudge
 
       def check_for
         if coverage
-          rs1 = coverage_regex.source
-          rs2 = pre_conditions_regex.source
-          regex = Regexp.new(rs1 + '|' + rs2)
-
-          [regex, method(:coverage_checker)]
+          [check_regex, method(:coverage_checker)]
         else
           super
         end

data/lib/fudge/tasks/shell.rb

@@ -12,58 +12,31 @@ module Fudge
       #
       # @param [Hash] options Any options to pass to the shell
       def run(options={})
-        @output, success = run_command(cmd(options))
+        output_io = options[:output] || $stdout
+        @output, success = run_command(cmd(options), output_io)
 
         return false unless success
-        return check_for_output
+        return check_for_output(output_io)
       end
 
       private
 
-      def run_command(cmd)
+      def run_command(cmd, output_io)
         output = ''
         IO.popen(cmd) do |f|
           until f.eof?
             bit = f.getc
             output << bit
-            putc bit
+            output_io.putc bit
           end
         end
 
         [output, $?.success?]
       end
 
-      def check_for_output
-        return true unless check_for # We're ok if no output defined
-
-        # Check if we have a callable to parse the regex matches
-        if check_for.is_a? Enumerable
-          regex, pass_if = check_for[0], check_for[1]
-        else
-          regex, pass_if = check_for, nil
-        end
-
-        # Do regex match and fail if no match
-        match = @output.match(regex)
-        unless match
-          puts "Output didn't match #{regex}."
-          return false
-        end
-
-        # If we've got a callable, call it to check on regex matches
-        if pass_if
-          passed = pass_if.call(match)
-          unless passed == true
-            if passed.is_a? String
-              puts passed
-            else
-              puts "Output matched #{check_for} but condition failed."
-            end
-            return false
-          end
-        end
-
-        true
+      def check_for_output(output_io)
+        checker = OutputChecker.new(check_for, output_io)
+        checker.check(@output)
       end
 
       # Defines the command to run

data/lib/fudge/version.rb

@@ -1,4 +1,4 @@
 module Fudge
   # Define gem version
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/lib/fudge/with_directory.rb

@@ -0,0 +1,27 @@
+#Directory helpers methods
+class Fudge::WithDirectory
+  attr_reader :dir, :output
+
+  def initialize(dir, output)
+    @dir = dir
+    @output = output
+  end
+
+  # Executes a block inside the directory
+  def inside
+    Dir.chdir(dir) do
+      output_message
+      yield
+    end
+  end
+
+  private
+
+  def output_message
+    message = ""
+    message << "--> In directory".foreground(:cyan)
+    message << " #{dir}:".foreground(:cyan).bright
+
+    output.puts message
+  end
+end

data/spec/lib/fudge/build_spec.rb

@@ -2,4 +2,32 @@ require 'spec_helper'
 
 describe Fudge::Build do
   it { should be_a Fudge::Tasks::CompositeTask }
+
+  describe "#run" do
+
+    context "when provided an output" do
+      let(:output) { StringIO.new }
+
+      it "prints messages to the output instead of stdout" do
+        subject.run :output => output
+
+        output.string.should_not be_empty
+        output.string.should include "Skipping callbacks..."
+      end
+
+      context "when there are callback hooks" do
+        let(:hook) { mock(:Hook) }
+
+        before :each do
+          subject.callbacks = true
+          subject.success_hooks << hook
+        end
+
+        it "passes output down to the hook run" do
+          hook.should_receive(:run).with(:output => output).and_return(true)
+          subject.run :output => output
+        end
+      end
+    end
+  end
 end

data/spec/lib/fudge/output_checker_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Fudge::OutputChecker do
+  let (:output_io) { StringIO.new }
+
+  describe "#check" do
+    subject { described_class.new /foo/, output_io }
+
+    context "when the output does not match the check" do
+       it 'send a mismatch message to the output io' do
+          subject.check('bar')
+          output_io.string.should include "Output didn't match (?-mix:foo)."
+       end
+    end
+
+    context "with a block for checking" do
+      let(:callable) do
+        Proc.new do
+          false
+        end
+      end
+      subject { described_class.new [/foo/, callable], output_io }
+
+      it 'sends error mesage to the output io' do
+        subject.check('foo')
+
+        output_io.string.should include "Output matched (?-mix:foo) but condition failed."
+      end
+    end
+  end
+end

data/spec/lib/fudge/runner_spec.rb

@@ -21,5 +21,24 @@ describe Fudge::Runner do
 
       expect { subject.run_build }.to raise_error Fudge::Exceptions::BuildFailed
     end
+
+    context "when an output is provided" do
+      let(:output) { StringIO.new }
+
+      before :each do
+        subject.run_build 'default', :output => output
+      end
+
+      it "puts all output to given output instead stdout" do
+        output.string.should_not be_empty
+        output.string.should include "Running build"
+        output.string.should include "default"
+        output.string.should include "Build SUCCEEDED!"
+      end
+
+      it "runs the task passing the output down" do
+        DummyTask.run_options.should == {:output => output}
+      end
+    end
   end
 end

data/spec/lib/fudge/tasks/bundler_spec.rb

@@ -11,6 +11,7 @@ class TestBundlerAwareTask
 end
 
 class TestNonBundlerAwareTask
+
   def self.name
     :test_non_bundle_aware
   end
@@ -34,6 +35,13 @@ describe Fudge::Tasks::CleanBundlerEnv do
 
         subject.run.should be_true
       end
+
+      it "runs each task with a clean bundle env" do
+        Bundler.should_receive(:with_clean_env).and_call_original
+
+        subject.tasks << bundle_aware_task
+        subject.run.should be_true
+      end
     end
   end
 end