pgit 0.0.4 → 1.0.0

data/spec/pgit/current_project/validator_spec.rb

@@ -3,9 +3,10 @@ require 'spec_helper'
 describe 'PGit::CurrentProject::Validator' do
   it 'should raise an error if there are no matching projects' do
     matching_projects = []
+    message = "None of the project paths matches the working directory"
 
     expect do
       PGit::CurrentProject::Validator.new(matching_projects)
-    end.to raise_error PGit::CurrentProject::NoPathsMatchWorkingDirError
+    end.to raise_error(PGit::Error::User, message)
   end
 end

data/spec/pgit/current_project_spec.rb

@@ -1,79 +1,28 @@
 require 'spec_helper'
-# .edderic-dotfiles/config.yml
-# projects
-#   - path:                  ~/Therapy-Exercises-Online
-#     id:                    12345
-#     api_token: asoeuhot
-#
-def successful_setup
-  fake_project_1 =  { "path" => "/Therapy-Exercises-Online/some_other_project",
-                      "id" => 12345,
-                      "api_token" => "astoeuh" }
-  fake_project_2 =  { "path" => "~/Therapy-Exercises-Online",
-                      "id" => 19191,
-                      "api_token" => "astoeuh" }
-  fake_project_list = [ fake_project_1, fake_project_2 ]
-  fake_yaml = { "projects" => fake_project_list }
-  fake_pwd = "/Therapy-Exercises-Online/some_other_project/some_subdirectory"
-  allow(Dir).to receive(:pwd).and_return(fake_pwd)
-
-  fake_configuration = double('configuration', to_yaml: fake_yaml)
-end
 
 describe 'PGit::CurrentProject' do
-  describe '#new(config_yaml)' do
-    it 'should delegate to PGit::CurrentProject::Validator' do
-      fake_project_1 =  { "path" => "~/some-non-matching-path",
-                          "id" => 12345,
-                          "api_token" => "astoeuh" }
-      fake_project_2 =  { "path" => "~/some-other-non-matching-path",
-                          "id" => 19191,
-                          "api_token" => "astoeuh" }
-      fake_project_list = [ fake_project_1, fake_project_2 ]
-      fake_yaml = { "projects" => fake_project_list }
-      fake_pwd = "/Therapy-Exercises-Online/some_other_project/some_subdirectory"
-      fake_configuration = double('configuration', to_yaml: fake_yaml)
-      allow(Dir).to receive(:pwd).and_return(fake_pwd)
-      allow(PGit::CurrentProject::Validator).to receive(:new).with []
-
-      PGit::CurrentProject.new(fake_configuration.to_yaml)
-
-      expect(PGit::CurrentProject::Validator).to have_received(:new).with []
-    end
+  it 'instantiates the PGit::Project that exists in the config file and whose path matches the working directory' do
+    matching_path = '/some/matching_path'
+    matching_project = instance_double('PGit::Project',
+                                      path: matching_path)
+    projects = [matching_project]
+    configuration = instance_double('PGit::Configuration',
+                                    projects: projects)
+    allow(Dir).to receive(:pwd).and_return(matching_path)
+    proj = PGit::CurrentProject.new(configuration)
+
+    expect(proj.path).to eq matching_path
   end
 
-  describe '#pwd' do
-    describe 'more than one of the projects listed matches the working directory' do
-      it "should return the more specific directory" do
-        fake_configuration = successful_setup
-
-        current_project = PGit::CurrentProject.new(fake_configuration.to_yaml)
-        working_directory = current_project.pwd
-
-        expect(working_directory).to eq "/Therapy-Exercises-Online/some_other_project"
-      end
-    end
-  end
-
-  describe '#id' do
-    it 'should return the correct pivotal tracker project_id' do
-      fake_configuration = successful_setup
-
-      current_project = PGit::CurrentProject.new(fake_configuration.to_yaml)
-      project_id = current_project.id
-
-      expect(project_id).to eq 12345
-    end
-  end
-
-  describe '#api_token' do
-    it 'should return the api_token associated to the current project' do
-      fake_configuration = successful_setup
-
-      current_project = PGit::CurrentProject.new(fake_configuration.to_yaml)
-      api_token = current_project.api_token
+  it 'raises an error if the project does not exist' do
+    matching_path = '/some/matching_path'
+    matching_project = instance_double('PGit::Project',
+                                      path: matching_path)
+    projects = [matching_project]
+    configuration = instance_double('PGit::Configuration',
+                                    projects: projects)
+    allow(Dir).to receive(:pwd).and_return('/some/non-matching-path')
 
