startling 0.0.2

data/lib/startling/commands/base.rb

@@ -0,0 +1,83 @@
+module Startling
+  module Commands
+    class Base
+      attr_reader :cli_options
+
+      def self.run(attrs={})
+        new(attrs).execute
+      end
+
+      def initialize(attrs={})
+        @cli_options = attrs
+        attrs.each do |attr, value|
+          self.class.__send__(:attr_reader, attr)
+          instance_variable_set("@#{attr}", value)
+        end
+      end
+
+      def execute
+        raise NotImplementedError
+      end
+
+      def self.load_configuration
+        loaded_configuration_path = Startling::Configuration.load_configuration
+        if loaded_configuration_path
+          puts "Loading configuration #{loaded_configuration_path}"
+        else
+          puts "Using default configuration"
+        end
+      end
+
+      def self.load_commands
+        loaded_commands_path = Startling::Configuration.load_commands
+        if loaded_commands_path
+          puts "Loading commands #{loaded_commands_path}"
+        end
+      end
+
+      def self.load_handlers
+        loaded_handlers_path = Startling::Configuration.load_handlers
+        if loaded_handlers_path
+          puts "Loading handlers #{loaded_handlers_path}"
+        end
+      end
+
+      def handler_class(handler)
+        begin
+          Startling::Handlers.const_get(to_camel_case(handler.to_s))
+        rescue NameError
+          print_name_error_message(handler, Startling::Configuration::DEFAULT_HANDLER_PATH)
+          exit
+        end
+      end
+
+      def command_class(command)
+        begin
+          Startling::Commands.const_get(to_camel_case(command.to_s))
+        rescue NameError
+          print_name_error_message(command, Startling::Configuration::DEFAULT_COMMAND_PATH)
+          exit
+        end
+      end
+
+      def print_name_error_message(name, path)
+        puts "Error loading #{to_camel_case(name.to_s)}. Is it defined in #{path}?"
+      end
+
+      def print_args(context)
+        puts "== Instance vars from #{context} ==>"
+        instance_variables.each do |var|
+          puts "#{var}: #{instance_variable_get(var)}"
+        end
+      end
+
+      def to_camel_case(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+        if first_letter_in_uppercase
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+        else
+          lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+        end
+      end
+    end
+  end
+end

data/lib/startling/commands/check_for_local_mods.rb

@@ -0,0 +1,17 @@
+require_relative '../git_local'
+
+require_relative "base"
+
+module Startling
+  module Commands
+    class CheckForLocalMods < Base
+      def execute
+        return if git.status.empty?
+
+        puts "Local modifications detected, please stash or something."
+        system("git status -s")
+        exit 1
+      end
+    end
+  end
+end

data/lib/startling/commands/create_branch.rb

@@ -0,0 +1,53 @@
+require_relative "base"
+
+module Startling
+  module Commands
+    class CreateBranch < Base
+      def execute
+        create_branch if branch_name != git.current_branch
+        branch_name
+      end
+
+      def repo
+        @repo ||= Github.repo(git.repo_name)
+      end
+
+      def create_branch
+        puts "Creating branch #{branch_name}..."
+        git.create_remote_branch(branch_name, base_branch: "origin/#{default_branch}")
+      end
+
+      def default_branch
+        repo.default_branch
+      end
+
+      def branch_name
+        @branch_name ||= get_branch_name
+      end
+
+      def get_branch_name
+        if branch.empty?
+          if git.current_branch_is_a_feature_branch?
+            return git.current_branch
+          else
+            abort "Branch name must be specified when current branch is not feature/."
+          end
+        end
+
+        branch.gsub!(/feature\//, '')
+        "feature/#{branch}".gsub(/\s+/, '-')
+      end
+
+      private
+
+      def branch
+        @branch ||=
+          if args.length > 1
+            args[1..-1].map(&:downcase).join('-')
+          else
+            ask("Enter branch name (enter for current branch): ")
+          end
+      end
+    end
+  end
+end

data/lib/startling/commands/create_pull_request.rb

@@ -0,0 +1,35 @@
+require_relative "base"
+require_relative 'create_branch'
+
+module Startling
+  module Commands
+    class CreatePullRequest < Base
+      def execute
+        create_branch
+        open_pull_request
+      end
+
+      def create_branch
+        @branch_name ||= CreateBranch.run(args: args, git: git)
+      end
+
+      def open_pull_request
+        puts "Opening pull request..."
+        git.create_empty_commit(pull_request_handler.commit_message)
+        git.push_origin_head
+
+        repo.open_pull_request title: pull_request_handler.title,
+          body: pull_request_handler.body, branch: @branch_name
+      end
+
+      def repo
+        @repo ||= Github.repo(git.repo_name)
+      end
+
+      def pull_request_handler
+        handler_name = Startling.pull_request_handler || :default_pull_request_handler
+        handler_class(handler_name).new(cli_options)
+      end
+    end
+  end
+end

data/lib/startling/commands/label_pull_request.rb

@@ -0,0 +1,15 @@
+require_relative "base"
+
+module Startling
+  module Commands
+    class LabelPullRequest < Base
+      def execute
+        repo.set_labels_for_issue issue_id: pull_request.id, labels: Startling.pull_request_labels
+      end
+
+      def repo
+        Github.repo(git.repo_name)
+      end
+    end
+  end
+end

data/lib/startling/configuration.rb

@@ -0,0 +1,106 @@
+require 'startling/git_local'
+require 'startling/github'
+require 'startling/colorize_string'
+require 'startling/commands/label_pull_request'
+require 'startling/handlers/default_pull_request_handler'
+
+module Startling
+  class Configuration
+    DEFAULT_COMMAND_PATH = "startling/commands"
+    DEFAULT_HANDLER_PATH = "startling/handlers"
+    DEFAULT_WIP_LIMIT = 4
+    DEFAULT_COMMIT_MESSAGE = "Startling"
+    DEFAULT_BODY = "Startling"
+
+    DEFAULT_STARTLINGFILES = [
+      'startlingfile.rb',
+      'Startlingfile.rb'
+    ].freeze
+
+    attr_accessor :cache_dir, :root_dir, :wip_limit, :repos, :story_handler, :pull_request_body,
+      :pull_request_handler, :pull_request_labels, :pull_request_commit_message, :cli_options
+
+    def initialize
+      @cache_dir = Dir.pwd
+      @root_dir = Dir.pwd
+      @wip_limit = DEFAULT_WIP_LIMIT
+      @repos = []
+      @story_handler = nil
+      @pull_request_handler = nil
+      @pull_request_body = DEFAULT_BODY
+      @pull_request_commit_message = DEFAULT_COMMIT_MESSAGE
+      @pull_request_labels = []
+      @cli_options = []
+    end
+
+    def self.load_configuration
+      DEFAULT_STARTLINGFILES.each do |file_name|
+        if Dir.entries(Startling::GitLocal.new.project_root).include? file_name
+          load "#{Startling::GitLocal.new.project_root}/#{file_name}"
+          return file_name
+        end
+      end
+      nil
+    end
+
+    def self.load_commands(path=DEFAULT_COMMAND_PATH)
+      load_path(path)
+    end
+
+    def self.load_handlers(path=DEFAULT_HANDLER_PATH)
+      load_path(path)
+    end
+
+    def self.load_path(path)
+      directory = File.join(Startling::GitLocal.new.project_root, path, "*")
+      return unless directory
+      Dir.glob(directory).each do |file|
+        load "#{file}"
+      end
+      directory
+    end
+
+    def hook_commands
+      @hooks ||= HookCommands.new
+    end
+
+    def add_cli_option(abbr_switch, full_switch, description, required=false)
+      @cli_options << CliOption.new(abbr_switch, full_switch, description, required)
+    end
+
+    def cli_options
+      @cli_options ||= []
+    end
+
+    class HookCommands
+      attr_accessor :before_story_start, :after_story_start,
+      :before_pull_request, :create_pull_request, :after_pull_request
+
+      def initialize
+        @before_story_start = []
+        @after_story_start = []
+        @before_pull_request = []
+        @after_pull_request = [:label_pull_request]
+      end
+    end
+
+    class CliOption
+      attr_reader :abbr_switch, :description, :full_switch
+
+      def initialize(abbr_switch, full_switch, description, required)
+        @abbr_switch = abbr_switch
+        @full_switch = full_switch
+        @description = description
+        @required = required
+      end
+
+      def long_switch
+        @required ? "--#{@full_switch} #{@full_switch}" : "--#{@full_switch}"
+      end
+
+      def sym
+        full_switch.to_s
+      end
+    end
+  end
+end

data/lib/startling/git_local.rb

@@ -0,0 +1,61 @@
+require_relative 'shell'
+
+module Startling
+  class GitLocal
+    def current_branch
+      `git symbolic-ref -q --short HEAD`.strip
+    end
+
+    def checkout_branch(branch)
+      Shell.run "git checkout #{branch}"
+    end
+
+    def status
+      Shell.run "git status --porcelain"
+    end
+
+    def remote_branches
+      Shell.run "git branch -r"
+    end
+
+    def local_branches
+      Shell.run "git branch"
+    end
+
+    def create_empty_commit(message)
+      Shell.run "git commit --allow-empty -m #{message}"
+    end
+
+    def create_remote_branch(branch_name, base_branch: 'origin/master')
+      Shell.run "git fetch -q"
+      Shell.run "git checkout -q #{branch_name} 2>/dev/null || git checkout -q -b #{branch_name} #{base_branch}"
+    end
+
+    def push_origin_head
+      Shell.run "git push -qu origin HEAD"
+    end
+
+    def destroy_branch(branch)
+      Shell.run "git push origin :#{branch}" if remote_branches.include? branch
+      Shell.run "git branch -D #{branch}" if local_branches.include? branch
+    end
+
+    def repo_name
+      remote_url[%r{([^/:]+/[^/]+)\.git}, 1]
+    end
+
+    def current_branch_is_a_feature_branch?
+       current_branch =~ %r{^feature/}
+    end
+
+    def project_root
+     `git rev-parse --show-toplevel`.strip
+    end
+
+    private
+
+    def remote_url
+      `git config --get remote.origin.url`.strip
+    end
+  end
+end

data/lib/startling/github.rb

@@ -0,0 +1,16 @@
+require 'octokit'
+
+require_relative 'github/repo'
+require_relative 'github/api'
+
+module Startling
+  module Github
+    def self.api
+      @api ||= Github::Api.new
+    end
+
+    def self.repo(name)
+      api.repository(name)
+    end
+  end
+end

data/lib/startling/github/api.rb

@@ -0,0 +1,106 @@
+require 'parallel'
+require 'faraday'
+require_relative 'pull_request'
+
+module Startling
+  module Github
+    class Api
+      def initialize
+        @lock = Mutex.new
+        @repositories = {}
+      end
+
+      def pull_requests(repo)
+        raw = octokit.pull_requests(repo, state: 'open')
+        Parallel.map(raw, in_threads: raw.count) do |pull|
+          PullRequest.new(pull).tap do |pull_request|
+            pull_request.labels = labels_for_issue(repo_name: repo, issue_id: pull_request.id)
+          end
+        end
+      end
+
+      def repository(name)
+        Repo.new name, self
+      end
+
+      def repository_attributes(name)
+        octokit.repository(name)
+      end
+
+      def open_pull_request(title: nil, body: nil, branch: nil,
+        destination_branch: nil, repo_name: nil)
+        response = octokit.create_pull_request(repo_name, destination_branch, branch, title, body)
+        response.data
+      rescue Octokit::UnprocessableEntity => e
+        puts "Failed to open pull request, it may be open already"
+        p e
+        nil
+      end
+
+      def labels_for_issue(repo_name: nil, issue_id: nil)
+        octokit.labels_for_issue(repo_name, issue_id)
+      end
+
+      def set_labels_for_issue(repo_name: nil, issue_id: nil, labels: nil)
+        octokit.replace_all_labels(repo_name, issue_id, labels)
+      end
+
+      def pull_request(repo_name, branch)
+        repository(repo_name).pull_request(branch)
+      end
+
+      private
+      attr_reader :lock, :repositories
+
+      def octokit
+        lock.synchronize do
+          @octokit ||= build_octokit
+        end
+      end
+
+      def build_octokit
+        stack = faraday_builder_class.new do |builder|
+          #builder.response :logger
+          builder.use Octokit::Response::RaiseError
+          builder.adapter Faraday.default_adapter
+        end
+        Octokit.middleware = stack
+        Octokit::Client.new access_token: access_token
+      end
+
+      def faraday_builder_class
+        defined?(Faraday::RackBuilder) ? Faraday::RackBuilder : Faraday::Builder
+      end
+
+      def access_token
+        Startling.cache.fetch('.github_access_token') do
+          client = Octokit::Client.new(login: prompt_for_login, password: prompt_for_password)
+          authorization_opts = {}
+          authorization_opts[:scopes] = ["repo"]
+          authorization_opts[:note] = "startling on #{`echo $HOSTNAME`}"
+          begin
+            client.create_authorization(authorization_opts)[:token]
+          rescue Octokit::OneTimePasswordRequired
+            authorization_opts[:headers] = { "X-GitHub-OTP" => prompt_for_otp }
+            retry
+          rescue Octokit::Unauthorized
+            puts "Invalid username or password, try again."
+            retry
+          end
+        end
+      end
+
+      def prompt_for_login
+        ask("Enter your Github username:  ")
+      end
+
+      def prompt_for_password
+        ask("Enter your Github password:  ") { |q| q.echo = false }
+      end
+
+      def prompt_for_otp
+        ask("Enter your one time password:  ")
+      end
+    end
+  end
+end