hustle_and_flow 0.0.1 → 0.0.2

data/lib/hustle_and_flow/issue_trackers/github/issues.rb

@@ -0,0 +1,89 @@
+require 'hustle_and_flow/issue_trackers/github/issue'
+require 'hustle_and_flow/formatters/issue_table_formatter'
+
+module  HustleAndFlow
+module  IssueTrackers
+class   Github
+class   Issues
+  include Enumerable
+
+  attr_accessor :tracker,
+                :query,
+                :issues
+
+  def initialize(tracker:, issues: nil, query: { state: :all })
+    self.tracker = tracker
+    self.query   = query
+    self.issues  = issues
+  end
+
+  def self.start(tracker:, issues: nil, io:, me:, issue_data:)
+    new(tracker: tracker,
+        issues:  issues).
+    start(io:         io,
+          me:         me,
+          issue_data: issue_data)
+  end
+
+  def start(io:, me:, issue_data:)
+    issue_data = issue_data.merge(status: 'open')
+
+    unless issue_specified?(issue_data)
+      applicable_issues = filter_by(issue_data)
+
+      io.print_formatted_table \
+        data:  Formatters::IssueTableFormatter.new(applicable_issues).to_ary,
+        title: 'Available Issues'
+
+      issue_data[:number] = io.choose_issue until issue_specified?(issue_data)
+    end
+
+    find_or_create(issue_data).start(me: me)
+  end
+
+  def find_or_create(**args)
+    find(**args) || Issue.create(tracker: tracker, **args)
+  end
+
+  def each
+    issues.each do |issue|
+      yield issue
+    end
+  end
+
+  private
+
+  def filter_by(*args)
+    self.class.new(tracker: tracker,
+                   issues:  issues.select do |issue|
+                              issue if issue.match?(*args)
+                            end)
+  end
+
+  def find(type: nil, title: nil, number: nil, **args)
+    issues.find do |issue|
+      issue.match?(type: type, title: title) ||
+      issue.match?(number: number.to_i)
+    end
+  end
+
+  def issues
+    @issues ||= client.
+                issues(tracker.repo_name, query).
+                map do |issue_data|
+                  Issue.new(tracker: tracker,
+                            data:    issue_data)
+                end
+  end
+
+  def issue_specified?(data)
+    (data[:type] && data[:title]) || data[:number]
+  end
+
+  def client
+    tracker.client
+  end
+end
+end
+end
+end

data/lib/hustle_and_flow/issue_trackers/github.rb

@@ -0,0 +1,71 @@
+require 'octokit'
+require 'hustle_and_flow/issue_trackers/github/issue'
+require 'hustle_and_flow/issue_trackers/github/issues'
+
+module  HustleAndFlow
+module  IssueTrackers
+class   Github
+  attr_accessor :client,
+                :repo,
+                :source
+
+  def initialize(repo:)
+    Octokit.auto_paginate = true
+
+    self.client = Octokit::Client.new(netrc: true)
+    self.repo   = repo
+  end
+
+  def repo_name
+    repo.base_name
+  end
+
+  def start(io:, me:, issue_data:)
+    Issues.start(tracker:    self,
+                 io:         io,
+                 me:         me,
+                 issue_data: issue_data)
+  end
+
+  # def ready_for_review(branch)
+  #   #
+  #   # No issue number
+  #   #   Find by title
+  #   # Has issue number
+  #   #   Find by number
+  #   #
+  #   # Issue found
+  #   #   Issue closed
+  #   #     Ask to reopen issue
+  #   #   Issue open
+  #   #     Issue being reviewed
+  #   #     Issue not being reviewed
+  #   # Issue not found
+  #   #   Ask to create issue
+  #   #
+  #   # Lookup Pull Request from Issue and Version Number
+  #   #
+  #   # Pull Request Found
+  #   #   How are PR's found?
+  #   #
+  #   #   PR Title Format: #15 v1 - My Issue Title
+  #   #
+  #   #   Pull Request Closed
+  #   #     Reopen PR
+  #   #   Pull Request Open
+  #   #     Use found PR
+  #   # Pull Request Not Found
+  #   #   Create New PR
+  #   #
+  #   pull_request = PullRequest.find_or_create_from_branch_name(branch.name)
+  #   issue        = Issue.find_or_create_from_branch_name(branch.name)
+  #
+  #   issue.ready_for_review(reviewer_names: branch.overwritten_authors)
+  # end
+  #
+  # def update_pull_request(branch)
+  #   client.create_pull_request()
+  # end
+end
+end
+end

data/lib/hustle_and_flow/utils/string.rb

