scm-workflow 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 90dcda5f4c926d3ddaa88dbe0a7641289f8699ea
+  data.tar.gz: 1f82b0d71688152be73377a23d65bbd6c35338e1
+SHA512:
+  metadata.gz: 0b4de49ea52fd388fa1670e96cd3a9a1a6a133faa1ed1be72fc6a4ec50fb688424269a900adf48c9e4edabb3519353920f104a3fb4b97429c038b3ae682528f3
+  data.tar.gz: 6a1e2f6afe58f6278768835b95d3863a8ddace9e4cf1f891463397ebba6bef63524076a5c30e3f9bba3601f542231f915f4457a61e4070829e0a20f437724c27

data/.gitignore

@@ -0,0 +1,3 @@
+.*.swp
+.DS_Store
+*.lock

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - "1.9.3"
+  - "1.9.2"
+  - "2.0.0"

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in scm-workflow.gemspec
+gemspec
+
+group :test do
+  gem 'rake'
+end
+
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Bone Crusher
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Scm::Workflow
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'scm-workflow'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install scm-workflow
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = Dir.glob("[0-9][0-9][0-9]_*").collect { |x| "-I#{x}" }
+  spec.rspec_opts << '--color -f d'
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+RSpec::Core::RakeTask.new(:coverage) do |spec|
+  # add simplecov
+  ENV["COVERAGE"] = 'yes'
+
+  # run the specs
+  Rake::Task['spec'].execute
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gitit #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Dir.glob('lib/tasks/*.rake').each {|r| import r}
+

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/bin/scw

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+Bundler.require(:default)
+
+require "utils/command-dispatcher.rb"
+
+# -----------------------------------------------------------------------------
+# This program is meant to be used as an extention to the git scm program.  It
+# provides a set of development workflows such as retrieving task information
+# from the rallydev application, automatically generating code review for the
+# smartbear software, automatically kick a build...
+#
+# Never call the scripts directly, always use git scw <command> instead of
+# git-scw-<command>
+#
+# Author::    Pat Laplante  (mailto:junk@covenofchaos.com)
+# Copyright:: Copyright (c) 2012 CovenOfChaos
+# License::   ???
+# -----------------------------------------------------------------------------
+
+$scriptPath = File.expand_path(File.dirname(__FILE__))
+$scriptName = File.basename(__FILE__)
+$command = ARGV.shift
+
+dispatcher = Scm::Workflow::Utils::CommandDispatcher.new( 
+    $scriptPath, $scriptName )
+
+# -----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+begin
+  dispatcher.dispatchCommand($command, *ARGV)
+rescue ArgumentError => ex
+  $stderr.puts "Error: " + ex.to_s + ".  Please specify a valid command."
+  dispatcher.usage
+  exit -1
+ensure
+end
+
+# -----------------------------------------------------------------------------
+# set filetype=ruby
+# -----------------------------------------------------------------------------

