crab 0.1.0

data/lib/crab/update.rb

@@ -0,0 +1,68 @@
+module Crab
+  class Update
+    def initialize(global_opts, cmd_opts, args)
+      @global_opts = global_opts
+      @cmd_opts = cmd_opts
+      @args = args
+
+      @rally = Rally.new
+    end
+
+    def run
+      opts = validate_and_fix_up_arguments
+
+      @rally.connect
+
+      story = @rally.find_story_with_id @args.first
+      opts = validate_and_fix_up_arguments_with_rally(story, opts)
+
+      story.update opts
+
+      puts "#{story.formatted_id}: #{story.name} (#{story.state})"
+    end
+
+    def validate_and_fix_up_arguments
+      Trollop::die "No story given" if @args.empty?
+      Trollop::die "Nothing to update. Please provide some options" unless @cmd_opts.any? {|k, v| k.to_s =~ /_given$/ }
+
+      opts = {}
+      opts[:name] = @cmd_opts[:name] if @cmd_opts[:name_given]
+      opts[:schedule_state] = state_from(@cmd_opts[:state]) if @cmd_opts[:state_given]
+
+      if @cmd_opts[:estimate_given]
+        opts[:plan_estimate] = @cmd_opts[:estimate] # nobody is going to remember "Plan Estimate", really
+      end
+
+      opts[:blocked] = @cmd_opts[:blocked] if @cmd_opts[:blocked_given]
+      opts[:blocked] = !@cmd_opts[:unblocked] if @cmd_opts[:unblocked_given]
+
+      opts
+    end
+
+    def validate_and_fix_up_arguments_with_rally(story, opts)
+      if @cmd_opts[:iteration_given]
+        opts[:iteration] = @rally.find_iteration_by_name @cmd_opts[:iteration]
+        Trollop::die "Unknown iteration \"#{@cmd_opts[:iteration]}\"" if opts[:iteration].nil?
+      end
+
+      if @cmd_opts[:release_given]
+        opts[:release] = @rally.find_release_by_name @cmd_opts[:release]
+        Trollop::die "Unknown release \"#{@cmd_opts[:release]}\"" if opts[:release].nil?
+      end
+
+      if @cmd_opts[:parent_given]
+        opts[:parent] = @rally.find_story_with_id(@cmd_opts[:parent]).rally_object
+        Trollop::die "Unknown story \"#{@cmd_opts[:parent]}\"" if opts[:parent].nil?
+      end
+
+      opts[:name] = story.name if opts[:name].blank?
+      opts
+    end
+
+    def state_from(option)
+      fixed_option = option.gsub(/(^\w|[-_]\w)/) { $1.upcase.gsub(/_/, '-') }
+      Trollop::die :state, "has an invalid value" unless Crab::Story::VALID_STATES.include? fixed_option
+      fixed_option
+    end
+  end
+end

data/lib/crab/utilities.rb

@@ -0,0 +1,18 @@
+module Crab
+  module Utilities
+    def credentials_file
+      File.expand_path("~/.rally_credentials")
+    end
+
+    def valid_credentials_file
+      Trollop::die "Please log in first" unless File.exists? credentials_file
+      credentials_file
+    end
+
+    def valid_project_name(cmd_opts)
+      project_name = cmd_opts[:project_given] ? cmd_opts[:project] : Crab::Project.current_project_name
+      Trollop::die :project, "must be specified" if project_name.blank?
+      project_name
+    end
+  end
+end

data/lib/crab/version.rb

@@ -0,0 +1,3 @@
+module Crab
+  VERSION = "0.1.0"
+end

data/old/.gitignore

@@ -0,0 +1 @@
+./crab/Gemfile.lock

data/old/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gem 'rally_rest_api'
+gem 'cucumber'
+gem 'rake'
+
+gem 'highline', :require => 'highline/import' # password prompts, etc
+gem 'pry' # irb-like awesomeness for debugging
+gem 'activesupport', :require => 'active_support/all' # nice additions to Ruby API
+gem 'i18n'
+
+gem 'mustache' # for file templates
+gem 'sanitize' # clean up description HTML
+

