gator 0.0.21.pre → 0.0.22.pre

data/rake/pre_release_to_git.rb

@@ -0,0 +1,59 @@
+class Jeweler
+  module Commands
+    class PreReleaseToGit
+      attr_accessor :gemspec, :version, :repo, :output, :gemspec_helper, :base_dir
+
+      def initialize(attributes = {})
+        self.output = $stdout
+
+        attributes.each_pair do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      def run
+        unless clean_staging_area?
+          system "git status"
+          raise "Unclean staging area! Be sure to commit or .gitignore everything first. See `git status` above."
+        end
+
+        repo.checkout('develop')
+        repo.push
+
+        if release_not_tagged?
+          output.puts "Tagging #{release_tag}"
+          repo.add_tag(release_tag)
+
+          output.puts "Pushing #{release_tag} to origin"
+          repo.push('origin', release_tag)
+        end
+      end
+
+      def clean_staging_area?
+        `git ls-files --deleted --modified --others --exclude-standard` == ""
+      end
+
+      def release_tag
+        "v#{version}"
+      end
+
+      def release_not_tagged?
+        tag = repo.tag(release_tag) rescue nil
+        tag.nil?
+      end
+
+      def self.build_for(jeweler)
+        command = self.new
+
+        command.base_dir = jeweler.base_dir
+        command.gemspec = jeweler.gemspec
+        command.version = jeweler.version
+        command.repo = jeweler.repo
+        command.output = jeweler.output
+        command.gemspec_helper = jeweler.gemspec_helper
+
+        command
+      end
+    end
+  end
+end

data/spec/core/application/application_configuration_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Gator::ApplicationConfiguration do
+
+  before :each do
+    @app_config = Gator::ApplicationConfiguration.new
+  end
+
+  it "should have a project configuration" do
+    @app_config.project.should be_a_kind_of Gator::Project
+  end
+
+  it "should have an environment configuration" do
+    @app_config.environment.should be_a_kind_of Gator::Configuration
+  end
+
+  it "should have an env shortcut to environment" do
+    @app_config.env.should equal @app_config.environment
+  end
+
+end

data/spec/core/application/application_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Gator::Application do
+
+  before :each do
+    @app = Gator::Application.new
+  end
+
+  it "should print the correct version" do
+    version =  File.read( File.dirname(__FILE__) + '/../../../VERSION' )
+    @app.should_receive(:say).with(version)
+    @app.version
+  end
+
+end

data/spec/core/command/command_spec.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Gator::Command do
+
+  before :all do
+
+    class CommandA < Gator::Command
+      define :command => "CommandA", :short => "CA",
+             :usage => "CommandA is useless", :description => "CommandA doesn't need a description"
+    end
+
+    class CommandB < Gator::Command
+      define :command => "CommandB", :short => "CB",
+             :usage => "CommandB is useless", :description => "CommandB doesn't need a description"
+    end
+
+    class CommandC < Gator::Command
+      define :command => "CommandC", :short => "CC",
+             :usage => "CommandC is useless", :description => "CommandC doesn't need a description"
+    end
+
+    class CommandD < Gator::Command
+      define :command => "CommandD", :short => "CD",
+             :usage => "CommandD is useless", :description => "CommandD doesn't need a description"
+    end
+
+    CommandA << CommandB
+    CommandA << CommandC
+    CommandC << CommandD
+
+  end
+
+  after :all do
+
+    remove_const CommandA
+    puts "commandA: #{CommandA}"
+    remove_const CommandB
+    remove_const CommandC
+    remove_const CommandD
+
+  end
+
+
+  describe "ClassMethods" do
+
+    it "should provide the correct subcommands" do
+      CommandA.get_subcommand("CommandB").should equal CommandB
+      CommandA.get_subcommand("CommandC").should equal CommandC
+    end
+
+    it "should provide the correct nested subcommands" do
+      CommandA.get_subcommand("CommandC", "CommandD").should equal CommandD
+    end
+
+    it "should return nil if a command cannot be found" do
+      CommandA.get_subcommand("CommandZ").should_not be
+    end
+
+    it "should resolve the correct subcommand on a parent" do
+      CommandB.resolve_subcommand(["CommandA"]).should == CommandA
+    end
+
+    it "should resolve the correct nested subcommand on a parent" do
+      CommandD.resolve_subcommand(["CommandA", "CommandB"]).should == CommandB
+    end
+
+    it "should fall back to CommandB" do
+      CommandC.resolve_subcommand(["CommandA", "CommandD"], ["CommandA", "CommandB"]).should == CommandB
+    end
+
+    it "should return nil if a command cannot be resolved" do
+      CommandC.resolve_subcommand("d").should == nil
+    end
+
+  end
+
+  describe "InstanceMethods" do
+
+    before :each do
+      @command_a = CommandA.new
+      @command_b = CommandB.new
+      @command_c = CommandC.new
+      @command_d = CommandD.new
+    end
+
+     it "should provide the correct subcommands" do
+      @command_a.get_subcommand("CommandB").should equal CommandB
+      @command_a.get_subcommand("CommandC").should equal CommandC
+    end
+
+    it "should provide the correct nested subcommands" do
+      @command_a.get_subcommand("CommandC", "CommandD").should equal CommandD
+    end
+
+    it "should return nil if a command cannot be found" do
+      @command_a.get_subcommand("CommandZ").should_not be
+    end
+
+    it "should resolve the correct subcommand on a parent" do
+      @command_a.resolve_subcommand(["CommandA"]).should == CommandA
+    end
+
+    it "should resolve the correct nested subcommand on a parent" do
+      @command_d.resolve_subcommand(["CommandA", "CommandB"]).should == CommandB
+    end
+
+    it "should fall back to CommandB" do
+      @command_c.resolve_subcommand(["CommandA", "CommandD"], ["CommandA", "CommandB"]).should == CommandB
+    end
+
+    it "should return nil if a command cannot be resolved" do
+      @command_c.resolve_subcommand("d").should == nil
+    end
+
+  end
+
+end

