fudge 0.0.1

data/lib/fudge/tasks/rake.rb

@@ -0,0 +1,19 @@
+module Fudge
+  module Tasks
+    class Rake < Shell
+      include Helpers::BundleAware
+
+      def self.name
+        :rake
+      end
+
+      private
+
+      def cmd(options={})
+        bundle_cmd("rake #{arguments}", options)
+      end
+    end
+
+    register Rake
+  end
+end

data/lib/fudge/tasks/rspec.rb

@@ -0,0 +1,29 @@
+module Fudge
+  module Tasks
+    class Rspec < Shell
+      include Helpers::BundleAware
+
+      attr_accessor :color, :coverage
+
+      def self.name
+        :rspec
+      end
+
+      private
+      def cmd(options={})
+        self.arguments = 'spec/' if arguments.blank?
+        bundle_cmd("rspec#{' --tty' unless color == false} #{arguments}", options)
+      end
+
+      def check_for
+        if coverage
+          [/(\d+\.\d+)%\) covered/, lambda { |matches| matches[1].to_f >= coverage ? true : 'Insufficient Coverage.' }]
+        else
+          super
+        end
+      end
+    end
+
+    register Rspec
+  end
+end

data/lib/fudge/tasks/shell.rb

@@ -0,0 +1,76 @@
+module Fudge
+  module Tasks
+    class Shell < Task
+      attr_accessor :arguments, :check_for
+
+      def self.name
+        :shell
+      end
+
+      def initialize(*args)
+        self.arguments = super.join(' ')
+      end
+
+      def run(options={})
+        @output, success = run_command(cmd(options))
+        return false unless success
+        return check_for_output
+      end
+
+      private
+
+      def run_command(cmd)
+        output = ''
+        IO.popen(cmd) do |f|
+          until f.eof?
+            bit = f.getc
+            output << bit
+            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
+      end
+
+      # Defines the command to run
+      def cmd(options={})
+        arguments
+      end
+    end
+
+    register Shell
+  end
+end

data/lib/fudge/tasks/task.rb

@@ -0,0 +1,18 @@
+module Fudge
+  module Tasks
+    class Task
+      attr_reader :args
+
+      def initialize(*args)
+        @args = args.dup
+        options = args.extract_options!
+
+        options.each do |k,v|
+          send("#{k}=", v) if respond_to?("#{k}=")
+        end
+
+        args
+      end
+    end
+  end
+end

data/lib/fudge/tasks/yard.rb

@@ -0,0 +1,29 @@
+module Fudge
+  module Tasks
+    class Yard < Shell
+      include Helpers::BundleAware
+
+      attr_accessor :coverage
+
+      def self.name
+        :yard
+      end
+
+      private
+
+      def cmd(options={})
+        bundle_cmd("yard #{arguments}", options)
+      end
+
+      def check_for
+        if coverage
+          [/(\d+\.\d+)% documented/, lambda { |matches| matches[1].to_f >= coverage ? true : 'Insufficient Documentation.' }]
+        else
+          super
+        end
+      end
+    end
+
+    register Yard
+  end
+end

data/lib/fudge/version.rb

@@ -0,0 +1,3 @@
+module Fudge
+  VERSION = "0.0.1"
+end

data/lib/tasks/fudge.rake

@@ -0,0 +1,7 @@
+
+namespace :fudge do
+  desc "Run the build with Fudge"
+  task :fudge do
+    `fudge build`
+  end
+end

data/spec/lib/fudge/build_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Fudge::Build do
+  it { should be_a Fudge::Tasks::CompositeTask }
+end

data/spec/lib/fudge/cli_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+class AnotherDummyTask < DummyTask
+  def self.name
+    :another_dummy
+  end
+
+  def run(options={})
+    self.class.ran = true
+  end
+end
+Fudge::Tasks.register(AnotherDummyTask)
+
+describe Fudge::Cli do
+  use_tmp_dir
+
+  after :each do
+    AnotherDummyTask.ran = false
+  end
+
+  describe :build do
+    before :each do
+      File.open('Fudgefile', 'w') do |f|
+        contents = <<-RUBY
+          build :default do
+            dummy
+          end
+
+          build :other do
+            another_dummy
+          end
+        RUBY
+        f.write(contents)
+      end
+    end
+
+    it "should run the default build" do
+      subject.build 'default'
+      DummyTask.ran.should be_true
+    end
+
+    it "should accept a build name to run" do
+      subject.build 'other'
+      DummyTask.ran.should be_false
+      AnotherDummyTask.ran.should be_true
+    end
+  end
+
+  describe :init do
+    it "should create a new FudgeFile in the current directory" do
+      File.should_not be_exists('Fudgefile')
+
+      subject.init
+
+      File.should be_exists('Fudgefile')
+    end
+
+    it "should contain a default build" do
+      subject.init
+
+      File.open('Fudgefile', 'r') do |f|
+        f.read.should include "build :default do\n  task :rspec\nend"
+      end
+    end
+
+    it "should not modify the Fudgefile if one exists" do
+      File.open('Fudgefile', 'w') do |f|
+        f.write('foo')
+      end
+
+      subject.init
+
+      File.open('Fudgefile') { |f| f.read }.should == 'foo'
+    end
+  end
+end