data/old/Rakefile

@@ -0,0 +1,277 @@
+require 'rubygems'
+require 'bundler/setup'
+
+Bundler.require :default
+
+task :ensure_credentials_are_present do
+  ENV['RALLY_USERNAME'] ||= ask('Username: ')
+  ENV['RALLY_PASSWORD'] ||= ask('Password: ') {|q| q.echo = "*" }
+end
+
+task :rally => :ensure_credentials_are_present do
+  @rally = RallyRestAPI.new :username => ENV['RALLY_USERNAME'], :password => ENV['RALLY_PASSWORD']
+  puts "Logged in as #{@rally.user.login_name}"
+end
+
+# a few things in this script break / do the wrong thing if you don't have
+# the project set up or don't have access to it
+task :project => :rally do
+  project = ENV['RALLY_PROJECT'] ||= ask('Project: ')
+  @project = @rally.find(:project) { equal :name, ENV['RALLY_PROJECT']}.first
+  puts "Using project \"#{ENV['RALLY_PROJECT']}\""
+end
+
+task :default => :rally do
+  binding.pry
+end
+
+class Feature < Mustache
+
+  self.template_path = File.join(File.dirname(__FILE__), 'templates')
+
+  # didn't like what's being done to support multiple languages
+  # this is going to break horribly when we try to add supoort for generating the
+  # scenarios from Rally and the whole roundtripping thing
+  # (as it'll be difficult to use partials, for example)
+  def initialize(rally_story, language=(ENV['CUCUMBER_LANG'] || ''))
+    @delegate = rally_story
+    self.class.template_file = File.join(self.class.template_path, "feature-#{language}.mustache") if language.present?
+  end
+
+  def name
+    @delegate.name
+  end
+
+  def formatted_id
+    @delegate.formatted_i_d
+  end
+
+  def state
+    (@delegate.schedule_state || "unknown").parameterize.underscore
+  end
+
+  def description
+    # this could use a lot of rethinking :(
+    # biggest problem is that Cucumber breaks if text in description looks like something
+    # it might know how to parse, but doesn't
+    # our feature descriptions are quite like that, so I was being ultra-conservative
+    sanitize(@delegate.description || '').gsub(/  +/, "\n").gsub(/\n\n/, "\n").gsub(/\n/, "\n  ")
+  end
+
+  def file_name
+    "#{formatted_id}_#{name.parameterize.underscore}.feature"
+  end
+
+  def dir_name
+    state
+  end
+
+end
+
+task :generate_features => :project do
+  project = @project
+  @stories = @rally.find(:hierarchical_requirement, :fetch => true) { equal :project, project }
+
+  @stories.each do |story|
+    feature = Feature.new(story)
+
+    dir = File.join("features", feature.dir_name)
+    file = File.join(dir, feature.file_name)
+
+    FileUtils.mkdir_p dir
+    FileUtils.touch file
+
+    File.open(file, 'w') do |f|
+      f.write feature.render
+    end
+    putc '.'
+  end
+  puts
+
+end
+# this whole class should die and we should probably use
+# a Cucumber formatter instead of relying directly on the Gherkin
+# APIs. With the extra info that Cucumber provides, it should also
+# be possible to generate Test Case Runs, which would be pretty sweet
+# to track using charts in Rally -- eg "How often do I have to do a manual
+# test run of the @manual stuff so it's all good?"
+class FeatureProxy
+  def initialize
+    @scenarios = []
+    @steps = ActiveSupport::OrderedHash.new([])
+  end
+
+  attr_reader :scenarios, :steps
+
+  def name
+    @feature.name
+  end
+
+  def description
+    @feature.description
+  end
+
+  # the next two methods could be replaced with something like an extension to the cucumber syntax
+  # in which we annotate foreign IDs -- my proposal is something like what's in here:
+  #
+  #   Feature: [XXXXX] Lorem Ipsum
+  #
+  # Simple regex, fairly hard to get wrong in almost any western keyboard, and should work for any bug/issue/card/story tracker I've seen
+  #
+  def rally_id
+    self.name.match(/^\[([^\]]+)\](.*)$/)
+    $1
+  end
+
+  def title_for_rally
+    self.name.match(/^\[([^\]]+)\](.*)$/)
+    $2.squish.titleize
+  end
+
+  # needed by Gherkin
+  def uri(uri)
+  end
+
+  def feature(feature)
+    @feature = feature
+  end
+
+  def get
+    @feature
+  end
+
+  def scenario(scenario)
+    @scenarios << scenario
+  end
+
+  def step(step)
+    @steps[@scenarios.last] += Array(step)
+  end
+
+  def eof
+  end
+
+  def has_story_id?
+    !!self.name.match(/^\[([^\]]+)\](.*)$/)
+  end
+end
+
+def parse(feature)
+  updater = FeatureProxy.new
+  parser = Gherkin::Parser::Parser.new(updater, false, "root", false)
+  parser.parse File.read(feature), feature, 0
+  updater
+end
+
+# took a while to figure out that we need to remove the CSS from inside embedded <style> tags!
+# Rally uses some crazy rich text editor that I'd be soooooo happy to disable, somehow. Chrome Extension, perhaps?
+def sanitize(source)
+  Sanitize.clean source, :remove_contents => %w{style}
+end
+
+task :update_features => :rally do
+  Dir['features/**/*.feature'].sort {|a,b| File.mtime(b) <=> File.mtime(a) }.each do |file|
+    feature = parse file
+    unless feature.has_story_id?
+      raise "Incompatible feature name: #{feature.name} in #{file} (needs to begin with a story number in square brackets)"
+    end
+
+    # TODO inline variables
+    feature_id = feature.rally_id
+    feature_name = feature.title_for_rally
+
+    story = @rally.find(:hierarchical_requirement) { equal :formatted_i_d, feature_id }.first
+
+    updates = {} # collect all updates first (room for double-checking and you only get to call Rally over the net once per item)
+
+    if story.name != feature_name
+      updates[:name] = feature_name
+    end
+
+    # matching the descriptions sucked -- Rally does some conversion to strip out HTML
+    rally_description = sanitize(story.description   || '').gsub(/\s+/, ' ').strip
+    cuke_description  = sanitize(feature.description || '').gsub(/\s+/, ' ').strip
+
+    if rally_description != cuke_description
+      formatted_description = (feature.description || '').strip.gsub(/\n/, '<br/>')
+      updates[:description] = formatted_description
+    end
+    #
+
+    if updates.empty?
+      puts "Nothing to do for #{feature_id} (story already up to date)"
+    else
+      story.update updates
+      puts "Updated #{feature_id}: #{story.name} (#{updates.keys.join(',')})"
+    end
+  end
+end
+
+task :update_scenarios => :project do
+  Dir['features/**/*.feature'].sort {|a,b| File.mtime(b) <=> File.mtime(a) }.each do |file|
+    feature = parse file
+    feature.steps.each do |scenario, steps|
+      create_test_case @project, feature, scenario, steps
+
+      # TODO make the scenarios in the Cucumber file reflect what's in Rally as well
+      #
+      # goal is to have roundtrip editing, but if not whatever is in Cucumber is "the truth"
+    end
+  end
+end
+
+TYPE_TAGS = %w{acceptance functional non-functional performance regression usability user_interface}
+RISK_TAGS = %w{low_risk medium_risk high_risk}
+PRIORITY_TAGS = %{useful important critical}
+METHOD_TAGS = %{automated manual}
+
+def create_test_case(project, feature, scenario, steps)
+  if !scenario.name.match /^\[([^\]]+)\](.*)$/
+    # uh oh, we have to create this scenario!
+    tags = scenario.tags.map {|t| t.name.gsub(/^@/, '') }
+
+    # could definitely use some cleaning up, but the defaults seem sensible so far
+    type_tag = (tags.find {|t| TYPE_TAGS.include? t } || 'acceptance').humanize
+    risk_tag = (tags.find {|t| RISK_TAGS.include? t } || 'medium_risk').gsub(/_risk/, '').humanize
+    priority_tag = (tags.find {|t| PRIORITY_TAGS.include? t } || 'important').humanize
+    method_tag = (tags.find {|t| METHOD_TAGS.include? t } || 'automated').humanize
+
+    story = @rally.find(:hierarchical_requirement) { equal :formatted_i_d, feature.rally_id }.first
+
+    options = {
+      :name => scenario.name,
+      :description => "Automatically updated by Cucumber, do not edit",
+      :type => type_tag,
+      :risk => risk_tag,
+      :priority => priority_tag,
+      :method => method_tag,
+      :pre_conditions => "N/A", # do scenarios have a header? BeforeScenario?
+      :post_conditions => "N/A", # ...and/or a footer? AfterScenario, perhaps?
+      :work_product => story,
+      :project => @project # linking testcase to story is not enough
+    }
+
+    test_case = @rally.create(:test_case, options) do |test_case|
+      steps.each_with_index do |step, i|
+        test_case_step = @rally.create(:test_case_step, :test_case => test_case, :index => i, :input => "#{step.keyword.strip} #{step.name.strip}")
+      end
+    end
+
+    puts "Created test case #{test_case.formatted_i_d} in story #{feature.rally_id}"
+  else
+    # TODO update scenario text in feature with ID from Rally
+    # then update other fields in Rally with our scenario fields / tags
+  end
+end
+
+desc "DANGER DANGER DANGER"
+task :delete_all_test_cases => :project do
+  story_id = ENV['STORY'] ||= ask("Story #: ")
+  project = @project
+  story = @rally.find(:hierarchical_requirement) { equal :formatted_i_d, story_id }.first
+  test_cases = @rally.find(:test_case) { equal :work_product, story }
+
+  test_cases.each do |tc|
+    p tc.delete
+  end
+end