-      expect(api_token).to eq 'astoeuh'
-    end
+    expect{ PGit::CurrentProject.new(configuration) }.to raise_error(PGit::Error::User, "Current Project does not exist. See `pgit proj add -h`")
   end
 end

data/spec/pgit/{external_error_spec.rb → error/external_spec.rb}

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
-describe 'PGit::ExternalError' do
+describe 'PGit::Error::External' do
   it 'should take in the response' do
     response = '{
       "code": "unfound_resource",
       "kind": "error",
       "error": "The object you tried to access could not be found.  It may have been removed by another user, you may be using the ID of another object type, or you may be trying to access a sub-resource at the wrong point in a tree."
     }'
-    external_error = PGit::ExternalError.new(response)
+    external_error = PGit::Error::External.new(response)
     message = external_error.instance_eval { @message }
 
     expect(message).to eq(response)
   end
 
   it 'should inherit from PGit::Error' do
-    ancestors = PGit::ExternalError.ancestors
+    ancestors = PGit::Error::External.ancestors
 
     expect(ancestors).to include PGit::Error
   end

data/spec/pgit/error/user_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'PGit::Error::User' do
+  it 'should save the error' do
+    message = "You did something dumb..."
+    user_error = PGit::Error::User.new(message)
+
+    expect(user_error.message).to eq message
+  end
+
+  it 'should be a PGit::Error' do
+    message = "You did something dumb..."
+    ancestors = PGit::Error::User.ancestors
+
+    expect(ancestors).to include(PGit::Error)
+  end
+end

data/spec/pgit/helpers/heredoc_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'PGit::Helpers::Heredoc' do
+  describe '.remove_front_spaces' do
+    it 'should return the script, formatted nicely' do
+      unprocessed = <<-HEREDOC
+          function get_pgit_commands
+          {
+            if [ -z $2 ]; then
+              COMPREPLY=(`pgit help -c`)
+            else
+              COMPREPLY=(`pgit help -c $2`)
+            fi
+          }
+          complete -F get_pgit_commands pgit
+      HEREDOC
+
+      expected_script =
+        "function get_pgit_commands\n" +
+        "{\n" +
+        "  if [ -z $2 ]; then\n" +
+        "    COMPREPLY=(`pgit help -c`)\n" +
+        "  else\n" +
+        "    COMPREPLY=(`pgit help -c $2`)\n" +
+        "  fi\n" +
+        "}\n" +
+        "complete -F get_pgit_commands pgit\n"
+      script = PGit::Helpers::Heredoc.remove_front_spaces(unprocessed)
+
+      expect(script).to eq expected_script
+    end
+  end
+end

data/spec/pgit/helpers/query_methods_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe 'PGit::Helpers::QueryMethods' do
+  describe '#defaulted_attrs' do
+    it 'should ensure that the class has the given attributes' do
+      class SomeFakeClass
+        include PGit::Helpers::QueryMethods
+        extend PGit::Helpers::QueryMethods
+
+        attr_accessor :some_query, :some_other_query
+        attr_query :some_query, :some_other_query
+
+        def initialize
+          @some_query = :no_some_query_given
+        end
+      end
+
+      fake = SomeFakeClass.new
+      fake.some_other_query = 'set to non default'
+
+      expect(fake.defaulted_attrs).to include(:some_query.to_s)
+    end
+  end
+end

data/spec/pgit/helpers/string_extensions_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'PGit::Helpers::StringExtensions' do
+  describe '#letter?' do
+    it 'should be case insensitive' do
+      expect('h').to be_letter('h')
+      expect('h').to be_letter('H')
+    end
+
+    it 'should not match when length is greater than 1' do
+      expect('hh').not_to be_letter('h')
+    end
+  end
+
+  describe '#index?' do
+    describe 'without passing an arg' do
+      it 'should tell us if the argument is a (normal person) index' do
+        expect('1').to be_index
+        expect('100').to be_index
+        expect('0').not_to be_index
+        expect('1.1').not_to be_index
+      end
+    end
+  end
+
+  describe '#yes?' do
+    it 'returns true if letter is y and false if not' do
+      expect('y').to be_yes
+      expect('Y').to be_yes
+      expect('2').not_to be_yes
+    end
+  end
+
+  describe '#no?' do
+    it 'returns false if letter is not and false if not' do
+      expect('n').to be_no
+      expect('N').to be_no
+      expect('y').not_to be_no
+    end
+  end
+
+  describe '#cancel?' do
+    it 'returns true if letter is c and false if not' do
+      expect('c').to be_cancel
+      expect('C').to be_cancel
+      expect('y').not_to be_cancel
+    end
+  end
+end

