hustle_and_flow 0.0.1 → 0.0.2

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

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'hustle_and_flow/formatters/issue_table_formatter'
+require 'hustle_and_flow/issue_trackers/github/issue'
+
+module    HustleAndFlow
+module    Formatters
+describe  IssueTableFormatter do
+  it 'can output issue information as columns' do
+    issues = [
+      IssueTrackers::Github::Issue.new(
+        tracker: 'tracker',
+        data:    {
+          number:   1,
+          state:    'open',
+          assignee: {
+            login: 'Michael Myers',
+          },
+          labels:   [
+            {
+              name: 'feature',
+            },
+          ],
+          title:    'Whatever This Feature Is Called Is Really Really Long, ' \
+                    "Like Sooooo Long You Don't Even Know",
+        },
+      ),
+      IssueTrackers::Github::Issue.new(
+        tracker: 'tracker',
+        data:    {
+          number:   20,
+          state:    'closed',
+          assignee: {
+            login: 'Jeff Has a Really Really Long Name',
+          },
+          labels:   [
+            {
+              name: 'bug',
+            },
+          ],
+          title:    'My Short Issue Title',
+        },
+      ),
+    ]
+
+    columnizer = IssueTableFormatter.new(issues)
+
+    expect(columnizer.to_ary).to eql [
+      [
+        [
+          [:green],
+          '#1',
+        ],
+        [
+          [:white],
+          'Michael Myers',
+        ],
+        [
+          [:green, :bold],
+          'Feature',
+        ],
+        [
+          [:white],
+          'Whatever This Feature Is Called Is Really Really Long, ' \
+          "Like Sooooo Long You Don't Even Know",
+        ],
+      ],
+      [
+        [
+          [:red],
+          '#20',
+        ],
+        [
+          [:white],
+          'Jeff Has a Really Really Long Name',
+        ],
+        [
+          [:red, :bold],
+          'Bug',
+        ],
+        [
+          [:white],
+          'My Short Issue Title',
+        ],
+      ],
+    ]
+  end
+end
+end
+end

