ghi 0.3.1 → 0.9.0.dev

data/lib/ghi/issue.rb

@@ -1,30 +0,0 @@
-class GHI::Issue
-  attr_reader :number, :title, :body, :votes, :state, :user, :created_at,
-    :updated_at, :labels
-
-  def initialize(options = {})
-    @number     = options["number"]
-    @title      = options["title"]
-    @body       = options["body"]
-    @votes      = options["votes"]
-    @state      = options["state"]
-    @user       = options["user"]
-    @created_at = options["created_at"]
-    @updated_at = options["updated_at"]
-    @labels     = options["labels"]
-  end
-
-  #-
-  # REFACTOR: This code is duplicated from cli.rb:gets_from_editor.
-  #+
-  def ==(other_issue)
-    case other_issue
-    when Array
-      other_title = other_issue.first.strip
-      other_body  = other_issue[1..-1].join.sub(/\b\n\b/, " ").strip
-      title == other_title && body == other_body
-    else
-      super other_issue
-    end
-  end
-end

data/spec/ghi/api_spec.rb

@@ -1,218 +0,0 @@
-$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
-require "ghi"
-require "ghi/api"
-require "ghi/issue"
-include GHI
-
-ISSUES_YAML = <<-YAML
----
-issues:
-- number: 1
-  votes: 0
-  created_at: 2009-04-17 14:55:33 -07:00
-  body: my sweet, sweet issue
-  title: new issue
-  updated_at: 2009-04-17 14:55:33 -07:00
-  user: schacon
-  state: open
-- number: 2
-  votes: 0
-  created_at: 2009-04-17 15:16:47 -07:00
-  body: the body of a second issue
-  title: another issue
-  updated_at: 2009-04-17 15:16:47 -07:00
-  user: schacon
-  state: open
-YAML
-
-ISSUE_YAML = <<-YAML
----
-issue:
-  number: 1
-  votes: 0
-  created_at: 2009-04-17 14:55:33 -07:00
-  body: my sweet, sweet issue
-  title: new issue
-  updated_at: 2009-04-17 14:55:33 -07:00
-  user: schacon
-  state: open
-YAML
-
-LABELS_YAML = <<-YAML
----
-labels:
-- testing
-- test_label
-YAML
-
-COMMENT_YAML = <<-YAML
----
-comment:
-  comment: this is amazing
-  status: saved
-YAML
-
-describe GHI::API do
-  it "should require user and repo" do
-    proc { API.new(nil, nil) }.should raise_error(API::InvalidConnection)
-    proc { API.new("u", nil) }.should raise_error(API::InvalidConnection)
-    proc { API.new(nil, "r") }.should raise_error(API::InvalidConnection)
-    proc { API.new("u", "r") }.should_not raise_error(API::InvalidConnection)
-  end
-
-  describe "requests" do
-    before :each do
-      @api = API.new "stephencelis", "ghi"
-      GHI.stub!(:login).and_return "stephencelis"
-      GHI.stub!(:token).and_return "token"
-
-      @http = mock(Net::HTTP)
-      @http.stub(:start) { |l| l.call }
-    end
-
-    it "should substitute url tokens" do
-      @api.send(:path, :open).should ==
-        "/api/v2/yaml/issues/open/stephencelis/ghi"
-      @api.send(:path, :show, 1).should ==
-        "/api/v2/yaml/issues/show/stephencelis/ghi/1"
-      @api.send(:path, :search, :open, "me").should ==
-        "/api/v2/yaml/issues/search/stephencelis/ghi/open/me"
-      @api.send(:path, "label/add", "me").should ==
-        "/api/v2/yaml/issues/label/add/stephencelis/ghi/me"
-    end
-
-    it "should process gets" do
-      path  = "/api/v2/yaml/issues/open/stephencelis/ghi"
-      query = "?login=stephencelis&token=token"
-      @api.stub!(:path).and_return path
-      req = mock(Net::HTTPRequest)
-      res = mock(Net::HTTPResponse)
-      Net::HTTP.should_receive(:new).once.and_return @http
-      Net::HTTP::Get.should_receive(:new).once.with(path + query).
-        and_return req
-      @http.should_receive(:request).once.with(req).and_return res
-      res.should_receive(:body).once.and_return ISSUES_YAML
-      @api.list
-    end
-
-    it "should process posts" do
-      path  = "/api/v2/yaml/issues/open/stephencelis/ghi"
-      query = { "login" => "stephencelis",
-                "token" => "token",
-                "title" => "Title",
-                "body"  => "Body" }
-      @api.stub!(:path).and_return path
-      req = mock(Net::HTTPRequest)
-      res = mock(Net::HTTPResponse)
-      Net::HTTP.should_receive(:new).once.and_return @http
-      Net::HTTP::Post.should_receive(:new).once.with(path).and_return req
-      req.should_receive(:set_form_data).once
-      @http.should_receive(:request).once.with(req).and_return res
-      res.should_receive(:body).once.and_return ISSUE_YAML
-      @api.open "Title", "Body"
-    end
-
-    def expect_get_response(body)
-      req = mock(Net::HTTPRequest)
-      res = mock(Net::HTTPResponse)
-      Net::HTTP.should_receive(:new).once.and_return @http
-      Net::HTTP::Get.should_receive(:new).once.and_return req
-      @http.should_receive(:request).once.with(req).and_return res
-      res.should_receive(:body).once.and_return body
-    end
-
-    def expect_post_response(body)
-      req = mock(Net::HTTPRequest)
-      res = mock(Net::HTTPResponse)
-      Net::HTTP.should_receive(:new).once.and_return @http
-      Net::HTTP::Post.should_receive(:new).once.and_return req
-      req.should_receive(:set_form_data).once
-      @http.should_receive(:request).once.with(req).and_return res
-      res.should_receive(:body).once.and_return body
-    end
-
-    it "should search open by default" do
-      @api.should_receive(:path).with(:search, :open, "me").and_return "u"
-      expect_get_response ISSUES_YAML
-      issues = @api.search "me"
-      issues.should be_an_instance_of(Array)
-      issues.each { |issue| issue.should be_an_instance_of(Issue) }
-    end
-
-    it "should search closed" do
-      @api.should_receive(:path).with(:search, :closed, "me").and_return "u"
-      expect_get_response ISSUES_YAML
-      @api.search "me", :closed
-    end
-
-    it "should list open by default" do
-      @api.should_receive(:path).with(:list, :open).and_return "u"
-      expect_get_response ISSUES_YAML
-      issues = @api.list
-      issues.should be_an_instance_of(Array)
-      issues.each { |issue| issue.should be_an_instance_of(Issue) }
-    end
-
-    it "should list closed" do
-      @api.should_receive(:path).with(:list, :closed).and_return "u"
-      expect_get_response ISSUES_YAML
-      @api.list :closed
-    end
-
-    it "should show" do
-      @api.should_receive(:path).with(:show, 1).and_return "u"
-      expect_get_response ISSUE_YAML
-      @api.show(1).should be_an_instance_of(Issue)
-    end
-
-    it "should open" do
-      @api.should_receive(:path).with(:open).and_return "u"
-      expect_post_response ISSUE_YAML
-      @api.open("Title", "Body").should be_an_instance_of(Issue)
-    end
-
-    it "should edit" do
-      @api.should_receive(:path).with(:edit, 1).and_return "u"
-      expect_post_response ISSUE_YAML
-      @api.edit(1, "Title", "Body").should be_an_instance_of(Issue)
-    end
-
-    it "should close" do
-      @api.should_receive(:path).with(:close, 1).and_return "u"
-      expect_post_response ISSUE_YAML
-      @api.close(1).should be_an_instance_of(Issue)
-    end
-
-    it "should reopen" do
-      @api.should_receive(:path).with(:reopen, 1).and_return "u"
-      expect_post_response ISSUE_YAML
-      @api.reopen(1).should be_an_instance_of(Issue)
-    end
-
-    it "should add labels" do
-      @api.should_receive(:path).with("label/add", 1, "l").and_return "u"
-      expect_post_response LABELS_YAML
-      @api.add_label(1, "l").should be_an_instance_of(Array)
-    end
-
-    it "should remove labels" do
-      @api.should_receive(:path).with("label/remove", 1, "l").and_return "u"
-      expect_post_response LABELS_YAML
-      @api.remove_label(1, "l").should be_an_instance_of(Array)
-    end
-
-    it "should comment, and escape values" do
-      @api.should_receive(:path).with(:comment, 1).and_return "u"
-
-      req = mock(Net::HTTPRequest)
-      res = mock(Net::HTTPResponse)
-      Net::HTTP.should_receive(:new).once.and_return @http
-      Net::HTTP::Post.should_receive(:new).once.and_return req
-      req.should_receive(:set_form_data).once
-      @http.should_receive(:request).once.with(req).and_return res
-      res.should_receive(:body).once.and_return COMMENT_YAML
-
-      @api.comment(1, "Comment&so").should be_an_instance_of(Hash)
-    end
-  end
-end

