octopolo 0.0.1

data/lib/octopolo/scripts/sync_branch.rb

@@ -0,0 +1,37 @@
+require_relative "../scripts"
+
+module Octopolo
+  module Scripts
+    class SyncBranch
+      include ConfigWrapper
+      include CLIWrapper
+      include GitWrapper
+
+      attr_accessor :branch
+
+      def self.execute(branch=nil)
+        new(branch).execute
+      end
+
+      def initialize(branch=nil)
+        @branch = branch || default_branch
+      end
+
+      # Public: Default value of branch if none given
+      def default_branch
+        config.deploy_branch
+      end
+
+      def execute
+        merge_branch
+      end
+
+      # Public: Merge the specified remote branch into your local
+      def merge_branch
+        git.merge branch
+      rescue Git::MergeFailed
+        cli.say "Merge failed. Please resolve these conflicts."
+      end
+    end
+  end
+end

data/lib/octopolo/scripts/tag_release.rb

@@ -0,0 +1,70 @@
+require "date" # necessary to get the Date.today convenience method
+require_relative "../scripts"
+require_relative "../changelog"
+
+module Octopolo
+  module Scripts
+    class TagRelease
+      include CLIWrapper
+      include ConfigWrapper
+      include GitWrapper
+
+      attr_accessor :suffix
+      attr_accessor :force
+      alias_method :force?, :force
+
+      TIMESTAMP_FORMAT = "%Y.%m.%d.%H.%M"
+
+      def self.execute(suffix=nil, force=false)
+        new(suffix, force).execute
+      end
+
+      def initialize(suffix=nil, force=false)
+        @suffix = suffix
+        @force = force
+      end
+
+      def execute
+        if should_create_branch?
+          update_changelog
+          tag_release
+        else
+          raise Octopolo::WrongBranch.new("Must perform this script from the deploy branch (#{config.deploy_branch})")
+        end
+      end
+
+      # Public: Whether to create a new branch
+      #
+      # Returns a Boolean
+      def should_create_branch?
+        force? || (git.current_branch == config.deploy_branch)
+      end
+
+      # Public: Generate a tag for the current release
+      def tag_release
+        git.new_tag tag_name
+      end
+
+      # Public: The name to apply to the new tag
+      def tag_name
+        @tag_name ||= %Q(#{Time.now.strftime(TIMESTAMP_FORMAT)}#{"_#{suffix}" if suffix})
+      end
+
+      def changelog
+        @changelog ||= Changelog.new
+      end
+
+      def update_changelog
+        changelog.open do |log|
+          log.puts "#### #{tag_name}"
+        end
+        git.perform("add #{changelog.filename}")
+        git.perform("commit -m 'Updating Changelog for #{tag_name}'")
+      end
+
+    end
+  end
+
+  WrongBranch = Class.new(StandardError)
+end
+

data/lib/octopolo/templates/pull_request_body.erb

@@ -0,0 +1,24 @@
+<%= description %>
+
+Deploy Plan
+-----------
+Does Infrastructure need to know anything special about this deploy? If so, keep this section and fill it in. **Otherwise, delete it.**
+
+Rollback Plan
+-------------
+**If this pull request requires anything more complex (e.g., rolling back a migration), you MUST update this section. Otherwise, delete this note.**
+
+To roll back this change, revert the merge with `git revert -m 1 MERGE_SHA` and perform another deploy.
+
+URLs
+----
+<% pivotal_ids.each do |pivotal_id| -%>
+* [pivotal tracker story <%= pivotal_id %>](https://www.pivotaltracker.com/story/show/<%= pivotal_id %>)
+<% end -%>
+<% jira_ids.each do |jira_id| -%>
+* [Jira issue <%= jira_id %>](<%= jira_url %>/browse/<%= jira_id %>)
+<% end -%>
+
+QA Plan
+-------
+Provide a detailed QA plan, or other developers will retain the right to mock you mercilessly.

data/lib/octopolo/user_config.rb

@@ -0,0 +1,112 @@
+module Octopolo
+  class UserConfig
+    # config values
+    attr_accessor :github_user
+    attr_accessor :github_token
+    attr_accessor :full_name
+    attr_accessor :pivotal_token
+    attr_accessor :attributes # keep the whole hash
+
+    # Public: Initialize a new UserConfig instance
+    def initialize attributes={}
+      self.attributes = attributes
+      attributes.each do |key, value|
+        # e.g., foo: "bar" translates to self.foo = "bar"
+        setter = "#{key}="
+        send(setter, value) if respond_to? setter
+      end
+    end
+
+    # Public: Parse the user's config file
+    #
+    # Returns a UserConfig instance
+    def self.parse
+      new attributes_from_file
+    end
+
+    # Public: Set and store a new configuration value
+    def set key, value
+      # capture new value in instance
+      send("#{key}=", value)
+      attributes.merge!(key => value)
+      # and store it
+      File.write UserConfig.config_path, YAML.dump(attributes)
+    end
+
+    # Public: The user's configuration values
+    #
+    # Returns a Hash
+    def self.attributes_from_file
+      YAML.load_file config_path
+    rescue Errno::ENOENT
+      # create the file if it doesn't exist
+      touch_config_file
+      {}
+    end
+
+    # Public: The path to the users's configuration file
+    #
+    # Returns a String containing the path
+    def self.config_path
+      File.join(config_parent, "config.yml")
+    end
+
+    # Public: The parent directory of the user's configuration file
+    #
+    # Returns a String containing the path
+    def self.config_parent
+      dir = File.expand_path("~/.octopolo")
+      dir = File.expand_path("~/.automation") unless Dir.exists?(dir)
+      dir
+    end
+
+    # Public: Create the user's configuration file
+    # NOTE this seems a mite gnarly, and its tests worse, but doesn't seem worth splitting out into "create_config_parent_directory" and "create_config_file" at this stage
+    def self.touch_config_file
+      unless Dir.exist? config_parent
+        Dir.mkdir config_parent
+      end
+
+      unless File.exist? config_path
+        File.write UserConfig.config_path, YAML.dump({})
+      end
+    end
+
+    # Public: The user's name
+    #
+    # Returns a String
+    def full_name
+      @full_name || ENV["USER"]
+    end
+
+    # Public: The GitHub username
+    #
+    # If none is stored, generate it for the user.
+    #
+    # Returns a String or raises MissingGitHubAuth
+    def github_user
+      @github_user || raise(MissingGitHubAuth)
+    end
+
+    # Public: The GitHub token
+    #
+    # If none is stored, generate it for the user.
+    #
+    # Returns a String or raises MissingGitHubAuth
+    def github_token
+      @github_token || raise(MissingGitHubAuth)
+    end
+
+    # Public: The Pivotal Tracker token
+    #
+    # If none is stored, prompt them to generate it.
+    #
+    # Returns a String or raises MissingPivotalAuth
+    def pivotal_token
+      @pivotal_token || raise(MissingPivotalAuth)
+    end
+
+    MissingGitHubAuth = Class.new(StandardError)
+    MissingPivotalAuth = Class.new(StandardError)
+  end
+end

data/lib/octopolo/version.rb

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

data/lib/octopolo/week.rb

@@ -0,0 +1,130 @@
+module Octopolo
+  class Week
+    attr_accessor :year
+    attr_accessor :number
+
+    DATE_STRING_FORMAT = "%Y-%m-%d"
+
+    # Public: Instantiate a new Week
+    #
+    # year - Year the week occurs in
+    # number - The number of the week in the given year
+    def initialize year, number
+      self.year = year
+      self.number = number
+    end
+
+    # Public: Parse the date from a date-ish object
+    #
+    # dateish - A Date, Time, or String representing a date or time
+    def self.parse dateish
+      # TODO i'm not 100% happy with this implementation, but it does what i want and the tests pass
+      if dateish.respond_to? :to_date
+        date = dateish.to_date
+        new date.year, date.cweek
+      else
+        date = Date.parse(dateish.to_s)
+        new date.year, date.cweek
+      end
+    rescue ArgumentError
+      raise InvalidType
+    end
+
+    # Public: Instantiate a Week for the current week
+    #
+    # Returns an instance of Week
+    def self.current
+      today = Date.today
+      Week.new today.cwyear, today.cweek
+    end
+
+    # Public: Instantiate a Week for the prior week
+    #
+    # Returns an instance of Week
+    def self.prior
+      current.previous
+    end
+
+    # Public: A list of the last N weeks, excluding the current week
+    #
+    # count - An integer listing the number of weeks to return
+    #
+    # Returns an Array of Week instances
+    def self.last count
+      # holy hell this is gnarly
+      #
+      # essentially, create an array with the current week in it, then loop
+      # through and tack on the previous week for whichever week is last; this
+      # way, we keep tacking on ever more previous weeks as many times as is
+      # asked for.
+      out = [prior]
+      (count - 1).times do
+        out << out.last.previous
+      end
+      out
+    end
+
+    # Public: Friendly string representation of the week
+    #
+    # Returns a String of the start date
+    def to_s
+      start_date.strftime(DATE_STRING_FORMAT)
+    end
+
+    # Public: Programmer-friendly representation of the week
+    #
+    # Returns a String containing object details
+    def inspect
+      "#<#{self.class} #{to_s} (year=#{year} number=#{number})>"
+    end
+
+    # Public: Whether the week is the same as another week
+    #
+    # Returns a Boolean
+    def == other
+      year == other.year && number == other.number
+    rescue
+      false
+    end
+
+    # Public: The previous week
+    #
+    # Returns an instance of Week
+    def previous
+      if number == 1
+        # carry the 1
+        Week.new year - 1, 52
+      else
+        Week.new year, number - 1
+      end
+    end
+
+    # Public: The next week
+    #
+    # Returns an instance of Week
+    def next
+      if number == 52
+        # carry the 1
+        Week.new year + 1, 1
+      else
+        Week.new year, number + 1
+      end
+    end
+
+    # Public: Monday that starts the week
+    #
+    # Returns an instance of Date
+    def start_date
+      Date.commercial year, number
+    end
+
+    # Public:  Sunday that ends the week
+    #
+    # Returns an instance of Date
+    def end_date
+      Date.commercial year, number, 7
+    end
+
+    InvalidType = Class.new(StandardError)
+  end
+end

data/octopolo.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/octopolo/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Patrick Byrne", "Luke Ludwig"]
+  gem.email         = ["patrick.byrne@sportngin.com", "luke.ludwig@sportngin.com"]
+  gem.description   = %q{A set of Github workflow scripts.}
+  gem.summary       = %q{A set of Github workflow scripts.}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "octopolo"
+  gem.license       = "MIT"
+  gem.require_paths = ["lib"]
+  gem.version       = Octopolo::VERSION
+
+  gem.add_dependency 'rake'
+  gem.add_dependency 'gli', '~> 2.10'
+  gem.add_dependency 'hashie', '~> 1.2'
+  gem.add_dependency 'octokit', '~> 2.7.1'
+  gem.add_dependency 'highline', '~> 1.6'
+  gem.add_dependency 'pivotal-tracker', '~> 0.5'
+  gem.add_dependency 'jiralicious'
+
+  gem.add_development_dependency 'rspec', '~> 2.11.0'
+  gem.add_development_dependency "guard"
+  gem.add_development_dependency "guard-rspec"
+  gem.add_development_dependency 'octopolo-plugin-example'
+end

data/spec/octopolo/cli_spec.rb

@@ -0,0 +1,310 @@
+require "spec_helper"
+
+module Octopolo
+  describe CLI do
+    subject { CLI }
+
+    context ".perform(command)" do
+      let(:command) { "ls" }
+      let(:result) { "result" }
+      let(:error) { "error message" }
+      let(:exception_message) { "Error with something" }
+
+      it "passes the given command to the shell" do
+        subject.should_receive(:say).with(command)
+        Open3.should_receive(:capture3).with(command).and_return([result, nil])
+        subject.should_receive(:say).with(result)
+        subject.perform(command).should == result
+      end
+
+      it "uses Kernel#` if Open3 has no capture3 method (e.g., Ruby 1.8.7)" do
+        subject.should_receive(:say).with(command)
+        # simulating ruby 1.8.7 not having an Open3.capture3 method
+        Open3.should_receive(:respond_to?).with(:capture3).and_return(false)
+        subject.should_receive(:`).with(command).and_return(result)
+        subject.should_receive(:say).with(result)
+        subject.perform(command).should == result
+      end
+
+      it "should handle errors gracefully" do
+        subject.should_receive(:say).with(command)
+        Open3.should_receive(:capture3).with(command).and_raise(exception_message)
+        subject.should_receive(:say).with("Unable to perform '#{command}': #{exception_message}")
+        subject.perform(command).should be_nil
+      end
+
+      it "should not speak the command if told not to" do
+        subject.should_receive(:say).with(command).never
+        subject.perform(command, false)
+      end
+    end
+
+    context ".perform_quietly(command)" do
+      let(:command) { "ls" }
+
+      it "performs the command without displaying itself" do
+        subject.should_receive(:perform).with(command, false)
+        subject.perform_quietly(command)
+      end
+    end
+
+    context ".perform_and_exit(command)" do
+      let(:command) { "ls" }
+
+      it "should use the 'exec' command to replace the Ruby process with the command" do
+        subject.should_receive(:say).with(command)
+        subject.should_receive(:exec).with(command)
+        subject.perform_and_exit(command)
+      end
+    end
+
+    context ".say(message)" do
+      let(:message) { "asdf" }
+
+      it "displays the given message" do
+        subject.should_receive(:puts).with(message)
+        subject.say message
+      end
+
+      it "does nothing if the message is nil" do
+        subject.should_receive(:puts).never
+        subject.say nil
+      end
+
+      it "does nothing if the message is an empty string" do
+        subject.should_receive(:puts).never
+        subject.say ""
+      end
+    end
+
+    context ".spacer_line" do
+      it "displays a blank space" do
+        subject.should_receive(:say).with(" ")
+        subject.spacer_line
+      end
+    end
+
+    context ".perform_in(dir, &block)" do
+      let(:dir) { "/tmp" }
+      let(:command) { "ls" }
+
+      it "changes the script to the given directory" do
+        subject.should_receive(:say).with("Performing in #{dir}:")
+        Dir.should_receive(:chdir).with(dir).and_yield
+        subject.should_receive(:perform).with(command)
+
+        subject.perform_in(dir) do
+          subject.perform(command)
+        end
+      end
+    end
+
+    context ".ask(question, choices)" do
+      let(:question) { "What do you want to eat?" }
+      let(:choices) { ["sandwich", "carrots", "cake"] }
+      let(:one_choice) { [choices.first] }
+      let(:valid_string_answer) { choices[valid_numeric_answer - 1] }
+      let(:invalid_string_answer) { "pineapple" }
+      # answers start at 1, not at 0, so +1
+      let(:valid_numeric_answer) { rand(choices.size) + 1 }
+      let(:invalid_low_numeric_answer) { 0 }
+      let(:invalid_high_numeric_answer) { choices.size + 2 }
+
+      it "provides the given list of choices for the given question" do
+        subject.should_receive(:say).with(question)
+        subject.should_receive(:say).with("1) sandwich")
+        subject.should_receive(:say).with("2) carrots")
+        subject.should_receive(:say).with("3) cake")
+        subject.should_receive(:prompt).and_return(valid_string_answer) # only specifying return value to prevent infinite loop
+
+        subject.ask(question, choices)
+      end
+
+      it "skips printing the question and choices if told not to (useful to avoid cluttering spec output)" do
+        subject.should_receive(:say).with(question).never
+        subject.should_receive(:say).with("1) sandwich").never
+        subject.should_receive(:say).with("2) carrots").never
+        subject.should_receive(:say).with("3) cake").never
+        subject.should_receive(:prompt).and_return(valid_string_answer) # only specifying return value to prevent infinite loop
+
+        subject.ask(question, choices, true)
+      end
+
+      it "simply returns the value if given only one choice" do
+        subject.should_receive(:say).never
+        subject.should_receive(:prompt).never
+
+        subject.ask(question, one_choice).should == one_choice.first
+      end
+
+      context "when answering with the string value" do
+        it "returns the user's selection, if in the available choices" do
+          subject.should_receive(:prompt).and_return(valid_string_answer)
+          subject.ask(question, choices, true).should == valid_string_answer
+        end
+
+        it "asks again if given a string other than one of the choices" do
+          subject.should_receive(:prompt).and_return(invalid_string_answer)
+          subject.should_receive(:say).with("Not a valid choice.")
+          subject.should_receive(:prompt).and_return(valid_string_answer)
+
+          subject.ask(question, choices, true).should == valid_string_answer
+        end
+      end
+
+      context "when answering with the numeric value" do
+        it "returns the user's selection, if in the available choices" do
+          subject.should_receive(:prompt).and_return(valid_numeric_answer)
+          subject.ask(question, choices, true).should == valid_string_answer
+        end
+
+        it "asks again if given a answer 0 or less" do
+          subject.should_receive(:prompt).and_return(invalid_low_numeric_answer)
+          subject.should_receive(:say).with("Not a valid choice.")
+          subject.should_receive(:prompt).and_return(valid_numeric_answer)
+
+          subject.ask(question, choices, true).should == valid_string_answer
+        end
+
+        it "asks again if given a answer greater than the list of choices" do
+          subject.should_receive(:prompt).and_return(invalid_high_numeric_answer)
+          subject.should_receive(:say).with("Not a valid choice.")
+          subject.should_receive(:prompt).and_return(valid_numeric_answer)
+
+          subject.ask(question, choices, true).should == valid_string_answer
+        end
+      end
+    end
+
+    context ".ask_boolean question" do
+      let(:question) { "Are you truly happy?" }
+
+      it "asks the question and prompts for an answer" do
+        subject.should_receive(:prompt).with("#{question} (y/n)") { "y" }
+        subject.ask_boolean(question)
+      end
+
+      it "returns true for 'y'" do
+        subject.should_receive(:prompt) { "y" }
+        subject.ask_boolean(question).should be_true
+      end
+
+      it "returns true for 'yes'" do
+        subject.should_receive(:prompt) { "yes" }
+        subject.ask_boolean(question).should be_true
+      end
+
+      it "returns true for 'Y'" do
+        subject.should_receive(:prompt) { "Y" }
+        subject.ask_boolean(question).should be_true
+      end
+
+      it "returns false for 'n'" do
+        subject.should_receive(:prompt) { "n" }
+        subject.ask_boolean(question).should be_false
+      end
+
+      it "returns false for 'no'" do
+        subject.should_receive(:prompt) { "no" }
+        subject.ask_boolean(question).should be_false
+      end
+
+      it "returns false for 'N'" do
+        subject.should_receive(:prompt) { "N" }
+        subject.ask_boolean(question).should be_false
+      end
+    end
+
+    context ".prompt prompt_text" do
+      let(:input) { "asdf" }
+      let(:highline) { stub }
+      let(:prompt_text) { "Foo: " }
+
+      before do
+        subject.stub(highline: highline)
+      end
+
+      it "retrieves response from the user" do
+        highline.should_receive(:ask).with("> ").and_return(input)
+
+        subject.prompt.should == input
+      end
+
+      it "uses the given text as the prompt" do
+        highline.should_receive(:ask).with(prompt_text)
+
+        subject.prompt prompt_text
+      end
+    end
+
+    context ".prompt_secret prompt_text" do
+      let(:input) { "asdf" }
+      let(:prompt_text) { "Foo: " }
+      let(:highline) { stub }
+      let(:highline_config) { stub }
+
+      before do
+        subject.stub(highline: highline)
+      end
+
+      it "retrieves response from the user without displaying what they type" do
+        highline.should_receive(:ask).with(prompt_text).and_yield(highline_config).and_return(input)
+        highline_config.should_receive(:echo=).with(false)
+        highline_config.should_receive(:readline=).with(true)
+        subject.prompt_secret(prompt_text).should == input
+      end
+    end
+
+    context ".prompt_multiline prompt_text" do
+      let(:input) { %w(a s d f) }
+      let(:prompt_text) { "Steps:" }
+      let(:highline) { stub }
+      let(:highline_config) { stub }
+
+      before do
+        subject.stub(highline: highline)
+      end
+
+      it "retreives response from the user across multiple lines, returning an array of their input" do
+        highline.should_receive(:ask).with(prompt_text).and_yield(highline_config).and_return(input)
+        highline_config.should_receive(:gather=).with("")
+        highline_config.should_receive(:readline=).with(true)
+        subject.prompt_multiline(prompt_text).should == input
+      end
+    end
+
+    context ".highline" do
+      let(:result) { stub }
+
+      it "instantiates a HighLine object" do
+        HighLine.should_receive(:new) { result }
+        subject.highline.should == result
+      end
+    end
+
+    context ".open path" do
+      let(:path) { "http://example.com/" }
+
+      it "exits and opens the path with Mac OS X's `open` command" do
+        subject.should_receive(:perform_and_exit).with("open '#{path}'")
+        subject.open path
+      end
+    end
+
+    context ".copy_to_clipboard(input)" do
+      let(:input) { "something#{rand(1000)}" }
+
+      # FIXME figure out a better way to test this on non-Mac systems, which don't have pbcopy or pbpaste
+      #
+      # only run on the test on a mac and when not in tmux
+      if RUBY_PLATFORM.include?("darwin") and !ENV['TMUX']
+        it "puts the text on the system clipboard (for pasting)" do
+          subject.should_receive(:say).with("Putting '#{input}' on the clipboard.")
+          subject.copy_to_clipboard input
+          # and to test that it's on the clipboard
+          `pbpaste`.should == input
+        end
+      end
+    end
+  end
+end