data/spec/lib/hustle_and_flow/io/shell_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+require 'hustle_and_flow/io/shell'
+require 'hustle_and_flow/issue_trackers/github/issue'
+
+module    HustleAndFlow
+module    Io
+describe  Shell do
+  let(:issue) { instance_double(HustleAndFlow::IssueTrackers::Github::Issue) }
+  let(:io)    { Shell.new }
+
+  it 'considers the issue correct if it is new' do
+    allow(issue).to   receive(:new?).
+                      and_return(true)
+    allow(issue).to   receive(:url).
+                      and_return('http://example.com')
+    allow(Kernel).to  receive(:system).
+                      and_return(true)
+
+    expect(io.correct_issue?(issue)).to be_truthy
+  end
+
+  it 'opens the URL of the issue if it is new' do
+    allow(issue).to   receive(:new?).
+                      and_return(true)
+    allow(issue).to   receive(:url).
+                      and_return('http://example.com')
+    allow(Kernel).to  receive(:system).
+                      and_return(true)
+
+    expect(io.correct_issue?(issue)).to be_truthy
+    expect(Kernel).to                   have_received(:system).
+                                        with('open http://example.com')
+  end
+
+  it 'considers the issue correct if the user responds positively when the issue has a body' do
+    allow(issue).to                            receive(:new?).
+                                               and_return(false)
+    allow(issue).to                            receive(:has_body?).
+                                               and_return(true)
+    allow(Formatters::IssueDetailFormatter).to receive(:to_details_s).
+                                               and_return ''
+    allow(io).to                               receive(:yes?).
+                                               and_return(true)
+
+    expect(io.correct_issue?(issue)).to be_truthy
+    expect(io).to                       have_received(:yes?).
+                                        with('Does this issue look correct?')
+  end
+
+  it 'displays the details of the issue to the user if it has a body' do
+    allow(issue).to                            receive(:new?).
+                                               and_return(false)
+    allow(issue).to                            receive(:has_body?).
+                                               and_return(true)
+    allow(Formatters::IssueDetailFormatter).to receive(:to_details_s).
+                                               and_return 'my details'
+
+    expect(io.correct_issue?(issue)).to be_truthy
+    expect(io).to                       have_received(:print_wrapped).
+                                        with('my details',
+                                             colorize: true)
+  end
+
+  it 'considers the issue incorrect if the user responds negatively when the issue has a body' do
+    allow(issue).to                            receive(:new?).
+                                               and_return(false)
+    allow(issue).to                            receive(:has_body?).
+                                               and_return(true)
+    allow(Formatters::IssueDetailFormatter).to receive(:to_details_s).
+                                               and_return ''
+    allow(io).to                               receive(:yes?).
+                                               and_return(false)
+
+    expect(io.correct_issue?(issue)).to be_falsey
+    expect(io).to                       have_received(:yes?).
+                                        with('Does this issue look correct?')
+  end
+
+  it 'considers the issue correct if the issue is neither new, nor has a body' do
+    allow(issue).to receive(:new?).
+                    and_return(false)
+    allow(issue).to receive(:has_body?).
+                    and_return(false)
+
+    expect(io.correct_issue?(issue)).to be_truthy
+  end
+
+  it 'can print a table with colors' do
+    allow(io).to receive(:print_table).
+                 and_return('yay')
+
+    io.print_formatted_table(
+      data: [
+        [
+          [[:green],        '#1'],
+          [[:white],        'Michael Myers'],
+          [[:green, :bold], 'Feature'],
+          [[:white],        'Whatever This Feature Is Called Is Really Really Long, ' \
+                            "Like Sooooo Long You Don't Even Know"],
+        ],
+        [
+          [[:red],          '#20'],
+          [[:white],        'Jeff Has a Really Really Long Name'],
+          [[:red, :bold],   'Bug'],
+          [[:white],        'My Short Issue Title'],
+        ],
+      ],
+    )
+
+    expect(io).to have_received(:print_table).
+                  with(
+                    [
+                      [
+                        "\e[32m#1\e[0m",
+                        "\e[37mMichael Myers\e[0m",
+                        "\e[32m\e[1mFeature\e[0m",
+                        "\e[37mWhatever This Feature Is Called Is Really Really Long, " \
+                        "Like Sooooo Long You Don't Even Know\e[0m",
+                      ],
+                      [
+                        "\e[31m#20\e[0m",
+                        "\e[37mJeff Has a Really Really Long Name\e[0m",
+                        "\e[31m\e[1mBug\e[0m",
+                        "\e[37mMy Short Issue Title\e[0m",
+                      ],
+                    ],
+                    truncate: true,
+                  )
+  end
+
+  it 'can print a table with a title' do
+    allow(io).to      receive(:print_table).
+                      and_return('yay')
+    allow(io).to      receive(:terminal_width).
+                      and_return(80)
+    allow($stdout).to receive(:puts)
+
+    io.print_formatted_table(
+      title: 'My Uber Fancy Title',
+      data:  [
+        [
+          ['green', '#1'],
+        ],
+      ],
+    )
+
+    expect($stdout).to have_received(:puts).
+                       with("#{' ' * 30}My Uber Fancy Title#{' ' * 31}")
+    expect($stdout).to have_received(:puts).
+                       with('-' * 80)
+  end
+end
+end
+end

data/spec/lib/hustle_and_flow/issue_tracker_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'hustle_and_flow/issue_tracker'
+
+module    HustleAndFlow
+describe  IssueTracker do
+end
+end

data/spec/lib/hustle_and_flow/issue_trackers/github/issue_spec.rb