data/old/templates/feature-pt.mustache

@@ -0,0 +1,5 @@
+# language: pt
+@{{state}}
+Funcionalidade: [{{formatted_id}}] {{{name}}}
+
+  {{{description}}}

data/old/templates/feature.mustache

@@ -0,0 +1,4 @@
+@{{state}}
+Feature: [{{formatted_id}}] {{{name}}}
+
+  {{{description}}}

metadata

@@ -0,0 +1,230 @@
+--- !ruby/object:Gem::Specification 
+name: crab
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Carlos Villela
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-27 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rally_rest_api
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: sanitize
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id009
+description: CRaB is a bridge between Cucumber and Rally
+email: 
+- cvillela@thoughtworks.com
+executables: 
+- crab
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Rakefile
+- bin/crab
+- crab.gemspec
+- features/find-text-in-stories.feature
+- features/list-from-rally.feature
+- features/login-and-out-of-rally.feature
+- features/project-selection.feature
+- features/pull-from-rally-into-cucumber.feature
+- features/show-from-rally.feature
+- features/steps/rally_steps.rb
+- features/subcommand-help.feature
+- features/support/aruba.rb
+- features/update-story-in-rally.feature
+- lib/crab.rb
+- lib/crab/cli.rb
+- lib/crab/cucumber_feature.rb
+- lib/crab/cucumber_scenario.rb
+- lib/crab/find.rb
+- lib/crab/list.rb
+- lib/crab/login.rb
+- lib/crab/project.rb
+- lib/crab/pull.rb
+- lib/crab/rally.rb
+- lib/crab/scenario.rb
+- lib/crab/show.rb
+- lib/crab/story.rb
+- lib/crab/update.rb
+- lib/crab/utilities.rb
+- lib/crab/version.rb
+- old/.gitignore
+- old/Gemfile
+- old/Gemfile.lock
+- old/Rakefile
+- old/templates/feature-pt.mustache
+- old/templates/feature.mustache
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: crab
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Cucumber-Rally Bridge
+test_files: []
+