schubert-minglr 1.2.0 → 1.3.0

data/lib/minglr/resources/user.rb

@@ -14,12 +14,6 @@ module Resources
       end
     end
     
-    def self.find_user_id_for_user(user)
-      if user = Resources::User.find(:all).select { |user| user.user.login == user }.first
-        user.user_id
-      end
-    end
-    
   end
   
 end

data/minglr.gemspec

@@ -1,12 +1,12 @@
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |s|
   s.name = %q{minglr}
-  s.version = "1.2.0"
-
-  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.version = "1.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Schubert", "Stephen Chu", "Chris O'Meara"]
-  s.date = %q{2009-07-26}
+  s.date = %q{2009-07-27}
   s.description = %q{* This gem provides two executable binaries to interact with Mingle (http://mingle.thoughtworks.com/mingle-agile-project-management) through its API. It also has sample interactive Rake task on how to facilitate easy card movements when a card enters/exits the development queue.  * mtx is a binary that facilities transition changes for use on rake tasks * minglr is a more interactive tool that provides a quick interface for many common uses}
   s.email = %q{michael@schubert.cx}
   s.executables = ["mtx", "minglr"]
@@ -24,12 +24,17 @@ Gem::Specification.new do |s|
      "VERSION.yml",
      "bin/minglr",
      "bin/mtx",
+     "cucumber.yml",
+     "features/cards.feature",
+     "features/step_definitions/minglr_steps.rb",
+     "features/step_definitions/shared_steps.rb",
+     "features/users.feature",
      "lib/minglr.rb",
      "lib/minglr/action.rb",
      "lib/minglr/config_parser.rb",
      "lib/minglr/extensions/array.rb",
-     "lib/minglr/input_cache.rb",
-     "lib/minglr/mtx_options_parser.rb",
+     "lib/minglr/mtx/input_cache.rb",
+     "lib/minglr/mtx/options_parser.rb",
      "lib/minglr/options_parser.rb",
      "lib/minglr/resources/attachment.rb",
      "lib/minglr/resources/base.rb",
@@ -42,7 +47,11 @@ Gem::Specification.new do |s|
      "minglrconfig.sample",
      "tasks/commit.sample.rake",
      "tasks/svn.sample.rake",
+     "test/action_test.rb",
+     "test/commands_test.rb",
+     "test/config_parser_test.rb",
      "test/extensions/array_test.rb",
+     "test/options_parser_test.rb",
      "test/resources/attachment_test.rb",
      "test/resources/base_test.rb",
      "test/resources/card_test.rb",
@@ -51,15 +60,18 @@ Gem::Specification.new do |s|
      "test/resources/user_test.rb",
      "test/test_helper.rb"
   ]
-  s.has_rdoc = true
   s.homepage = %q{http://github.com/schubert/minglr}
   s.post_install_message = %q{PostInstall.txt}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.0.1}
+  s.rubygems_version = %q{1.3.5}
   s.summary = %q{command line user tool for Mingle (http://mingle.thoughtworks.com/mingle-agile-project-management)}
   s.test_files = [
-    "test/extensions/array_test.rb",
+    "test/action_test.rb",
+     "test/commands_test.rb",
+     "test/config_parser_test.rb",
+     "test/extensions/array_test.rb",
+     "test/options_parser_test.rb",
      "test/resources/attachment_test.rb",
      "test/resources/base_test.rb",
      "test/resources/card_test.rb",
@@ -68,4 +80,14 @@ Gem::Specification.new do |s|
      "test/resources/user_test.rb",
      "test/test_helper.rb"
   ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
 end

data/tasks/commit.sample.rake

@@ -64,7 +64,7 @@ namespace :minglr do
         end
       else
         print "#{message}"
-        if cache = InputCache.get(options[:cache_key])
+        if cache = MTX::InputCache.get(options[:cache_key])
           print " [#{cache}]"
         end
         print ": "
@@ -72,8 +72,8 @@ namespace :minglr do
       end
 
     if !options[:secure] && cache_key = options.delete(:cache_key)
-      user_input = InputCache.get(cache_key) if user_input.blank?
-      InputCache.put(cache_key, user_input)
+      user_input = MTX::InputCache.get(cache_key) if user_input.blank?
+      MTX::InputCache.put(cache_key, user_input)
     end
     
     user_input = escape(user_input)

data/test/action_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+module Minglr
+  
+  class ActionTest < Test::Unit::TestCase
+  
+    context Action do
+    
+      context "valid_actions" do
+        
+        should "return an array of valid actions" do
+          valid_actions = ["users", "cards", "card", "move", "update", "attach", "projects", "create", "fetch"].sort
+          assert_equal [], (valid_actions - Action.valid_actions)
+        end
+      
+      end
+      
+      context "valid_action?" do
+        
+        should "return true if action is a valid action" do
+          assert_equal true, Action.valid_action?("move")
+        end
+        
+        should "return false if action is not a valid action" do
+          assert_equal false, Action.valid_action?("frobble")
+        end
+        
+      end
+      
+      context "execute" do
+        
+        should "ignore the first option if no project is specified" do
+          action = :someaction
+          options = ["someaction", "option2"]
+          flag_options = { :foo => "bar" }
+          config = { :foo => "bar" }
+          
+          Minglr::Action::Commands.expects(:send).with(action, ["option2"], flag_options, config)
+          Action.execute(action, options, flag_options, config)
+        end
+        
+        should "ignore the first two options if project is specified" do
+          action = :someaction
+          options = ["someproject", "someaction", "option2"]
+          flag_options = { :foo => "bar" }
+          config = { :foo => "bar" }
+          
+          Minglr::Action::Commands.expects(:send).with(action, ["option2"], flag_options, config)
+          Action.execute(action, options, flag_options, config)          
+        end
+        
+        should "send the action to commands" do
+          action = "someaction"
+          options = ["option1", "option2"]
+          flag_options = { :foo => "bar" }
+          config = { :foo => "bar" }
+          
+          Minglr::Action::Commands.expects(:send).with(action, options, flag_options, config)
+          Action.execute(action, options, flag_options, config)
+        end
+        
+        should "rescue and print an error if the resource can't be found" do
+          Action.expects(:puts).with("Failed with MyError  for URL '#{Resources::Base.site}' ...")
+          Minglr::Action::Commands.expects(:send).raises(ActiveResource::ResourceNotFound, stub("Response", :code => "MyError"))
+          
+          Action.execute("someaction", ["someaction"])
+        end
+        
+      end
+       
+    end
+  
+  end
+  
+end

data/test/commands_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+module Minglr
+  
+  class CommandsTest < Test::Unit::TestCase
+
+    context Action::Commands do
+      
+      setup do
+        @options = []
+        @flag_options = {}
+        @config = { :status_property => "cp_status", :username => "user", :password => "password" }
+      end
+      
+      context "attach" do
+        
+        should "parse card number and file number as options and call resource" do
+          @options << "1"
+          @flag_options[:file_attachment] = "file"
+          
+          Resources::Attachment.expects(:attach).with("1", "file", "user", "password")
+          Action::Commands.attach(@options, @flag_options, @config)
+        end
+    
+      end 
+  
+      context "card" do
+    
+        should "parse card number and call resource" do
+          @options << "1"
+          
+          Resources::Card.expects(:print_card).with("1", "cp_status")
+          Action::Commands.card(@options, @flag_options, @config)
+        end
+    
+      end
+  
+      context "cards" do
+    
+        should "call resource" do
+          Resources::Card.expects(:print_all).with(@options, "cp_status")
+          Action::Commands.cards(@options, @flag_options, @config)
+        end
+    
+      end
+  
+      context "create" do
+    
+        should "call resource" do
+          Resources::Card.expects(:create).with(@flag_options, "cp_status")
+          Action::Commands.create(@options, @flag_options, @config)
+        end
+    
+      end
+  
+      context "fetch" do
+    
+        should "parse card number and call resource" do
+          @options << "1"
+          
+          Resources::Attachment.expects(:fetch).with("1", "user", "password")
+          Action::Commands.fetch(@options, @flag_options, @config)
+        end
+    
+      end
+  
+      context "move" do
+    
+        should "parse card number and call resource" do
+          @options << "1"
+
+          Resources::Card.expects(:move).with("1", @flag_options, @config)
+          Action::Commands.move(@options, @flag_options, @config)
+        end
+  
+      end
+  
+      context "projects" do
+    
+        should "call resource" do
+          Resources::Project.expects(:print_all).with(@options, "cp_status")
+          Action::Commands.projects(@options, @flag_options, @config)
+        end
+    
+      end
+  
+      context "update" do
+    
+        should "parse card number and call resource" do
+          @options << "1"
+          
+          Resources::Card.expects(:update).with("1", @flag_options)
+          Action::Commands.update(@options, @flag_options, @config)
+        end
+    
+      end
+  
+      context "users" do
+    
+        should "call resource" do
+          Resources::User.expects(:print_all).with(@options)
+          Action::Commands.users(@options, @flag_options, @config)
+        end
+  
+      end
+  
+    end
+  
+  end
+  
+end

data/test/config_parser_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+module Minglr
+  
+  class ConfigParserTest < Test::Unit::TestCase
+    
+    context "parse" do
+    
+      should "look for a config file in the user home directory or the current working directory" do
+        File.expects(:exist?).with(File.join(ENV["HOME"], ".minglrconfig"))
+        File.expects(:exist?).with(File.expand_path(File.join(ENV["PWD"], ".minglrconfig")))
+        ConfigParser.stubs(:puts)
+        ConfigParser.parse
+      end
+      
+      should "return the parsed configuration as a hash" do
+        configuration_content = <<-EOS
+          [foo]
+            myfoo = myvalue
+          [bar]
+            mybar = yourvalue
+        EOS
+        
+        File.stubs(:exist?).returns(true)
+        File.expects(:read).returns(configuration_content)
+        parsed_configuration = ConfigParser.parse
+        
+        assert_equal Hash, parsed_configuration.class
+      end
+      
+      should "print a message if the config file cannot be found" do
+        File.expects(:exist?).times(2).returns(false)
+        ConfigParser.expects(:puts)
+        ConfigParser.parse
+      end
+    
+    end
+    
+    context "initialize" do
+      
+      should "parse the configuration file into sections and variables" do
+        configuration_content = <<-EOS
+          [foo]
+            myfoo = myvalue
+          [bar]
+            mybar = yourvalue
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal true, parsed_configuration.config.has_key?(:foo)
+        assert_equal true, parsed_configuration.config.has_key?(:bar)
+        assert_equal true, parsed_configuration.config[:foo].has_key?(:myfoo)
+        assert_equal true, parsed_configuration.config[:bar].has_key?(:mybar)
+        assert_equal "myvalue", parsed_configuration.config[:foo][:myfoo]
+        assert_equal "yourvalue", parsed_configuration.config[:bar][:mybar]
+      end
+      
+      should "skip comment lines" do
+        configuration_content = <<-EOS
+          # [foo]
+          #   bar = bad
+          [foo]
+            bar = baz
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal "baz", parsed_configuration.config[:foo][:bar]
+      end
+      
+      should "skip blank lines" do
+        configuration_content = <<-EOS
+
+          [foo]
+          
+          [babble]
+            bar = baz
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal "baz", parsed_configuration.config[:babble][:bar]
+      end
+      
+      should "not redefine a section if it has already been defined" do
+        configuration_content = <<-EOS
+          [foo]
+            bar = baz
+            should = bekept
+            
+          [foo]
+            bar = somethingelse
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal "somethingelse", parsed_configuration.config[:foo][:bar]
+        assert_equal "bekept", parsed_configuration.config[:foo][:should]
+      end
+      
+      should "set a section variable to the latest value allowing it to be redefined" do
+        configuration_content = <<-EOS
+          [foo]
+            bar = baz
+            bar = somethingelse
+        EOS
+        
+        parsed_configuration = ConfigParser.new(configuration_content)
+        assert_equal "somethingelse", parsed_configuration.config[:foo][:bar]
+      end
+      
+    end
+    
+  end
+  
+end

data/test/options_parser_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+module Minglr
+  
+  class OptionsParserTest < Test::Unit::TestCase
+    
+    context "parse" do
+      
+      should "gather all property definitions for a given project" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.expects(:project_options).returns([[:column_name, "Some Column Name"]])
+        OptionsParser.expects(:puts)
+        OptionsParser.parse(["--version"])
+      end
+      
+      should "warn about authentication if property definition gathering fails" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.expects(:project_options).raises(ActiveResource::UnauthorizedAccess, stub(:code => "BadAccess"))
+        OptionsParser.expects(:puts).at_least(1)
+        OptionsParser.expects(:puts).with("Connection Failed with BadAccess  to http://foo.bar")
+        OptionsParser.expects(:puts).with("Did you set 'basic_authentication_enabled: true' in your auth_config.yml file?")
+        OptionsParser.parse(["--version"])
+      end
+      
+      should "parse name option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-n", "MyName"])
+        
+        assert_equal true, options.has_key?(:name)
+        assert_equal "MyName", options[:name]
+      end
+      
+      should "parse description option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-d", "MyDescription"])
+        
+        assert_equal true, options.has_key?(:description)
+        assert_equal "MyDescription", options[:description]
+      end
+      
+      should "parse type option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-t MyType"])
+        
+        assert_equal true, options.has_key?(:card_type_name)
+        assert_equal "MyType", options[:card_type_name]
+      end
+      
+      should "parse comment option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-c MyComment"])
+        
+        assert_equal true, options.has_key?(:comment)
+        assert_equal "MyComment", options[:comment]
+      end
+      
+      should "parse file option" do
+        Resources::Base.site = "http://foo.bar"
+        Resources::PropertyDefinition.stubs(:project_options).returns([])
+        options = OptionsParser.parse(["-f MyFile"])
+        
+        assert_equal true, options.has_key?(:file_attachment)
+        assert_equal "MyFile", options[:file_attachment]
+      end
+      
+    end
+    
+  end
+  
+end