@@ -0,0 +1,354 @@
+require 'rspectacular'
+require 'octokit'
+require 'hustle_and_flow/issue_trackers/github'
+require 'hustle_and_flow/issue_trackers/github/issue'
+
+module    HustleAndFlow
+module    IssueTrackers
+class     Github
+describe  Issue, vcr: { record: :all } do
+  let(:repo)    { OpenStruct.new(base_name: 'thekompanee/hustle_and_flow') }
+  let(:tracker) { Github.new(repo: repo) }
+
+  it 'can create an issue' do
+    issue = Issue.create(tracker: tracker,
+                         title:   'My IssueTracker Issue Title')
+
+    expect(issue).to        be_a Issue
+    expect(issue.title).to  eql 'My IssueTracker Issue Title'
+    expect(issue.number).to be_a Integer
+  end
+
+  it 'can create an issue with a body' do
+    issue = Issue.create(tracker: tracker,
+                         title:   'My IssueTracker Issue Title',
+                         body:    'My body is a wonderland')
+
+    expect(issue.body).to eql 'My body is a wonderland'
+  end
+
+  it 'can create an issue with a label' do
+    issue = Issue.create(tracker: tracker,
+                         title:   'My IssueTracker Issue Title',
+                         labels:  'feature')
+
+    expect(issue).to have_label 'feature'
+  end
+
+  it 'can create an issue with multiple labels' do
+    issue = Issue.create(tracker: tracker,
+                         title:   'My IssueTracker Issue Title',
+                         labels:  %w{feature bug})
+
+    expect(issue).to have_label 'feature'
+    expect(issue).to have_label 'bug'
+  end
+
+  it 'when starting work on an issue, it reopens it if it is closed' do
+    io = instance_double(HustleAndFlow::Io::Shell)
+    allow(io).to receive(:correct_issue?).
+                 and_return(true)
+    allow(io).to receive(:reassign_issue?).
+                 and_return(true)
+
+    issue = Issue.new(tracker: tracker,
+                      io:      io,
+                      data:    {
+                        number:   74,
+                        state:    'closed',
+                        html_url: 'https://github.com/thekompanee/hustle_and_flow' })
+
+    started_issue = issue.start(me: 'jfelchner')
+
+    expect(started_issue).to      be_a Issue
+    expect(started_issue).not_to  be_closed
+  end
+
+  it 'when starting an issue, it reassigns the issue if it is unassigned' do
+    io = instance_double(HustleAndFlow::Io::Shell)
+    allow(io).to receive(:correct_issue?).
+                 and_return(true)
+
+    issue = Issue.new(tracker: tracker,
+                      io:      io,
+                      data:    {
+                        number:   74,
+                        html_url: 'https://github.com/thekompanee/hustle_and_flow' })
+
+    started_issue = issue.start(me: 'jfelchner')
+
+    expect(started_issue).to      be_a            Issue
+    expect(started_issue).not_to  eql             issue
+    expect(started_issue).to      be_assigned_to  'jfelchner'
+  end
+
+  it 'does not reassign the issue if it is already assigned to the user' do
+    io = instance_double(HustleAndFlow::Io::Shell)
+    allow(io).to receive(:correct_issue?).
+                 and_return(true)
+
+    issue = Issue.new(tracker: tracker,
+                      io:      io,
+                      data:    {
+                        number:   74,
+                        assignee: { login:    'jfelchner' },
+                        html_url: 'https://github.com/thekompanee/hustle_and_flow' })
+
+    started_issue = issue.start(me: 'jfelchner')
+
+    expect(started_issue).to be_a           Issue
+    expect(started_issue).to eql            issue
+    expect(started_issue).to be_assigned_to 'jfelchner'
+  end
+
+  it 'reassigns the issue if it is not already assigned to the user and the user ' \
+     'chooses to reassign it' do
+
+    io = instance_double(HustleAndFlow::Io::Shell)
+    allow(io).to receive(:correct_issue?).
+                 and_return(true)
+    allow(io).to receive(:reassign_issue?).
+                 and_return(true)
+
+    issue = Issue.new(tracker: tracker,
+                      io:      io,
+                      data:    {
+                        number:   74,
+                        assignee: { login: 'neo' },
+                        html_url: 'https://github.com/thekompanee/hustle_and_flow' })
+
+    started_issue = issue.start(me: 'jfelchner')
+
+    expect(started_issue).to      be_a Issue
+    expect(started_issue).not_to  eql  issue
+    expect(started_issue).to      be_assigned_to('jfelchner')
+    expect(io).to                 have_received(:reassign_issue?).
+                                  with(from: 'neo')
+  end
+
+  it 'does not reassign the issue if it is not already assigned to the user but the ' \
+     'user chooses not to reassign it' do
+
+    io = instance_double(HustleAndFlow::Io::Shell)
+    allow(io).to receive(:correct_issue?).
+                 and_return(true)
+    allow(io).to receive(:reassign_issue?).
+                 and_return(false)
+
+    issue = Issue.create(tracker:  tracker,
+                         io:       io,
+                         title:    'Ninja Assassin',
+                         assignee: 'blakecash')
+
+    started_issue = issue.start(me: 'jfelchner')
+
+    expect(started_issue).to be_a Issue
+    expect(started_issue).to eql  issue
+    expect(io).to            have_received(:reassign_issue?).
+                             with(from: 'blakecash')
+  end
+
+  it 'does not start work on an issue if it is not the correct one' do
+    io = instance_double(HustleAndFlow::Io::Shell)
+    allow(io).to receive(:correct_issue?).
+                 and_return(false)
+
+    issue = Issue.create(io:      io,
+                         tracker: tracker,
+                         title:   'My IssueTracker Issue Title')
+
+    expect(issue.start).to  be_nil
+    expect(io).to           have_received(:correct_issue?).
+                            with(issue)
+  end
+
+  it 'considers the issue new if it was created less than 5 minutes ago' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { created_at: Time.now.utc })
+
+    less_than_five_minutes_from_now = Time.now.utc + (5 * 60) - 1
+
+    Timecop.freeze(less_than_five_minutes_from_now) do
+      expect(issue).to be_new
+    end
+  end
+
+  it 'does not consider the issue new if it was created exactly 5 minutes ago' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { created_at: Time.now.utc })
+
+    five_minutes_from_now = Time.now.utc + (5 * 60)
+
+    Timecop.freeze(five_minutes_from_now) do
+      expect(issue).not_to be_new
+    end
+  end
+
+  it 'does not have a body if the body is nil' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { body: nil })
+
+    expect(issue).not_to have_body
+  end
+
+  it 'does not have a body if the body is empty' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { body: '' })
+
+    expect(issue).not_to have_body
+  end
+
+  it 'does have a body if the body is not empty' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { body: 'My body is a wonderland' })
+
+    expect(issue).to have_body
+  end
+
+  it 'knows which labels are categories' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { labels: [{ name: 'feature' }] })
+
+    expect(issue.category).to eql 'feature'
+  end
+
+  it 'knows which labels are not categories' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { labels: [{ name: 'featuring' }] })
+
+    expect(issue.category).to be_nil
+  end
+
+  it 'knows if the issue is unassigned' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { assignee: { login: 'bar' } })
+
+    expect(issue).not_to be_unassigned
+
+    issue = Issue.new(tracker: tracker,
+                      data:    { assignee: {} })
+    expect(issue).to be_unassigned
+
+    issue = Issue.new(tracker: tracker,
+                      data:    { assignee: nil })
+    expect(issue).to be_unassigned
+  end
+
+  it 'can reassign an issue to another user' do
+    original_issue = Issue.create(tracker: tracker,
+                                  title:   'Ninjitsu')
+
+    reassigned_issue = original_issue.assign(to: 'jfelchner')
+
+    expect(reassigned_issue).to be_a Issue
+    expect(reassigned_issue).to be_assigned_to 'jfelchner'
+  end
+
+  it 'marks the assignee as the contact if there is an assigned user' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { assignee: { login: 'flibbity' } })
+
+    expect(issue.contact).to eql 'flibbity'
+  end
+
+  it 'marks the creator as the contact if the issue is unassigned' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { assignee: { login: 'undercoat' } })
+
+    expect(issue.contact).to eql 'undercoat'
+  end
+
+  it 'marks the creator as the assignee if there is both an assignee and a creator' do
+    issue = Issue.new(tracker: tracker,
+                      data:    {
+                        user:     { login: 'undercoat' },
+                        assignee: { login: 'flibbity'  } })
+
+    expect(issue.contact).to eql 'flibbity'
+  end
+
+  it 'can create a branch name from only its title' do
+    issue = Issue.new(tracker: tracker,
+                      data:    { title: 'My Branchy Branch' })
+
+    expect(issue.to_branch_name).to eql 'my-branchy-branch-v1'
+  end
+
+  it 'can create a branch name from its title and number' do
+    issue = Issue.new(tracker: tracker,
+                      data:    {
+                        title:  'My Branchy Branch',
+                        number: 42 })
+
+    expect(issue.to_branch_name).to eql 'my-branchy-branch-closes-42-v1'
+  end
+
+  it 'can create a branch name from its type, title and number' do
+    issue = Issue.create(tracker: tracker,
+                         labels:  [{ name: 'feature' }],
+                         title:   'My Branchy Branch')
+
+    expect(issue.to_branch_name).to eql \
+      "feature/my-branchy-branch-closes-#{issue.number}-v1"
+  end
+
+  it 'can create a branch name from a custom action' do
+    issue = Issue.new(tracker: tracker,
+                      data:    {
+                        title:  'My Branchy Branch',
+                        number: 42 })
+
+    branch_name = issue.to_branch_name(action: 'References')
+
+    expect(branch_name).to eql 'my-branchy-branch-references-42-v1'
+  end
+
+  it 'cannot create a branch name from an unknown action' do
+    issue = Issue.new(tracker: tracker,
+                      data:    {
+                        title:  'My Branchy Branch',
+                        number: 42 })
+
+    expect { issue.to_branch_name(action: 'Killit') }.to \
+      raise_error HustleAndFlow::Errors::UnknownIssueActionError
+  end
+
+  it 'can create a branch name from a custom version' do
+    issue = Issue.new(tracker: tracker,
+                      data:    {
+                        title:  'My Branchy Branch',
+                        number: 42 })
+
+    branch_name = issue.to_branch_name(version: 9_999)
+
+    expect(branch_name).to eql 'my-branchy-branch-closes-42-v9999'
+  end
+
+  it 'knows how to match against the type and title' do
+    issue = Issue.new(tracker: tracker,
+                      data:    {
+                        labels: [{ name: 'bug' }],
+                        title:  'Found a bug' })
+
+    expect(issue).to      be_match(type:  'bug',
+                                   title: 'Found a bug')
+
+    expect(issue).not_to  be_match(type:  'foo',
+                                   title: 'Found a bug')
+
+    expect(issue).not_to  be_match(type:  'bug',
+                                   title: 'xFound a bug')
+  end
+
+  it 'knows how to match against the number' do
+    issue = Issue.new(tracker: tracker,
+                      data:    {
+                        number: 1347 })
+
+    expect(issue).to      be_match(number: 1347)
+    expect(issue).not_to  be_match(number: 18)
+  end
+end
+end
+end
+end