data/bin/scw-init

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+Bundler.require(:default)
+
+require 'highline/import'
+require "scm-workflow"
+require "kruptos"
+require "base64"
+
+#-----------------------------------------------------------------------------
+#-----------------------------------------------------------------------------
+def usage() 
+  puts "Commands for initialization of a local repo."
+  exit 0
+end
+
+#-----------------------------------------------------------------------------
+# ................ A R G U M E N T S .. P R O C E S S I N G .................
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# This hash will hold all of the options parsed from the command-line by
+# OptionParser.
+#-----------------------------------------------------------------------------
+options = {}
+loglevels = [:debug, :info, :warn, :error, :fatal]
+ 
+optparse = OptionParser.new do|opts|
+  # Set a banner, displayed at the top of the help screen.
+  opts.banner = "Usage: optparse1.rb [options] file1 file2 ..."
+   
+  # Define the options, and what they do
+  options[:quick] = false
+  opts.on( '-q', '--quick', 'Perform the task quickly' ) do
+  options[:quick] = true
+  end
+   
+  options[:logfile] = nil
+  opts.on( '-l', '--logfile FILE', 'Write log to FILE' ) do |file|
+  options[:logfile] = file
+  end
+  
+  options[:usage] = nil
+  opts.on( '-u', '--usage', 'Print one liner about this script' ) do
+     options[:usage] = true
+  end
+
+  options[:list] = []
+  opts.on( '-a', '--list a,b,c', Array, "List of parameters" ) do |l|
+    options[:list] = l
+  end
+  
+  options[:loglevel] = nil
+  opts.on( '-v', '--loglevel OPT', loglevels, "Log level" ) do |s|
+    options[:loglevel] = s
+  end 
+
+  # This displays the help screen, all programs are assumed to have this 
+  # option.
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    exit
+  end
+end
+
+#-----------------------------------------------------------------------------
+# Parse the command-line. Remember there are two forms of the parse method. 
+# The 'parse' method simply parses ARGV, while the 'parse!' method parses 
+# ARGV and removes any options found there, as well as any parameters for the
+# the options. What's left is the list of files to resize.
+#-----------------------------------------------------------------------------
+begin
+  optparse.parse!
+rescue => ex
+  puts ex.to_s
+  exit 1
+end
+usage if options[:usage]
+
+puts "Being quick" if options[:quick]
+puts "Logging to file #{options[:logfile]}" if options[:logfile]
+
+loglevel = options[:loglevel]
+logsettings = Scm::Workflow::Utils::LogSettings.instance
+logsettings.level = loglevels.index(loglevel) if options[:loglevel]
+logsettings.output = options[:logfile] if options[:logfile]
+
+#-----------------------------------------------------------------------------
+# ..................... E X E C U T I O N .. G U T S ........................
+#-----------------------------------------------------------------------------
+git = Gitit::Git.new(Dir.pwd)
+#Test it is a valid repo, if not create it.
+config = git.config
+
+#-----------------------------------------------------------------------------
+#-----------------------------------------------------------------------------
+begin
+
+  configBlocks = Array.new
+  configBlocks << Scm::Workflow::Flow.new
+  configBlocks << Scm::Workflow::CodeCollab.new
+  configBlocks << Scm::Workflow::Rally.new
+
+  initRepo = Scm::Workflow::InitializeRepo.new(git, configBlocks)
+
+  initRepo.execute { |configuration| 
+    configuration.each do |v|
+      globalEntry = v
+         
+      puts
+      puts " > " + globalEntry.to_s
+      globalEntry.instance_variables.each do |sv|
+        entry = globalEntry.instance_variable_get(sv)
+        info = entry.info;
+        hideInput = entry.hideinput;
+        question = "\tEnter the " + info + ": "
+        value = ask(question) { |q| q.echo = "*" } if hideInput
+        value = ask(question) { |q| q.default = entry.value } if !hideInput
+        entry.value = value
+      end
+    end
+  }
+  
+  
+rescue Interrupt => e
+  puts "\ninterupted"
+end
+
+exit initRepo.wasSuccessfull? ? 0 : 1
+
+

data/lib/ext/string.rb

@@ -0,0 +1,55 @@
+require "bundler/setup"
+require "kruptos"
+require "base64"
+
+Bundler.require(:default)
+
+class String
+
+  def encrypt(key = "Some random key")
+    blowfish = Kruptos::Blowfish.new(key)
+    
+    String val = self
+
+    # pad the value to be 8 bytes aligned.
+    (8-(val.length % 8)).times { val += "\012" }
+    encodedString = Base64.encode64(val)
+    
+    encryptedValue = ""
+    (
+      chunk = val.slice!(0,8)
+      encryptedValue += blowfish.encrypt_block(chunk)
+    ) until val.empty?
+    
+    return ::Base64.encode64(encryptedValue);
+  end
+
+  def decrypt(key = "Some random key")
+    blowfish = Kruptos::Blowfish.new(key)
+    value = ::Base64.decode64(self)
+    
+    decryptedValue = ""
+    (
+      chunk = value.slice!(0,8)
+      decryptedValue += blowfish.decrypt_block(chunk)
+    ) until value.empty?
+    
+    (
+      decryptedValue = decryptedValue.chomp("\012")
+    ) until (decryptedValue[decryptedValue.length-1] != "\012")
+
+    return decryptedValue
+  end
+
+end
+
+# String foo = "This is cool".encrypt("blablabla")
+# puts foo => "WuwcAFdNWrtdn4SANiTxgg=="
+# puts foo.decrypt("blablabla") => "This is cool"
+# puts foo.decrypt("blablabla").length => 12
+
+# String foo = "This is cool".encrypt
+# puts foo
+# puts foo.decrypt
+# puts foo.decrypt.length
+