data/spec/ghi/cli_spec.rb

@@ -1,267 +0,0 @@
-require "ghi"
-require "ghi/api"
-require "ghi/cli"
-
-describe GHI::CLI::Executable do
-  before :each do
-    @cli = GHI::CLI::Executable.new
-    @cli.stub!(:api).and_return(mock(GHI::API))
-    $stdout.stub! :close_write
-    IO.stub!(:popen).and_return $stdout
-  end
-
-  describe "parsing" do
-    describe "with well-formed arguments" do
-      before :each do
-        @user, @repo = "local_user_host", "ghi"
-        @action = @state = @number = @term =
-          @title = @body = @tag = @comment = nil
-      end
-
-      after :each do
-        @cli.should_receive(@action)
-        @cli.parse! Array(@args)
-        @cli.action.should == @action
-        @cli.state.should  == (@state || :open)
-        @cli.number.should == @number
-        @cli.search_term.should == @term
-        @cli.title.should == @title
-        @cli.body.should == @body
-        @cli.user.should == @user
-        @cli.repo.should == @repo
-        @cli.tag.should == @tag
-        if @commenting
-          @cli.should be_commenting
-        else
-          @cli.should_not be_commenting
-        end
-      end
-
-      it "should always parse -r" do
-        @args = ["-rremoteuser/remoterepo", "-l"]
-        @action, @state, @user, @repo = :list, :open, "remoteuser", "remoterepo"
-      end
-
-      describe "inside a repository" do
-        after :each do
-          @cli.stub!(:`).and_return "stub@github.com:#@user/#@repo.git"
-        end
-
-        it "should parse empty as list open" do
-          @action, @state = :list, :open
-        end
-
-        it "should parse -l as list open" do
-          @args = ["-l"]
-          @action, @state = :list, :open
-        end
-
-        it "should parse -l as list open" do
-          @args = ["-l"]
-          @action, @state = :list, :open
-        end
-
-        it "should parse -lo as list open" do
-          @args = ["-lo"]
-          @action, @state = :list, :open
-        end
-
-        it "should parse -lc as list closed" do
-          @args = ["-lc"]
-          @action, @state = :list, :closed
-        end
-
-        it "should parse -l2 as show issue 2" do
-          @args = ["-l2"]
-          @action, @number = :show, 2
-        end
-
-        it "should parse -l 'term' as search open for 'term'" do
-          @args = ["-l", "term"]
-          @action, @state, @term = :search, :open, "term"
-        end
-
-        it "should parse -o as open new issue" do
-          @args = ["-o"]
-          @action = :open
-        end
-
-        it "should parse -o 'New Issue' as open issue with title 'New Issue'" do
-          @args = ["-o", "New Issue"]
-          @action, @title = :open, "New Issue"
-        end
-
-        it "should parse -om 'New Issue' as open issue with'New Issue'" do
-          @args = ["-om", "New Issue"]
-          @action, @title = :open, "New Issue"
-        end
-
-        it "should parse -o 'New Issue' -m as open 'New Issue' in $EDITOR" do
-          @args = ["-o", "New Issue", "-m"]
-          @action, @title, @commenting = :open, "New Issue", true
-        end
-
-        it "should parse -o 'Issue' -m 'Body' as open 'Issue' with 'Body'" do
-          @args = ["-o", "Issue", "-m", "Body"]
-          @action, @title, @body = :open, "Issue", "Body"
-        end
-
-        it "should parse -o2 as reopen issue 2" do
-          @args = ["-o2"]
-          @action, @number = :reopen, 2
-        end
-
-        it "should parse -o2 -m as reopen issue 2 with a comment" do
-          @args = ["-o2", "-m"]
-          @action, @number, @commenting = :reopen, 2, true
-        end
-
-        it "should parse -o2 -m 'Comment' as reopen issue 2" do
-          @args = ["-o2", "-m", "Comment"]
-          @action, @number, @body = :reopen, 2, "Comment"
-        end
-
-        it "should parse -ol as list open" do
-          @args = ["-ol"]
-          @action, @state = :list, :open
-        end
-
-        it "should parse -ou as return open issues url" do
-          @args = ["-ou"]
-          @action = :url # Should state be :open?
-        end
-
-        it "should parse -cl as list closed" do
-          @args = ["-cl"]
-          @action, @state = :list, :closed
-        end
-
-        it "should parse -c2 as close issue 2" do
-          @args = ["-c2"]
-          @action, @number = :close, 2
-        end
-
-        it "should parse -c2 -m as close issue 2 with a comment" do
-          @args = ["-c2", "-m"]
-          @action, @number, @commenting = :close, 2, true
-        end
-
-        it "should parse -c2 -m 'Fixed' as close issue 2 with 'Fixed'" do
-          @args = ["-c2", "-m", "Fixed"]
-          @action, @number, @body = :close, 2, "Fixed"
-        end
-
-        it "should parse -m2 -c as close issue 2 with a comment" do
-          @args = ["-m2", "-c"]
-          @action, @number, @commenting = :close, 2, true
-        end
-
-        it "should parse -cu as return closed issues url" do
-          @args = ["-cu"]
-          @action, @state = :url, :closed
-        end
-
-        it "should parse -e2 as edit issue 2" do
-          @args = ["-e2"]
-          @action, @number = :edit, 2
-        end
-
-        it "should parse -rlocalrepo as localuser/localrepo" do
-          GHI.stub!(:login).and_return "localuser"
-          @args = ["-rlocalrepo", "-l"]
-          @action, @state, @user, @repo = :list, :open, "localuser", "localrepo"
-        end
-
-        it "should parse -rremoteuser/remoterepo as remoteuser/remoterepo" do
-          @args = ["-rremoteuser/remoterepo", "-l"]
-          @action, @state, @user, @repo = :list, :open, "remoteuser", "remoterepo"
-        end
-
-        it "should parse -rremoteuser/remoterepo as a later argument" do
-          @args = ["-1", "-rremoteuser/remoterepo"]
-          @action, @number, @user, @repo = :show, 1, "remoteuser", "remoterepo"
-        end
-
-        it "should parse -t2 'tag' as label issue 2 with 'tag'" do
-          @args = ["-t2", "tag"]
-          @action, @number, @tag = :label, 2, "tag"
-        end
-
-        it "should parse -d2 'tag' as remove label 'tag' from issue 2" do
-          @args = ["-d2", "tag"]
-          @action, @number, @tag = :unlabel, 2, "tag"
-        end
-
-        it "should parse -m2 as comment on issue 2" do
-          @args = ["-m2"]
-          @action, @number, @commenting = :comment, 2, true
-        end
-
-        it "should parse -m2 'Comment' as comment 'Comment' on issue 2" do
-          @args = ["-m2", "Comment"]
-          @action, @number, @body = :comment, 2, "Comment"
-        end
-
-        it "should parse -u as return open issues url" do
-          @args = ["-u"]
-          @action = :url # Should state be :open?
-        end
-
-        it "should parse -uo as return open issues url" do
-          @args = ["-uo"]
-          @action = :url # Should state be :open?
-        end
-
-        it "should parse -uc as return open issues url" do
-          @args = ["-uc"]
-          @action, @state = :url, :closed
-        end
-
-        it "should parse -u2 as return issue 2 url" do
-          @args = ["-u2"]
-          @action, @number = :url, 2
-        end
-
-        it "should parse -uu as return unread issues url" do
-          @args = ["-uu"]
-          @action, @state = :url, :unread
-        end
-      end
-    end
-
-    describe "with malformed arguments" do
-      before :each do
-        @cli.should_receive :warn
-        @cli.should_receive(:exit).with 1
-      end
-
-      it "should exit with -e" do
-        @cli.should_receive :puts
-        @cli.parse! ["-e"]
-      end
-
-      it "should exit with -e 'invalid'" do
-        @cli.should_receive :puts
-        @cli.parse! ["-e", "invalid"]
-      end
-
-      it "should exit with -c as list closed" do
-        @cli.parse! ["-c"]
-      end
-
-      it "should exit with -r" do
-        @cli.should_receive :puts
-        @cli.parse! ["-r"]
-      end
-
-      it "should exit with -t" do
-        @cli.should_receive :puts
-        @cli.parse! ["-t"]
-      end
-
-      it "should exit with -t2" do
-        @cli.parse! ["-t2"]
-      end
-    end
-  end
-end