data/spec/lib/fudge/description_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+
+describe Fudge::Description do
+  let(:build) { subject.builds.values.first }
+  let(:build_tasks) { build.tasks.map }
+
+  def make_build
+    subject.build :default do
+      subject.task :dummy
+      yield
+    end
+    build.callbacks = callbacks
+  end
+
+  let(:input) { '' }
+  let(:file) { StringIO.new(input).tap { |s| s.stub(:path).and_return('') } }
+  subject { described_class.new file }
+
+  describe :initialize do
+    let(:input) { 'build :foo do; end' }
+
+    it "should add the builds in the given string" do
+      subject.builds[:foo].should be_a Fudge::Build
+    end
+  end
+
+  describe :build do
+    it "should create a new build and add it to the builds array" do
+      subject.builds.should be_empty
+
+      subject.build :some_branch do
+      end
+
+      subject.builds.should have(1).item
+      subject.builds[:some_branch].should be_a Fudge::Build
+    end
+  end
+
+  describe :task do
+    it "should add a task to the current scope" do
+      subject.build :default do
+        subject.task :dummy
+      end
+
+      build_tasks.should have(1).item
+      build_tasks.first.should be_a DummyTask
+    end
+
+    it "should pass arguments to the initializer" do
+      subject.build :default do
+        subject.task :dummy, :foo, :bar
+      end
+
+      build_tasks.first.args.should == [:foo, :bar]
+    end
+
+    it "should forward missing methods to task" do
+      subject.build :default do
+        subject.dummy :foo, :bar
+      end
+
+      build_tasks.first.args.should == [:foo, :bar]
+    end
+
+    it "should super method_missing if no task found" do
+      expect { subject.non_existeng_task :foo, :bar }.to raise_error(NoMethodError)
+    end
+
+    it "should add tasks recursively to composite tasks" do
+      subject.build :default do
+        subject.dummy_composite do
+          subject.dummy
+        end
+      end
+
+      build_tasks.first.tasks.first.should be_a DummyTask
+    end
+  end
+
+  describe :task_group do
+    it "should add a task group and allow it to be used in a build" do
+      subject.task_group :group1 do
+        subject.task :dummy
+      end
+
+      subject.build :default do
+        subject.task_group :group1
+      end
+
+      subject.builds[:default].run
+      DummyTask.ran.should be_true
+    end
+
+    it "should allow passing arguments to task groups" do
+      subject.task_group :special_group do |which|
+        subject.task which
+      end
+
+      subject.build :default do
+        subject.task_group :special_group, :dummy
+      end
+
+      subject.builds[:default].run
+      DummyTask.ran.should be_true
+    end
+
+    it "should raise an exception if task group not found" do
+      expect do
+        subject.build :default do
+          subject.task_group :unkown_group
+        end
+      end.to raise_error Fudge::Exceptions::TaskGroupNotFound
+    end
+
+    it "should allow the use of task groups through nested layers of composite tasks" do
+      subject.task_group :group1 do
+        subject.task :dummy
+      end
+
+      subject.build :default do
+        subject.task :dummy_composite do
+          subject.task_group :group1
+        end
+      end
+
+      subject.builds[:default].run
+      DummyTask.ran.should be_true
+    end
+
+    it "should allow the use of task groups through nested layers of composite nodes when options are given" do
+      subject.task_group :group1 do
+        subject.task :dummy
+      end
+
+      subject.build :default do
+        subject.task :dummy_composite, :hello, :foobar => true do
+          subject.task_group :group1
+        end
+      end
+
+      subject.builds[:default].run
+
+      # Check that the options are maintained through the call
+      build_tasks.first.args.should have(2).items
+      build_tasks.first.args[1][:foobar].should be_true
+      DummyTask.ran.should be_true
+    end
+  end
+
+  describe "Callback Hooks" do
+    before :each do
+      @ran = []
+      Fudge::Tasks::Shell.any_instance.stub(:run_command) do |cmd|
+        @ran << cmd
+        ['', cmd != 'fail']
+      end
+    end
+
+    describe :on_success do
+      context "when callbacks is set to true" do
+        let(:callbacks) { true }
+
+        it "should add success hooks that run after the build is successful" do
+          make_build do
+            subject.on_success { subject.shell 'FOO' }
+            subject.on_success { subject.shell 'BAR' }
+          end
+
+          build.run.should be_true
+          @ran.should == ['FOO', 'BAR']
+        end
+
+        it "should fail the build and stop running callbacks if any of the success hooks fail" do
+          make_build do
+            subject.on_success { subject.shell 'fail'; subject.shell 'FOO' }
+            subject.on_success { subject.shell 'BAR' }
+          end
+
+          build.run.should be_false
+          @ran.should == ['fail']
+        end
+      end
+
+      context "when callbacks is set to false" do
+        let(:callbacks) { false }
+
+        it "should not run the callbacks if the build succeeds" do
+          make_build do
+            subject.on_success { subject.shell 'echo "WOOP"' }
+          end
+
+          build.run.should be_true
+          @ran.should == []
+        end
+      end
+    end
+
+    describe :on_failure do
+      before :each do
+        DummyTask.any_instance.stub(:run).and_return(false)
+      end
+
+      context "when callbacks is set to true" do
+        let(:callbacks) { true }
+
+        it "should add failure hooks that run after the build fails" do
+          make_build do
+            subject.on_failure { subject.shell 'WOOP' }
+            subject.on_failure { subject.shell 'BAR' }
+          end
+
+          build.run.should be_false
+          @ran.should == ['WOOP', 'BAR']
+        end
+
+        it "should fail the build and stop running callbacks if any of the failure hooks fail" do
+          make_build do
+            subject.on_failure { subject.shell 'fail'; subject.shell 'FOO' }
+            subject.on_failure { subject.shell 'BAR' }
+          end
+
+          build.run.should be_false
+          @ran.should == ['fail']
+        end
+      end
+
+      context "when callbacks is set to false" do
+        let(:callbacks) { false }
+
+        it "should not run the callbacks if the build fails" do
+          make_build do
+            subject.on_failure { subject.shell 'WOOP' }
+          end
+
+          build.run.should be_false
+          @ran.should == []
+        end
+      end
+    end
+  end
+end