data/lib/scm-workflow.rb

@@ -0,0 +1,21 @@
+require "bundler/setup"
+require "scm-workflow"
+require "utils/logging"
+
+require "kruptos"
+require "base64"
+require "ext/string"
+
+require "gitit"
+require "workflow"
+
+require "scm-workflow/configuration"
+Dir[File.dirname(__FILE__) + "/scm-workflow/workflow-*.rb"].each do |file|
+  require file
+end
+
+module Scm
+  module Workflow
+    # Your code goes here...
+  end
+end

data/lib/scm-workflow/configuration.rb

@@ -0,0 +1,81 @@
+require "bundler/setup"
+Bundler.require(:default)
+
+module Scm
+  module Workflow
+  end
+end
+
+module Scm::Workflow
+
+  class ConfigElement
+    attr_reader :info;
+    attr_accessor :value;
+    attr_reader :hideinput; 
+    
+    def initialize (info, hideinput, default)
+      @info = info;
+      @hideinput = hideinput;
+      @value = default;
+    end
+  end
+
+  class Flow
+    attr_accessor :develop;
+    attr_accessor :feature;
+    
+    def initialize
+      @develop = ConfigElement.new("Develop branch name", false, "develop")
+      @feature = ConfigElement.new("Feature branch name", false, "feature")
+    end
+
+    def to_s
+      return "Specify branch related information: "
+    end
+    
+  end
+
+  class CodeCollab
+    attr_accessor :app_exec_path;
+    attr_accessor :username;
+    attr_accessor :serverurl;
+    attr_accessor :reviewers;
+    attr_accessor :observers;
+
+    def initialize
+      @execpath = ConfigElement.new("Path to code collab executable", false, "/Applications/ccollab_client/ccollab")
+      @serverurl = ConfigElement.new("Code collab server url", false, "https://development-us:8443")
+      @username = ConfigElement.new("Code collab username", false, "")
+      @reviewers = ConfigElement.new("List of reviewers id, coma separated", false, "")
+      @observers = ConfigElement.new("List of observers id, coma separated", false, "")
+    end
+    
+    def to_s
+      return "Specify code collab related information: "
+    end
+
+  end
+
+  
+  class Rally
+    attr_accessor :username;
+    attr_accessor :password;
+    attr_accessor :serverurl;
+    attr_accessor :workspace;
+    attr_accessor :project;
+
+    def initialize
+      @serverurl = ConfigElement.new("Rally server url", false, "https://rally1.rallydev.com/")
+      @username = ConfigElement.new("Rally username", false, "")
+      @password = ConfigElement.new("Rally password", true, "")
+      @workspace = ConfigElement.new("Rally workspace", false, "")
+      @project = ConfigElement.new("Rally project", false, "")
+    end
+
+    def to_s
+      return "Specify Rallydev related information: "
+    end
+  
+  end
+
+end

data/lib/scm-workflow/version.rb

@@ -0,0 +1,5 @@
+module Scm
+  module Workflow
+    VERSION = "0.0.1"
+  end
+end

data/lib/tasks/version.rake