data/spec/core/command/task_spec.rb

@@ -0,0 +1,95 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Gator::Task do
+
+  before :all do
+
+    class TaskWithoutParent < Gator::Task
+      define :command => "TaskWithoutParent", :short => "TWOP",
+             :usage => "TaskWithoutParent is useless", :description => "TaskWithoutParent doesn't need a description"
+    end
+
+    class TaskWithParent < Gator::Task
+      define :command => "TaskWithParent", :short => "TWP",
+             :usage => "TaskWithParent is useless", :description => "TaskWithParent doesn't need a description"
+    end
+
+    class TaskContainer < Gator::Command
+      define :command => "TaskContainer", :short => "TC",
+             :usage => "TaskContainer is useless", :description => "TaskContainer doesn't need a description"
+
+      register_subcommand TaskWithParent
+    end
+
+  end
+
+  after :all do
+    remove_const TaskWithoutParent
+    remove_const TaskWithParent
+    remove_const TaskContainer
+  end
+
+  describe "ClassMethods" do
+
+    it "should return the correct definition" do
+      TaskWithoutParent.definition[:command].should == "TaskWithoutParent"
+      TaskWithoutParent.definition[:short].should == "TWOP"
+      TaskWithoutParent.definition[:usage].should == "TaskWithoutParent is useless"
+      TaskWithoutParent.definition[:description].should == "TaskWithoutParent doesn't need a description"
+    end
+
+    it "should return the correct parent command" do
+      TaskWithParent.parent.should equal TaskContainer
+    end
+
+    it "should return nil when it does not have a parent command" do
+      TaskWithoutParent.parent.should_not be
+    end
+
+  end
+
+  describe "InstanceMethods" do
+
+    before :each do
+      @task_with_parent = TaskWithParent.new
+      @task_without_parent = TaskWithoutParent.new
+    end
+
+    it "should return the correct definition" do
+      @task_without_parent.definition[:command].should == "TaskWithoutParent"
+      @task_without_parent.definition[:short].should == "TWOP"
+      @task_without_parent.definition[:usage].should == "TaskWithoutParent is useless"
+      @task_without_parent.definition[:description].should == "TaskWithoutParent doesn't need a description"
+    end
+
+    it "should return the correct parent command" do
+      @task_with_parent.parent.should equal TaskContainer
+    end
+
+    it "should return nil when it does not have a parent command" do
+      @task_without_parent.parent.should_not be
+    end
+
+    it "should return nil for requests to subcommands" do
+      @task_with_parent.get_subcommand.should_not be
+    end
+
+    it "should return nil for requests to resolve subcommands when it does not have a parent" do
+      @task_without_parent.resolve_subcommand("test").should_not be
+    end
+
+    it "should return nil for requests to resolve subcommands with a wrong command name" do
+      @task_with_parent.resolve_subcommand("TaskContainer_").should_not be
+    end
+
+    it "should return the parent task for requests with the parents command name" do
+      @task_with_parent.resolve_subcommand( [@task_with_parent.parent.definition[:command]] ).should equal @task_with_parent.parent
+    end
+
+    it "should return its class for requests with the its command name" do
+      @task_with_parent.resolve_subcommand( [@task_with_parent.definition[:command]] ).should equal @task_with_parent.class
+    end
+
+  end
+
+end