@@ -0,0 +1,25 @@
+module  HustleAndFlow
+module  Utils
+module  String
+  def underscore(camel_cased_word)
+    word = camel_cased_word.to_s.gsub('::', '/')
+    word.gsub!(/(?:([A-Za-z\d])|^)(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}" }
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    word.tr!('-', '_')
+    word.chomp!('_')
+    word.downcase!
+    word
+  end
+
+  def titleize(other)
+    result = other.to_s.dup
+    result = underscore(result)
+    result = result.tr('_', ' ')
+    result = result.downcase
+
+    result.gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
+  end
+end
+end
+end

data/lib/hustle_and_flow/utils/url_slug.rb

@@ -0,0 +1,28 @@
+###
+# Public: Responsible for converting strings into URL Slugs
+#
+module  HustleAndFlow
+module  Utils
+class   UrlSlug
+  def initialize(original_string)
+    self.original_string = original_string || ''
+  end
+
+  def to_s
+    original_string.
+      downcase.                 # Lowercase the string
+      strip.                    # Remove all leading and trailing spaces
+      gsub(/-+\z/, '').         # Remove any dashes at the end
+      gsub(/\A-+/, '').         # Remove any dashes at the beginning
+      gsub(/[^\w\-\s]|_/, '').  # Remove any non-alphanumerics, dashes or spaces
+      gsub(/\s+/, '-').         # Consolidate remaining consecutive space and
+                                # convert to dashes
+      gsub(/-+/, '-')           # Consolidate consecutive dashes into one dash
+  end
+
+  protected
+
+  attr_accessor :original_string
+end
+end
+end

data/lib/hustle_and_flow/vcs_repository.rb

@@ -0,0 +1,19 @@
+require 'hustle_and_flow/version_control/git/repository'
+
+module  HustleAndFlow
+class   VcsRepository
+  attr_accessor :adapter
+
+  def initialize(**args)
+    self.adapter = HustleAndFlow::
+                   VersionControl::
+                   Git::
+                   Repository.
+                   new(path: args[:path])
+  end
+
+  def method_missing(name, *args)
+    adapter.public_send(name, *args)
+  end
+end
+end

data/lib/hustle_and_flow/version.rb

@@ -1,3 +1,3 @@
 module HustleAndFlow
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/hustle_and_flow/version_control/git/branch.rb

@@ -0,0 +1,136 @@
+module  HustleAndFlow
+module  VersionControl
+module  Git
+class   Branch
+  attr_accessor :repo,
+                :branch
+
+  def initialize(repo:, branch:)
+    self.repo   = repo
+    self.branch = branch
+  end
+
+  def current?
+    local? && branch.current
+  end
+
+  def local?
+    !remote?
+  end
+
+  def remote?
+    !branch.remote.to_s.empty?
+  end
+
+  def has_tracking_branch?
+    local? && upstream
+  end
+
+  def author
+    latest_commit.author.name
+  end
+
+  def name
+    branch.name
+  end
+
+  def start
+    # WIP if necessary
+
+    repo.with_branch(name) do
+      ensure_upstream
+    end
+
+    # if selected_branch.has_wip_commit? && yes?("There is a WIP commit on this bra
+    # nch, would you like to apply it locally?")
+    #   repo.rollback
+    #
+    #   say "The WIP commit has been applied."
+    #
+    #   if yes?("Would you like to remove the commit from origin?")
+    #     repo.push(branch: selected_branch, force: true)
+    #   end
+    # end
+  end
+
+  def version_number
+    name[/v(\d+)\z/, 1].to_i
+  end
+
+  private
+
+  # def has_wip_commit?
+  #   latest_commit.message.include? 'WIP:'
+  # end
+
+  # def <=>(other)
+  #   name <=> other.name
+  # end
+
+  # def overwritten_authors
+  #   names = `git overwritten`
+  #   names.first(3)
+  # end
+
+  def ensure_upstream
+    self.upstream = default_upstream_branch_name unless has_tracking_branch?
+  end
+
+  def latest_commit
+    branch.gcommit
+  end
+
+  def upstream=(other)
+    remote, branch = parse_name(other)
+
+    self.upstream_remote = remote
+    self.upstream_branch = "refs/heads/#{branch}"
+  end
+
+  def upstream
+    return nil if upstream_remote.empty?
+
+    "#{upstream_remote}/#{name}"
+  end
+
+  def upstream_remote
+    repo.upstream_remote_for_branch(name)
+  end
+
+  def upstream_remote=(other)
+    repo.upstream_remote_for_branch(name, other)
+  end
+
+  def upstream_branch
+    repo.upstream_branch_for_branch(name)
+  end
+
+  def upstream_branch=(other)
+    repo.upstream_branch_for_branch(name, other)
+  end
+
+  def default_upstream_branch_name
+    "origin/#{name}"
+  end
+
+  def parse_name(name)
+    name = name.to_s
+
+    if name.match(%r{^(?:remotes/)?([^/]+)/(.+)})
+      return [$1, $2]
+    end
+
+    return [nil, name]
+  end
+
+  def branch=(other)
+    @branch = if other.is_a? self.class
+                other.branch
+              else
+                other
+              end
+  end
+end
+end
+end
+end

data/lib/hustle_and_flow/version_control/git/branches.rb

@@ -0,0 +1,93 @@
+require 'hustle_and_flow/utils/url_slug'
+require 'hustle_and_flow/version_control/git/branch'
+
+module  HustleAndFlow
+module  VersionControl
+module  Git
+class   Branches
+  include Enumerable
+
+  attr_accessor :repo,
+                :branches
+
+  def initialize(repo:, branches:)
+    self.repo     = repo
+    self.branches = branches
+  end
+
+  def filter_by_issue(number:, title:)
+    self.class.new(repo:     repo,
+                   branches: (branches_matching_issue_number(number) +
+                              branches_matching_issue_title(title)).uniq)
+  end
+
+  def valid_number?(number)
+    return false unless number.to_s.match(/\A\d+\z/)
+
+    (1..branches.count).include?(number.to_i)
+  end
+
+  def from_number(number)
+    branches[number.to_i - 1]
+  end
+
+  def next_branch_name(template:)
+    template.sub('*****', next_version_number.to_s)
+  end
+
+  def selectable
+    tracking_branches = branches.map do |branch|
+      branch.name if branch.has_tracking_branch?
+    end
+
+    self.class.new(repo:     repo,
+                   branches: branches.reject do |branch|
+                               branch.remote? &&
+                               tracking_branches.include?(branch.name)
+                             end)
+  end
+
+  def each
+    branches.each do |branch|
+      yield branch
+    end
+  end
+
+  private
+
+  def next_version_number
+    latest_branch = branches.max do |first_branch, second_branch|
+                      first_branch.version_number <=> second_branch.version_number
+                    end
+
+    latest_branch ? latest_branch.version_number + 1 : 1
+  end
+
+  def branches_matching_issue_number(issue_number)
+    return [] unless issue_number
+
+    branches.select do |branch|
+      branch.name.match(/-#{issue_number.to_i}\b/)
+    end
+  end
+
+  def branches_matching_issue_title(issue_title)
+    return [] unless issue_title.to_s.length > 0
+
+    title_slug = Utils::UrlSlug.new(issue_title).to_s
+
+    branches.select do |branch|
+      branch.name.include? title_slug
+    end
+  end
+
+  def branches=(other)
+    @branches = other.map do |branch|
+      Branch.new(repo:   repo,
+                 branch: branch)
+    end
+  end
+end
+end
+end
+end

data/lib/hustle_and_flow/version_control/git/repository.rb

@@ -0,0 +1,99 @@
+require 'git'
+require 'hustle_and_flow/version_control/git/branches'
+require 'hustle_and_flow/formatters/branch_table_formatter'
+
+module  HustleAndFlow
+module  VersionControl
+module  Git
+class   Repository
+  attr_accessor :repo
+
+  def initialize(path:)
+    self.repo = ::Git.open(path)
+  end
+
+  def start(io:, number:, title:, branch_template:)
+    available_branches = branches.
+                         selectable.
+                         filter_by_issue(number: number,
+                                         title:  title)
+
+    next_branch_name = available_branches.next_branch_name(template: branch_template)
+
+    selected = if available_branches.count.zero?
+                 Branch.new(repo: self, branch: repo.checkout(next_branch_name,
+                                                              new_branch: true))
+               else
+                 branch_number = nil
+
+                 io.print_formatted_table \
+                   title: 'Possible Existing Branches',
+                   data:  Formatters::BranchTableFormatter.new(available_branches).
+                         to_ary
+
+                 io.print_new_branch_prompt(next_branch_name)
+
+                 until available_branches.valid_number? branch_number
+                   branch_number = io.choose_branch
+                 end
+
+                 available_branches.from_number(branch_number)
+               end
+
+    selected.start
+  end
+
+  def user
+    repo.config('github.user')
+  end
+
+  def base_name
+    origin_url[%r{github\.com.([\w\-]+/[\w\-]+)}, 1]
+  end
+
+  def upstream_remote_for_branch(branch_name, value = nil)
+    repo.config(upstream_remote_config_key(branch_name), value)
+  end
+
+  def upstream_branch_for_branch(branch_name, value = nil)
+    repo.config(upstream_merge_config_key(branch_name), value)
+  end
+
+  def with_branch(branch_name)
+    repo.checkout(branch_name)
+
+    yield
+
+    repo.push('origin', branch_name)
+  end
+
+  private
+
+  def branches
+    Branches.new(repo:     self,
+                 branches: repo.branches)
+  end
+
+  def new_branch_name(branch_template)
+    branch_template.sub('*****', branches.next_version_number)
+  end
+
+  def origin_url
+    origin.url
+  end
+
+  def origin
+    @origin ||= repo.remote('origin')
+  end
+
+  def upstream_remote_config_key(branch_name)
+    "branch.#{branch_name}.remote"
+  end
+
+  def upstream_merge_config_key(branch_name)
+    "branch.#{branch_name}.merge"
+  end
+end
+end
+end
+end

data/lib/hustle_and_flow.rb

@@ -1,5 +1,4 @@
-require "hustle_and_flow/version"
+require 'hustle_and_flow/version'
 
 module HustleAndFlow
-  # Your code goes here...
 end

data/spec/lib/hustle_and_flow/formatters/branch_table_formatter_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'hustle_and_flow/formatters/branch_table_formatter'
+
+module    HustleAndFlow
+module    Formatters
+describe  BranchTableFormatter do
+  it 'can output branch information as columns' do
+    branches = [
+      OpenStruct.new(current?:             true,
+                     local?:               true,
+                     remote?:              true,
+                     has_tracking_branch?: true,
+                     author:               'Michael Myers',
+                     name:                 'feature/add-new-feature-closes-42-v2'),
+      OpenStruct.new(current?:             false,
+                     local?:               false,
+                     remote?:              true,
+                     has_tracking_branch?: false,
+                     author:               'Jeff Has a Really Really Long Name',
+                     name:                 'add-new-feature-42'),
+    ]
+
+    columnizer = BranchTableFormatter.new(branches)
+
+    expect(columnizer.to_ary).to eql([
+      [
+        { format: [:white,  :bold], value: 1 },
+        { format: [:yellow, :bold], value: '*' },
+        { format: [:yellow, :bold], value: 'T' },
+        { format: [:white,  :bold], value: 'Michael Myers' },
+        { format: [:green,  :bold], value: 'feature/add-new-feature-closes-42-v2' },
+      ],
+      [
+        { format: [:white,   :bold], value: 2 },
+        { format: [:yellow,  :bold], value: ' ' },
+        { format: [:magenta, :bold], value: 'R' },
+        { format: [:white,   :bold], value: 'Jeff Has a Really Really Long Name' },
+        { format: [:green,   :bold], value: 'add-new-feature-42' },
+      ],
+    ])
+  end
+end
+end
+end

data/spec/lib/hustle_and_flow/formatters/issue_detail_formatter_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'hustle_and_flow/formatters/issue_detail_formatter'
+require 'hustle_and_flow/issue_trackers/github/issue'
+
+module    HustleAndFlow
+module    Formatters
+describe  IssueDetailFormatter do
+  it 'can output the details of an issue as an array' do
+    issue = IssueTrackers::Github::Issue.new(
+      tracker: 'foo',
+      data:    {
+        status:   'open',
+        assignee: {
+          login: 'neo' },
+        number:   42,
+        title:    'My Awesome Title',
+        body:     'My Body is a Wonderland' })
+
+    expect(IssueDetailFormatter.new(issue).to_hash).to eql(
+      header:  { format: [:green, :bold], value: '#42 - My Awesome Title' },
+      divider: { format: [:black, :bold], value: nil },
+      contact: { format: [:blue,  :bold], value: 'By: neo' },
+      body:    { format: [:white, :bold], value: 'My Body is a Wonderland' }
+    )
+  end
+
+  it 'can output the category next to the title if there is one' do
+    issue = IssueTrackers::Github::Issue.new(
+      tracker: 'foo',
+      data:    {
+        status:   'open',
+        assignee: {
+          login: 'neo' },
+        number:   42,
+        labels:   [
+          { name: 'feature' },
+        ],
+        title:    'My Awesome Title' })
+
+    expect(IssueDetailFormatter.new(issue).to_hash).to eql(
+      header:  { format: [:green, :bold], value: '#42 - Feature: My Awesome Title' },
+      divider: { format: [:black, :bold], value: nil },
+      contact: { format: [:blue,  :bold], value: 'By: neo' },
+      body:    { format: [:white, :bold], value: nil }
+    )
+  end
+end
+end
+end