@@ -0,0 +1,138 @@
+require 'cli-colorize'
+
+def valid? version
+  pattern = /^\d+\.\d+\.\d+(\-(dev|beta|rc\d+))?$/
+  raise "Tried to set invalid version: #{version}".red unless version =~ pattern
+end
+
+def correct_version version
+  ver, flag = version.split '-'
+  v = ver.split '.'
+  (0..2).each do |n|
+    v[n] = v[n].to_i
+  end
+  [v.join('.'), flag].compact.join '-'
+end
+
+def read_version
+  begin 
+    File.read 'VERSION'
+  rescue
+    raise "VERSION file not found or unreadable.".red
+  end
+end
+
+def write_version version
+  valid? version
+  begin
+    File.open 'VERSION', 'w' do |file|
+      file.write correct_version(version)
+    end
+  rescue
+    raise "VERSION file not found or unwritable.".red
+  end
+end
+
+def reset current, which
+  version, flag = current.split '-'
+  v = version.split '.'
+  which.each do |part|
+    v[part] = 0
+  end
+  [v.join('.'), flag].compact.join '-'
+end
+
+def increment current, which
+  version, flag = current.split '-'
+  v = version.split '.'
+  v[which] = v[which].to_i + 1
+  [v.join('.'), flag].compact.join '-'
+end
+
+desc "Prints the current application version"
+version = read_version
+task :version do
+  puts <<HELP
+Available commands are:
+-----------------------
+rake version:write[version]   # set custom version in the x.x.x-? format
+rake version:patch            # increment the patch x.x.x+1 (keeps any flags on)
+rake version:minor            # increment minor and reset patch x.x+1.0 (keeps any flags on)
+rake version:major            # increment major and reset others x+1.0.0 (keeps any flags on)
+rake version:dev              # set the dev flag on x.x.x-dev
+rake version:beta             # set the beta flag on x.x.x-beta
+rake version:rc               # set or increment the rc flag x.x.x-rcX
+rake version:release          # removes any flags from the current version
+
+HELP
+  puts "Current version is: #{version.green}"
+end
+
+namespace :version do
+  
+  desc "Write version explicitly by specifying version number as a parameter"
+  task :write, [:version] do |task, args|
+    write_version args[:version].strip
+    puts "Version explicitly written: #{read_version.green}"
+  end
+  
+  desc "Increments the patch version"
+  task :patch do
+    new_version = increment read_version, 2
+    write_version new_version
+    puts "Application patched: #{new_version.green}"
+  end
+  
+  desc "Increments the minor version and resets the patch"
+  task :minor do
+    incremented = increment read_version, 1
+    new_version = reset incremented, [2]
+    write_version new_version
+    puts "New version released: #{new_version.green}"
+  end
+  
+  desc "Increments the major version and resets both minor and patch"
+  task :major do
+    incremented = increment read_version, 0
+    new_version = reset incremented, [1, 2]
+    write_version new_version
+    puts "Major application version change: #{new_version.green}. Congratulations!"
+  end
+  
+  desc "Sets the development flag on"
+  task :dev do
+    version, flag = read_version.split '-'
+    new_version = [version, 'dev'].join '-'
+    write_version new_version
+    puts "Version in development: #{new_version.green}"
+  end
+  
+  desc "Sets the beta flag on"
+  task :beta do
+    version, flag = read_version.split '-'
+    new_version = [version, 'beta'].join '-'
+    write_version new_version
+    puts "Version in beta: #{new_version.green}"
+  end
+  
+  desc "Sets or increments the rc flag"
+  task :rc do
+    version, flag = read_version.split '-'
+    rc = /^rc(\d+)$/.match flag
+    if rc
+      new_version = [version, "rc#{rc[1].to_i+1}"].join '-'
+    else
+      new_version = [version, 'rc1'].join '-'
+    end
+    write_version new_version
+    puts "New version release candidate: #{new_version.green}"
+  end
+  
+  desc "Removes any version flags"
+  task :release do
+    version, flag = read_version.split '-'
+    write_version version
+    puts "Released stable version: #{version.green}"
+  end
+  
+end

data/lib/test_unit_extensions.rb

@@ -0,0 +1,26 @@
+module Test
+  module Unit
+  end
+end
+
+module Test::Unit
+  # Used to fix a minor minitest/unit incompatibility in flexmock 
+#AssertionFailedError = Class.new(StandardError)
+  
+  class TestCase
+   
+    def self.must(name, &block)
+      test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+      defined = instance_method(test_name) rescue false
+      raise "#{test_name} is already defined in #{self}" if defined
+      if block_given?
+        define_method(test_name, &block)
+      else
+        define_method(test_name) do
+          flunk "No implementation provided for #{name}"
+        end
+      end
+    end
+
+  end
+end

data/lib/utils/command-dispatcher.rb