data/spec/core/configuration/configuration_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Gator::Configuration do
+
+  before :all do
+    class ConcreteConfiguration < Gator::Configuration
+    end
+  end
+
+  after :all do
+    remove_const ConcreteConfiguration
+  end
+
+  before :each do
+    @configuration = ConcreteConfiguration.new
+  end
+
+  it "should add a property getter" do
+    @configuration.add_configuration :my_prop
+    @configuration.should respond_to "my_prop"
+  end
+
+  it "should add a property setter" do
+    @configuration.add_configuration :my_prop
+    @configuration.should respond_to "my_prop="
+  end
+
+  it "should set and get a property via its setter" do
+    a = {}
+    @configuration.add_configuration :a
+    @configuration.a= a
+    @configuration.a.should eql(a)
+  end
+
+  it "should add a value" do
+    a = {}
+    @configuration.add_configuration :my_prop, a
+    @configuration.my_prop.should eql(a)
+  end
+
+  it "should yield around a property" do
+    a = {}
+    @configuration.add_configuration :my_prop, a
+    @configuration.my_prop do |property|
+      property.should eql(a)
+    end
+  end
+
+  it "should add a getter with a value" do
+    a = {}
+    @configuration.add_getter :my_getter, a
+    @configuration.my_getter.should equal a
+  end
+
+end

data/spec/core/io/paths_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+
+describe Gator::Paths do
+
+  before :all do
+    @original_pwd = Dir.pwd
+    @empty_project = File.expand_path(File.dirname(__FILE__) + '/../../fixtures/empty_gator_project')
+    @not_a_project = File.expand_path(File.dirname(__FILE__) + '/../../fixtures/no_gator_file')
+  end
+
+  after :all do
+    Dir.chdir @original_pwd
+  end
+
+  it "should point to the correct gator home in the users directory" do
+    Gator::Paths.gator_home.should == File.join(Thor::Util.user_home,".gator")
+  end
+
+  it "should point to the correct project base directory" do
+    Dir.chdir @empty_project
+    Gator::Paths.project_home.should == @empty_project
+  end
+
+  it "should point to the correct environment file" do
+    Gator::Paths.env_file == File.join( Gator::Paths.gator_home, "environment.rb" )
+  end
+
+  it "should return nil for project base directory when not in a project directory" do
+    Dir.chdir @not_a_project
+    Gator::Paths.project_home.should_not be
+  end
+
+  it "should point to the correct project file" do
+    Dir.chdir @empty_project
+    Gator::Paths.project_file.should == File.join(@empty_project,"gator.rb")
+  end
+
+  it "should return nil for project file when not in a project directory" do
+    Dir.chdir @not_a_project
+    Gator::Paths.project_file.should_not be
+  end
+
+end

data/spec/core/io/sandbox_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+
+describe Gator::Sandbox do
+
+  it "should add a getter for a value" do
+    Gator::Sandbox.add_getter :my_getter, "MyValue"
+    Gator::Sandbox.my_getter.should == "MyValue"
+  end
+
+end

data/spec/core/project/layout_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Gator::Layout do
+
+  before :each do
+    @layout = Gator::Layout.new
+  end
+
+  it 'should expand empty to itself' do
+    @layout.expand.should eql('')
+    @layout.expand('').should eql('')
+  end
+
+  it 'should expand array of symbols' do
+    @layout.expand(:foo, :bar).should eql('foo/bar')
+  end
+
+  it 'should expand array of names' do
+    @layout.expand('foo', 'bar').should eql('foo/bar')
+  end
+
+  it 'should map symbol to path' do
+    @layout[:foo] = 'baz'
+    @layout.expand(:foo, :bar).should eql('baz/bar')
+  end
+
+  it 'should map symbols to path' do
+    @layout[:foo, :bar] = 'none'
+    @layout.expand(:foo, :bar).should eql('none')
+  end
+
+  it 'should map strings to path' do
+    @layout[:foo, "bar"] = 'none'
+    @layout.expand(:foo, :bar).should eql('none')
+    @layout.expand(:foo, 'bar').should eql('none')
+  end
+
+  it 'should ignore nil elements' do
+    @layout[:foo, :bar] = 'none'
+    @layout.expand(:foo, nil, :bar).should eql('none')
+    @layout.expand(nil, :foo).should eql('foo')
+  end
+
+  it 'should return nil if path not mapped' do
+    @layout[:foo].should be_nil
+  end
+
+  it 'should return path from symbol' do
+    @layout[:foo] = 'path'
+    @layout[:foo].should eql('path')
+  end
+
+  it 'should return path from symbol' do
+    @layout[:foo, :bar] = 'path'
+    @layout[:foo, :bar].should eql('path')
+  end
+
+  it 'should do eager mapping' do
+    @layout[:one] = 'none'
+    @layout[:one, :two] = '1..2'
+    @layout.expand(:one, :two, :three).should eql('1..2/three')
+  end
+
+end