data/spec/lib/hustle_and_flow/issue_trackers/github/issues_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'hustle_and_flow/issue_trackers/github'
+require 'hustle_and_flow/issue_trackers/github/issues'
+
+module    HustleAndFlow
+module    IssueTrackers
+class     Github
+describe  Issues, vcr: { record: :all } do
+  let(:repo)    { OpenStruct.new(base_name: 'thekompanee/hustle_and_flow') }
+  let(:tracker) { Github.new(repo: repo) }
+
+  it 'can find an issue based on the type and title' do
+    issue = Issues.new(tracker: tracker).
+            find_or_create type:  'bug',
+                           title: 'Menu item specifications not working'
+
+    expect(issue).to        be_a  Github::Issue
+    expect(issue.number).to eql   36
+  end
+
+  it 'can find an issue based on the number' do
+    issue = Issues.new(tracker: tracker).
+            find_or_create number: 2
+
+    expect(issue).to        be_a  Github::Issue
+    expect(issue.title).to  eql   "hello there, is it tea you're looking for? 2"
+    expect(issue.number).to eql   2
+  end
+
+  it 'can create an issue if the found issue does not exist' do
+    random = SecureRandom.hex(4)
+    issue  = Issues.new(tracker: tracker).
+             find_or_create type:  'feature',
+                            title: "Ninjitsu #{random}"
+
+    expect(issue).to        be_a  Github::Issue
+    expect(issue.title).to  eql   "Ninjitsu #{random}"
+  end
+
+  it 'can start an issue with a specified issue number' do
+    io    = instance_double(HustleAndFlow::Io::Shell)
+    issue = Issues.start(tracker:    tracker,
+                         io:         io,
+                         me:         'jfelchner',
+                         issue_data: {
+                           number: 36,
+                         })
+
+    expect(issue).to          be_a  Github::Issue
+    expect(issue.category).to eql   'bug'
+    expect(issue.title).to    eql   'Menu item specifications not working'
+  end
+
+  it 'can start an issue if a type and title is specified' do
+    io    = instance_double(HustleAndFlow::Io::Shell)
+    issue = Issues.start(tracker:    tracker,
+                         io:         io,
+                         me:         'jfelchner',
+                         issue_data: {
+                           type:  'bug',
+                           title: 'Menu item specifications not working',
+                         })
+
+    expect(issue).to        be_a  Github::Issue
+    expect(issue.number).to eql   36
+  end
+
+  it 'can start an issue if a type and title is specified' do
+    io    = instance_double(HustleAndFlow::Io::Shell)
+
+    allow(io).to receive(:print_formatted_table).
+                 with(any_args).
+                 and_return true
+    allow(io).to receive(:choose_issue).
+                 and_return 216
+
+    issue = Issues.start(tracker:    tracker,
+                         io:         io,
+                         me:         'jfelchner',
+                         issue_data: {
+                           type: 'bug',
+                         })
+
+    expect(issue).to        be_a  Github::Issue
+    expect(issue.title).to  eql   'Ninjitsu'
+    expect(issue.number).to eql   216
+  end
+end
+end
+end
+end