@@ -0,0 +1,54 @@
+module Scm 
+  module Workflow
+    module Utils
+    end
+  end
+end
+
+module Scm::Workflow::Utils
+
+  # ---------------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+  class CommandDispatcher
+  
+    EX_NOCMD="No command specified"
+    EX_INVALCMD="is not a valid command"
+    
+    # -------------------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    def initialize(rootScriptAbsLocation, rootScriptName)
+      @rootScriptAbsLocation = rootScriptAbsLocation
+      @rootScriptName = rootScriptName
+      @commandPrefix = rootScriptAbsLocation + '/' + rootScriptName + '-';
+    end   
+    
+    # -------------------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    def usage()
+      Dir.glob(@commandPrefix + '*').each do |f|
+        help = `#{f} --usage`
+        command = File.basename(f).gsub!( "-", " " )
+        $stdout.puts command.ljust(25)  + " : " + help 
+      end
+    end
+
+    # -------------------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    def dispatchCommand(cmd, *arguments)
+    
+      raise ArgumentError.new(EX_NOCMD) if cmd == nil
+      raise ArgumentError.new("#{cmd} " + EX_INVALCMD) unless isValid?(cmd)
+    
+      exec(@commandPrefix + cmd, *arguments)
+    end
+
+    # -------------------------------------------------------------------------
+    # -------------------------------------------------------------------------
+    def isValid?(command)
+      return false if (!File.exists?(@commandPrefix + command))
+      return true
+    end
+
+  end
+  
+end

data/lib/utils/logging.rb

@@ -0,0 +1,62 @@
+module Scm
+  module Workflow
+    module Utils
+    end
+  end
+end
+
+require 'singleton'
+require 'logger'
+
+module Scm::Workflow::Utils
+  class LogSettings
+    include Singleton
+    attr_accessor :level
+    attr_accessor :output
+    def initialize
+        @level = Logger::FATAL
+        @output = STDOUT
+    end
+  end
+
+  class Logging
+    include Singleton
+
+    attr_reader :logger
+    def initialize
+      logsettings = Scm::Workflow::Utils::LogSettings.instance
+      @logger = Logger.new(logsettings.output)
+      @logger.level = logsettings.level
+    end
+  end
+end
+
+module Logging
+
+  # ---------------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+  def logger
+    @logger ||= Logging.logger_for(self.class.name)
+  end
+
+  # Use a hash class-ivar to cache a unique Logger per class:
+  @loggers = {}
+
+  # ---------------------------------------------------------------------------
+  # ---------------------------------------------------------------------------
+  class << self
+
+    def logger_for(classname)
+      @loggers[classname] ||= configure_logger_for(classname)
+    end
+
+    def configure_logger_for(classname)
+      logsettings = Scm::Workflow::Utils::LogSettings.instance
+      logger = Logger.new(logsettings.output)
+      logger.progname = classname
+      logger.level = logsettings.level
+      logger
+    end
+  end
+
+end

data/scm-workflow.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'scm-workflow/version'
+
+Gem::Specification.new do |gem|
+
+  gem.name          = "scm-workflow"
+  gem.version       = File.exist?('VERSION') ? File.read('VERSION') : Scm::Workflow::VERSION
+  gem.authors       = ["Pat Laplante"]
+  gem.email         = ["pat@covenofchaos.com"]
+  gem.description   = %q{""}
+  gem.summary       = %q{""}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.licenses 		= ["MIT"]
+
+  gem.add_development_dependency 'rspec' 
+  gem.add_development_dependency 'cli-colorize'
+  gem.add_development_dependency 'rdoc', '>= 3.12'
+  gem.add_development_dependency 'cucumber', '>= 1.0'
+  gem.add_development_dependency 'bundler', '>= 1.0.0'
+  gem.add_development_dependency 'simplecov'
+
+  gem.add_dependency 'ruby'
+  gem.add_dependency 'gitit', '>= 0.4.0'
+  gem.add_dependency 'highline'
+  gem.add_dependency 'builder'
+  gem.add_dependency 'kruptos', '>= 0.2.0'
+  gem.add_dependency 'inflector'
+  gem.add_dependency 'workflow'
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+if ENV["COVERAGE"] == 'yes'
+  require 'simplecov'
+  SimpleCov.start
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'scm-workflow'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/stringext_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe String do
+
+  # -------------------------------------------------------------------------
+  # -------------------------------------------------------------------------
+  describe "#testStringEncrypt" do
+
+    before(:each) do
+    end
+
+    it "will successfully encrypt a string" do
+      encrypted = "abcd".encrypt
+      encrypted.encrypt.should_not eq "abcd"
+    end
+
+    it "will successfully decrypt an encrypted string" do
+      encrypted = "abcd".encrypt
+      encrypted.decrypt.should eq "abcd"
+    end
+
+    it "will successfully encrypt and decrypt a string when using a custom key" do
+      encrypted = "abcd".encrypt("My custom key")
+      encrypted.encrypt.should_not eq "abcd"
+      encrypted.decrypt.should_not eq "abcd"
+      encrypted.decrypt("My custom key").should eq "abcd"
+    end
+
+    after(:each) do
+    end
+
+  end
+
+end
+