data/spec/pgit/installer/bash_auto_completion_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe 'PGit::Installer::BashAutoCompletion' do
+  describe 'FILENAME' do
+    it 'should be ~/.pgit_auto_completion' do
+      expect(PGit::Installer::BashAutoCompletion::FILENAME).to eq "~/.pgit_auto_completion"
+    end
+  end
+
+  describe '.script' do
+    it 'should return the script, formatted nicely' do
+      unprocessed = <<-UNPROCESSED
+        function get_pgit_commands
+        {
+          if [ -z $2 ]; then
+            COMPREPLY=(`pgit help -c`)
+          else
+            COMPREPLY=(`pgit help -c $2`)
+          fi
+        }
+        complete -F get_pgit_commands pgit
+      UNPROCESSED
+
+      expected_script = PGit::Helpers::Heredoc.remove_front_spaces(unprocessed)
+      script = PGit::Installer::BashAutoCompletion.script
+
+      expect(script).to eq expected_script
+    end
+  end
+
+  describe '#write_completer_file' do
+    it "should write the auto completion script to #{PGit::Installer::BashAutoCompletion::FILENAME}" do
+      global_opts = {}
+      global_opts = {}
+      opts = {}
+      args = {}
+      fake_file = instance_double('File')
+      allow(fake_file).to receive(:puts).with(PGit::Installer::BashAutoCompletion.script).and_return(fake_file)
+      allow(fake_file).to receive(:close)
+      short_path = PGit::Installer::BashAutoCompletion::FILENAME
+      short_bashrc_path = "~/.bashrc"
+      expanded_path = "/Users/Edderic/#{PGit::Installer::BashAutoCompletion::FILENAME}"
+      expanded_bashrc_path = "/Users/Edderic/.bashrc"
+      bashrc_lines = [
+        "# some more ls aliases\n",
+        "alias ll='ls -alF'\n",
+        "alias la='ls -A'\n",
+        "alias l='ls -CF'\n" ]
+      message = "Wrote autocompletion script under #{PGit::Installer::BashAutoCompletion::FILENAME}"
+
+      allow(File).to receive(:expand_path).with(short_path).and_return(expanded_path)
+      allow(File).to receive(:open).with(expanded_path, 'w').and_return(fake_file)
+      allow(File).to receive(:readlines).with(expanded_bashrc_path).and_return(bashrc_lines)
+
+      installer = PGit::Installer::BashAutoCompletion.new(global_opts, opts, args)
+      allow(installer).to receive(:puts).with(message)
+
+      installer.write_completer_file
+
+      expect(fake_file).to have_received(:puts).with(PGit::Installer::BashAutoCompletion.script)
+      expect(fake_file).to have_received(:close)
+      expect(installer).to have_received(:puts).with(message)
+    end
+  end
+
+  describe '#source_completer_from_bashrc' do
+    describe '~/.bashrc does have "source ~#{PGit::Installer::BashAutoCompletion::FILENAME}"' do
+      it 'should NOT source it' do
+        global_opts = {}
+        opts = {}
+        args = {}
+        fake_file = instance_double('File')
+        fake_bashrc_file = instance_double('File')
+        allow(fake_bashrc_file).to receive(:puts).with("source #{PGit::Installer::BashAutoCompletion::FILENAME}").and_return(fake_file)
+        allow(fake_bashrc_file).to receive(:close)
+        short_bashrc_path = "~/.bashrc"
+        expanded_bashrc_path = "/Users/Edderic/.bashrc"
+        bashrc_lines = [
+          "# some more ls aliases\n",
+          "alias ll='ls -alF'\n",
+          "alias la='ls -A'\n",
+          "source #{PGit::Installer::BashAutoCompletion::FILENAME}",
+          "alias l='ls -CF'\n" ]
+        message = "Already sourcing #{PGit::Installer::BashAutoCompletion::FILENAME} in ~/.bashrc"
+
+        allow(File).to receive(:expand_path).with(short_bashrc_path).and_return(expanded_bashrc_path)
+        allow(File).to receive(:open).with(expanded_bashrc_path, 'a').and_return(fake_bashrc_file)
+        allow(File).to receive(:readlines).with(expanded_bashrc_path).and_return(bashrc_lines)
+
+        installer = PGit::Installer::BashAutoCompletion.new(global_opts, opts, args)
+        allow(installer).to receive(:puts).with(message)
+
+        installer.source_completer_from_bashrc
+
+        expect(fake_bashrc_file).not_to have_received(:puts).with "source #{PGit::Installer::BashAutoCompletion::FILENAME}"
+        expect(fake_bashrc_file).not_to have_received(:close)
+        expect(installer).to have_received(:puts).with(message)
+      end
+    end
+
+    describe '~/.bashrc does not have the "source ~#{PGit::Installer::BashAutoCompletion::FILENAME}"' do
+      it 'should source ~#{PGit::Installer::BashAutoCompletion::FILENAME}' do
+        global_opts = {}
+        opts = {}
+        args = {}
+        fake_file = instance_double('File')
+        fake_bashrc_file = instance_double('File')
+        allow(fake_bashrc_file).to receive(:puts).with("source #{PGit::Installer::BashAutoCompletion::FILENAME}").and_return(fake_file)
+        allow(fake_bashrc_file).to receive(:close)
+        short_bashrc_path = "~/.bashrc"
+        expanded_bashrc_path = "/Users/Edderic/.bashrc"
+        bashrc_lines = [
+          "# some more ls aliases\n",
+          "alias ll='ls -alF'\n",
+          "alias la='ls -A'\n",
+          "alias l='ls -CF'\n" ]
+        installation_message = "~/.bashrc will now source #{PGit::Installer::BashAutoCompletion::FILENAME}"
+
+        allow(File).to receive(:expand_path).with(short_bashrc_path).and_return(expanded_bashrc_path)
+        allow(File).to receive(:open).with(expanded_bashrc_path, 'a').and_return(fake_bashrc_file)
+        allow(File).to receive(:readlines).with(expanded_bashrc_path).and_return(bashrc_lines)
+
+        installer = PGit::Installer::BashAutoCompletion.new(global_opts, opts, args)
+        allow(installer).to receive(:puts).with(installation_message)
+
+        installer.source_completer_from_bashrc
+
+        expect(fake_bashrc_file).to have_received(:puts).with "source #{PGit::Installer::BashAutoCompletion::FILENAME}"
+        expect(fake_bashrc_file).to have_received(:close)
+        expect(installer).to have_received(:puts).with(installation_message)
+      end
+    end
+  end
+end