data/test/test_rally.rb

@@ -0,0 +1,69 @@
+require "test/unit"
+require "json"
+require 'json/add/core'
+#require "./test_unit_extensions.rb"
+#require "./rally/rally.rb"
+require "test_unit_extensions"
+
+class RallyConfig
+  attr_accessor :username;
+  attr_accessor :password;
+  attr_accessor :serverurl;
+  attr_accessor :workspace;
+  attr_accessor :project;
+
+  def initialize()
+    @serverurl = "https://rally1.rallydev.com/"
+    @username = "plaplante@pharos.com"
+    @password = "Gr0sVag1n69"
+    @workspace = "Pharos"
+    @project = "MPS / Web Client"
+  end
+end
+
+class RallyTest < Test::Unit::TestCase
+  def setup
+    @rallyConfig = RallyConfig.new
+    @rally = Pharos::Utils::Rally::Rally.new(@rallyConfig)
+  end
+  
+  must "connect to rally successfully" do
+    @rally.openConnection
+    iteration = @rally.getCurrentIteration
+    puts "Iteration: " + iteration.name
+
+    stories = @rally.getCurrentIterationStories iteration
+    stories.each { |story|
+      puts "(" + story.formatted_i_d + ") - " + story.name
+      unless story.tasks.nil?
+        story.tasks.each { |task|
+          puts "\t" + task.formatted_i_d + ": " + task.name
+        }
+      end
+    }
+#    tasks.each { |task| puts "(" + task.work_product.formatted_i_d + ") - " + task.work_product.name +  ": " + task.inspect }
+
+    defects = @rally.getAllOpenDefectsForIteration @rallyConfig.project, iteration
+    defects.each { |defect| puts defect.state; puts defect.priority; puts defect.project.body; }
+  end
+
+#  %w[y Y YeS YES yes].each do |yes|
+#    must "return true when yes_or_no parses #{yes}" do
+#      assert @questioner.yes_or_no(yes), "#{yes.inspect} expected to parse as true" 
+#    end
+#  end
+
+#  %w[n N no nO].each do |no|
+#    must "return false when yes_or_no parses #{no}" do
+#      assert ! @questioner.yes_or_no(no), "#{no.inspect} expected to parse as false" 
+#    end
+#  end
+
+#  %w[Note Yesterday xyzaty].each do |mu|
+#    must "return nil because #{mu} is not a variant of 'yes' or 'no'" do
+#      assert_nil @questioner.yes_or_no(mu), "#{mu.inspect} expected to parse as nil" 
+#    end
+#  end 
+
+
+end

metadata

@@ -0,0 +1,252 @@
+--- !ruby/object:Gem::Specification
+name: scm-workflow
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Pat Laplante
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cli-colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gitit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kruptos
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: workflow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: '""'
+email:
+- pat@covenofchaos.com
+executables:
+- scw
+- scw-init
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/scw
+- bin/scw-init
+- lib/ext/string.rb
+- lib/scm-workflow.rb
+- lib/scm-workflow/configuration.rb
+- lib/scm-workflow/version.rb
+- lib/tasks/version.rake
+- lib/test_unit_extensions.rb
+- lib/utils/command-dispatcher.rb
+- lib/utils/logging.rb
+- scm-workflow.gemspec
+- spec/spec_helper.rb
+- spec/stringext_spec.rb
+- test/test_rally.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: '""'
+test_files:
+- spec/spec_helper.rb
+- spec/stringext_spec.rb
+- test/test_rally.rb