data/spec/pgit/pivotal/individual_request_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'PGit::Pivotal::IndividualRequest' do
+  describe '#get!' do
+    it 'does a cURL request' do
+      class SomeSubclass < PGit::Pivotal::IndividualRequest
+        attr_reader :api_token, :someattr
+        def initialize
+          @api_token
+        end
+
+        def sublink
+          'some/link'
+        end
+      end
+
+      json = double('JSON')
+      some_subclass = SomeSubclass.new
+      some_other_subclass = SomeSubclass.new
+
+      api_token = some_subclass.api_token
+      link = "https://www.pivotaltracker.com/services/v5/some/link"
+      get_request = "curl -X GET -H 'X-TrackerToken: #{api_token}' #{link}"
+      allow(JSON).to receive(:parse).with(json).and_return({ 'kind' => 'project', 'someattr' => '123'})
+      allow(some_subclass).to receive(:`).with(get_request).and_return(json)
+
+      some_subclass.get!
+
+      expect(some_subclass).to have_received(:`).with(get_request)
+    end
+  end
+end

data/spec/pgit/pivotal/iteration_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe PGit::Pivotal::Iteration do
+  describe '#new with hash' do
+    it 'should instantiate stories' do
+      iterations_string = File.read(File.join(PGit.root, 'spec', 'fixtures', 'iterations'))
+      iteration_hashes = JSON.parse(iterations_string)
+      first_iteration_hash = iteration_hashes.first
+      current_project = instance_double('PGit::CurrentProject', id: 123, api_token: 'haba')
+      allow(PGit::CurrentProject).to receive(:new).and_return(current_project)
+      iteration = PGit::Pivotal::Iteration.new do |iteration|
+        iteration.hash = first_iteration_hash
+      end
+
+      first_story = iteration.stories.first
+      expect(first_story.id).to eq 90501214
+    end
+  end
+end