pra 0.1.1

data/lib/pra/window_system.rb

@@ -0,0 +1,38 @@
+module Pra
+  class WindowSystem
+    class PureVirtualMethodNotImplemented < RuntimeError; end
+
+    # This method is a pure virtual method and is intended for the inheriting
+    # class to implement it in order to handle all the initialization and
+    # setup of the windowing system the inheriting class is implementing.
+    def setup
+      raise PureVirtualMethodNotImplemented, "the 'setup' method needs to be implemented."
+    end
+
+    # This method is a pure virtual method and is called by the system
+    # right before the fetching of the pull requests is started. It is simply
+    # intended to be a notification to the window system so that it can notify
+    # the user in whatever is an appropriate fashion that it is in the process
+    # of fetching the pull requests.
+    def fetching_pull_requests
+      raise PureVirtualMethodNotImplemented, "the 'fetching_pull_requests' method needs to be implemented."
+    end
+
+    # This method is a pure virtual method and is intendend for the inheriting
+    # class to implement it to handle refreshing the pull requests within in
+    # the window system. This method is called evertime the pull request
+    # fetching system fetches pull requests.
+    def refresh_pull_requests(pull_requests)
+      raise PureVirtualMethodNotImplemented, "the 'refresh_pull_requests' method needs to be implemented."
+    end
+
+    # This method is a pure virtual method and is intended for the inherting
+    # class to implement it in order to initiate the main run loop of the
+    # windowing system the inheriting class is implementing. It can also be
+    # used to include any tear down that needs to happen when the run loop
+    # exits.
+    def run_loop
+      raise PureVirtualMethodNotImplemented, "the 'run_loop' method needs to be implemented."
+    end
+  end
+end

data/lib/pra/window_system_factory.rb

@@ -0,0 +1,16 @@
+require 'pra/curses_window_system'
+
+module Pra
+  module WindowSystemFactory
+    class UnknownWindowSystemId < RuntimeError; end
+
+    def self.build(window_system_id)
+      case window_system_id
+      when 'curses'
+        return Pra::CursesWindowSystem.new
+      else
+        raise Pra::WindowSystemFactory::UnknownWindowSystemId, ".build() doesn't know about a windows system identified by '#{window_system_id}'"
+      end
+    end
+  end
+end

data/lib/pra.rb

@@ -0,0 +1,5 @@
+require "pra/version"
+
+module Pra
+  # Your code goes here...
+end

data/pra.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pra/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pra"
+  spec.version       = Pra::VERSION
+  spec.authors       = ["Andrew De Ponte"]
+  spec.email         = ["cyphactor@gmail.com"]
+  spec.description   = %q{Command Line utility to make you aware of open pull-requests across systems at all times.}
+  spec.summary       = %q{CLI tool that shows open pull-requests across systems.}
+  spec.homepage      = "http://github.com/reachlocal/pra"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+
+  spec.add_dependency "rest-client", "~> 1.6.7"
+  spec.add_dependency "launchy", "~> 2.3.0"
+end

data/spec/lib/pra/app_spec.rb

@@ -0,0 +1,72 @@
+require_relative "../../../lib/pra/app"
+
+describe Pra::App do
+  describe "#run" do
+    it "builds the window system" do
+      subject.stub(:spawn_pull_request_fetcher)
+      window_system_double = double('window system', setup: nil, run_loop: nil)
+      expect(Pra::WindowSystemFactory).to receive(:build).with('curses').and_return(window_system_double)
+      subject.run
+    end
+
+    it "sets up the window system" do
+      subject.stub(:spawn_pull_request_fetcher)
+      window_system_double = double('window system', run_loop: nil)
+      Pra::WindowSystemFactory.stub(:build).and_return(window_system_double)
+      expect(window_system_double).to receive(:setup)
+      subject.run
+    end
+
+    it "spawns the pull request fetcher thread" do
+      window_system_double = double('window system', setup: nil, run_loop: nil)
+      Pra::WindowSystemFactory.stub(:build).and_return(window_system_double)
+      expect(subject).to receive(:spawn_pull_request_fetcher)
+      subject.run
+    end
+
+    it "starts the window system run loop" do
+      subject.stub(:spawn_pull_request_fetcher)
+      window_system_double = double('window system', setup: nil, refresh_pull_requests: nil)
+      Pra::WindowSystemFactory.stub(:build).and_return(window_system_double)
+      expect(window_system_double).to receive(:run_loop)
+      subject.run
+    end
+  end
+
+  describe "#fetch_and_refresh_pull_requests" do
+    it "notifies the window system it is starting to fetch pull requests" do
+      Kernel.stub(:sleep)
+      Pra::PullRequestService.stub(:fetch_pull_requests)
+      window_system_double = double('window system', refresh_pull_requests: nil)
+      subject.instance_variable_set(:@window_system, window_system_double)
+      expect(window_system_double).to receive(:fetching_pull_requests)
+      subject.fetch_and_refresh_pull_requests
+    end
+
+    it "fetches the pull requests from all of the sources" do
+      Kernel.stub(:sleep)
+      window_system_double = double('window system', refresh_pull_requests: nil, fetching_pull_requests: nil)
+      subject.instance_variable_set(:@window_system, window_system_double)
+      expect(Pra::PullRequestService).to receive(:fetch_pull_requests)
+      subject.fetch_and_refresh_pull_requests
+    end
+
+    it "tells the window system to refresh pull requests" do
+      Kernel.stub(:sleep)
+      pull_requests = double('fetched pull requests')
+      Pra::PullRequestService.stub(:fetch_pull_requests).and_return(pull_requests)
+      window_system_double = double('window system', fetching_pull_requests: nil)
+      subject.instance_variable_set(:@window_system, window_system_double)
+      expect(window_system_double).to receive(:refresh_pull_requests).with(pull_requests)
+      subject.fetch_and_refresh_pull_requests
+    end
+
+    it "sleeps for the polling frequency" do
+      window_system_double = double('window system', refresh_pull_requests: nil, fetching_pull_requests: nil)
+      subject.instance_variable_set(:@window_system, window_system_double)
+      Pra::PullRequestService.stub(:fetch_pull_requests)
+      expect(Kernel).to receive(:sleep)
+      subject.fetch_and_refresh_pull_requests
+    end
+  end
+end

data/spec/lib/pra/config_spec.rb

@@ -0,0 +1,128 @@
+require_relative "../../../lib/pra/config"
+
+describe Pra::Config do
+  describe "#initialize" do
+    it "assigns the provide default config hash" do
+      config_hash = { some: "hash" }
+      config = Pra::Config.new(config_hash)
+      config.instance_variable_get(:@initial_config).should eq(config_hash)
+    end
+  end
+
+  describe ".load_config" do
+    subject { Pra::Config }
+
+    it "parses the config file" do
+      subject.should_receive(:parse_config_file)
+      subject.load_config
+    end
+
+    it "constructs an instance of the config from the parsed config" do
+      parsed_config = double('parsed config file')
+      subject.stub(:parse_config_file).and_return(parsed_config)
+      subject.should_receive(:new).with(parsed_config)
+      subject.load_config
+    end
+
+    it "returns the instance of the config object" do
+      subject.stub(:parse_config_file)
+      config = double('config')
+      subject.stub(:new).and_return(config)
+      subject.load_config.should eq(config)
+    end
+  end
+
+  describe ".parse_config_file" do
+    subject { Pra::Config }
+
+    it "reads the users config" do
+      subject.stub(:json_parse)
+      subject.should_receive(:read_config_file)
+      subject.parse_config_file
+    end
+
+    it "json parses the config contents" do
+      config_contents = double('config contents')
+      subject.stub(:read_config_file).and_return(config_contents)
+      subject.should_receive(:json_parse).with(config_contents)
+      subject.parse_config_file
+    end
+  end
+
+  describe ".read_config_file" do
+    subject { Pra::Config }
+
+    it "opens the file" do
+      config_path = double('config path')
+      subject.stub(:config_path).and_return(config_path)
+      File.should_receive(:open).with(config_path, "r").and_return(double('config file').as_null_object)
+      subject.read_config_file
+    end
+
+    it "reads the files contents" do
+      subject.stub(:config_path)
+      file = double('config file').as_null_object
+      File.stub(:open).and_return(file)
+      file.should_receive(:read)
+      subject.read_config_file
+    end
+
+    it "closes the file" do
+      subject.stub(:config_path)
+      file = double('config file', read: nil)
+      File.stub(:open).and_return(file)
+      file.should_receive(:close)
+      subject.read_config_file
+    end
+
+    it "returns the file contents" do
+      subject.stub(:config_path)
+      file = double('config file', close: nil)
+      File.stub(:open).and_return(file)
+      file.stub(:read).and_return('some file contents')
+      subject.read_config_file.should eq('some file contents')
+    end
+  end
+
+  describe ".config_path" do
+    subject { Pra::Config }
+
+    it "returns the joined users home directory and .pra.json to create the path" do
+      subject.stub(:users_home_directory).and_return('/home/someuser')
+      subject.config_path.should eq('/home/someuser/.pra.json')
+    end
+  end
+
+  describe ".users_home_directory" do
+    subject { Pra::Config }
+
+    it "returns the current users home directory" do
+      ENV['HOME'] = '/home/someuser'
+      subject.users_home_directory.should eq('/home/someuser')
+    end
+  end
+
+  describe ".json_parse" do
+    subject { Pra::Config }
+
+    it "parses the given content as json" do
+      content = double('some json content')
+      JSON.should_receive(:parse).with(content)
+      subject.json_parse(content)
+    end
+
+    it "returns the parsed result" do
+      parsed_json = double('the parsed json')
+      JSON.stub(:parse).and_return(parsed_json)
+      subject.json_parse(double).should eq(parsed_json)
+    end
+  end
+
+  describe "#pull_sources" do
+    it "returns the pull sources value out of the config" do
+      pull_source_configs = double('pull source configs')
+      subject.instance_variable_set(:@initial_config, { "pull_sources" => pull_source_configs })
+      subject.pull_sources.should eq(pull_source_configs)
+    end
+  end
+end

data/spec/lib/pra/curses_window_system_spec.rb

@@ -0,0 +1,4 @@
+require_relative "../../../lib/pra/curses_window_system"
+
+describe Pra::CursesWindowSystem do
+end

data/spec/lib/pra/github_pull_source_spec.rb

@@ -0,0 +1,128 @@
+require_relative "../../../lib/pra/github_pull_source"
+
+describe Pra::GithubPullSource do
+  describe "#pull_requests" do
+    it "gets all the repositories" do
+      subject.should_receive(:repositories).and_return([])
+      subject.pull_requests
+    end
+
+    it "gets the pull requests for each repository" do
+      config = {
+        "protocol" => "https",
+        "host" => "my.github.instance",
+        "username" => "foo",
+        "password" => "bar",
+        "repositories" => [
+          { "owner" => "reachlocal", "repository" => "snapdragon" }
+        ]
+      }
+      pull_source = Pra::GithubPullSource.new(config)
+      pull_source.should_receive(:get_repo_pull_requests).with({ "owner" => "reachlocal", "repository" => "snapdragon" }).and_return([])
+      pull_source.pull_requests
+    end
+
+    it "returns the collection of all of the pull requests for the configured repos" do
+      config = {
+        "protocol" => "https",
+        "host" => "my.github.instance",
+        "username" => "foo",
+        "password" => "bar",
+        "repositories" => [
+          { "owner" => "reachlocal", "repository" => "snapdragon" },
+          { "owner" => "realpractice", "repository" => "rliapi" }
+        ]
+      }
+      pull_request_one = double('pull request one')
+      pull_request_two = double('pull request two')
+      pull_source = Pra::GithubPullSource.new(config)
+      pull_source.stub(:get_repo_pull_requests).with({ "owner" => "reachlocal", "repository" => "snapdragon" }).and_return([pull_request_one])
+      pull_source.stub(:get_repo_pull_requests).with({ "owner" => "realpractice", "repository" => "rliapi" }).and_return([pull_request_two])
+      pull_source.pull_requests.should eq([pull_request_one, pull_request_two])
+    end
+  end
+
+  describe "#repositories" do
+    it "returns the repositories segment of the config" do
+      config = {
+        "protocol" => "https",
+        "host" => "my.github.instance",
+        "username" => "foo",
+        "password" => "bar",
+        "repositories" => [
+          { "owner" => "reachlocal", "repository" => "snapdragon" }
+        ]
+      }
+      pull_source = Pra::GithubPullSource.new(config)
+      pull_source.repositories.should eq([{ "owner" => "reachlocal", "repository" => "snapdragon" }])
+    end
+  end
+  
+  describe "#get_repo_pull_requests" do
+    it "requests the pull requests for the given repo" do
+      config = {
+        "protocol" => "https",
+        "host" => "my.github.instance",
+        "username" => "foo",
+        "password" => "bar",
+        "repositories" => [
+          { "owner" => "reachlocal", "repository" => "snapdragon" }
+        ]
+      }
+      pull_source = Pra::GithubPullSource.new(config)
+      the_resource = double
+      pull_source.stub(:rest_api_pull_request_resource).with({ "owner" => "reachlocal", "repository" => "snapdragon" }).and_return(the_resource)
+      the_resource.should_receive(:get).and_return('[]')
+      pull_source.get_repo_pull_requests({ "owner" => "reachlocal", "repository" => "snapdragon" })
+    end
+  end
+
+  describe "#rest_api_pull_request_url" do
+    let(:config) do
+      {
+        "protocol" => "https",
+        "host" => "my.github.instance",
+        "username" => "foo",
+        "password" => "bar",
+        "repositories" => [
+          { "owner" => "reachlocal", "repository" => "snapdragon" }
+        ]
+      }
+    end
+
+    it "returns the pull request url compiled from the config options" do
+      pull_source = Pra::GithubPullSource.new(config)
+      pull_source.rest_api_pull_request_url({ "owner" => "reachlocal", "repository" => "snapdragon" }).should eq("https://my.github.instance/repos/reachlocal/snapdragon/pulls")
+    end
+  end
+
+  describe "#rest_api_pull_request_resource" do
+    let(:config) do
+      {
+        "protocol" => "https",
+        "host" => "my.github.instance",
+        "username" => "foo",
+        "password" => "bar",
+        "repositories" => [
+          { "owner" => "reachlocal", "repository" => "snapdragon" }
+        ]
+      }
+    end
+
+    let(:repo_config) { {"owner" => "reachlocal", "repository" => "snapdragon"} }
+
+    subject { Pra::GithubPullSource.new(config) }
+
+    it "gets the repository url compiled from the config options" do
+      subject.should_receive(:rest_api_pull_request_url).with(repo_config)
+      subject.rest_api_pull_request_resource(repo_config)
+    end
+
+    it "builds a restclient resource using the pull request url and user credentials" do
+      url = "https://my.github.instance/repos/reachlocal/snapdragon/pulls"
+      subject.stub(:rest_api_pull_request_url).and_return(url)
+      RestClient::Resource.should_receive(:new).with(url, {user: "foo", password: "bar", content_type: :json, accept: :json})
+      subject.rest_api_pull_request_resource(repo_config)
+    end
+  end
+end

data/spec/lib/pra/pull_request_service_spec.rb

@@ -0,0 +1,78 @@
+require_relative '../../../lib/pra/pull_request_service'
+
+describe Pra::PullRequestService do
+  describe ".fetch_pull_requests" do
+    it "gets all the pull-request sources" do
+      subject.should_receive(:pull_sources).and_return([])
+      subject.fetch_pull_requests
+    end
+
+    it "gets the pull requests from each pull-request source" do
+      pull_source_one = double('pull source one')
+      pull_source_two = double('pull source two')
+      subject.stub(:pull_sources).and_return([pull_source_one, pull_source_two])
+      pull_source_one.should_receive(:pull_requests).and_return([])
+      pull_source_two.should_receive(:pull_requests).and_return([])
+      subject.fetch_pull_requests
+    end
+
+    it "returns an array of all the pull-requests from each of the sources" do
+      pull_request_one = double('pull request one')
+      pull_request_two = double('pull request two')
+      pull_source_one = double('pull source one', :pull_requests => [pull_request_one])
+      pull_source_two = double('pull source two', :pull_requests => [pull_request_two])
+      subject.stub(:pull_sources).and_return([pull_source_one, pull_source_two])
+      subject.fetch_pull_requests.should eq([pull_request_one, pull_request_two])
+    end
+  end
+
+  describe "#pull_sources" do
+    it "gets the users config" do
+      subject.stub(:map_config_to_pull_sources)
+      Pra::Config.should_receive(:load_config)
+      subject.pull_sources
+    end
+
+    it "maps the pull-request sources from the config to PullSource objects" do
+      config = double('users config')
+      Pra::Config.stub(:load_config).and_return(config)
+      subject.should_receive(:map_config_to_pull_sources).with(config)
+      subject.pull_sources
+    end
+
+    it "returns the mapped pull-request sources" do
+      Pra::Config.stub(:load_config)
+      sources = double('pull sources')
+      subject.stub(:map_config_to_pull_sources).and_return(sources)
+      subject.pull_sources.should eq(sources)
+    end
+  end
+
+  describe "#map_config_to_pull_sources" do
+    it "gets the pull sources from the config" do
+      config = double('config')
+      config.should_receive(:pull_sources).and_return([])
+      subject.map_config_to_pull_sources(config)
+    end
+
+    it "creates a PullSource based object for each configured pull source" do
+      pull_source_config_one = double('pull source config one')
+      pull_source_config_two = double('pull source config two')
+      config = double('config', pull_sources: [pull_source_config_one, pull_source_config_two])
+      Pra::PullSourceFactory.should_receive(:build_pull_source).with(pull_source_config_one)
+      Pra::PullSourceFactory.should_receive(:build_pull_source).with(pull_source_config_two)
+      subject.map_config_to_pull_sources(config)
+    end
+
+    it "returns an array of the constructed PullSource based objects" do
+      pull_source_one = double('pull source one')
+      pull_source_two = double('pull source two')
+      pull_source_config_one = double('pull source config one')
+      pull_source_config_two = double('pull source config two')
+      config = double('config', pull_sources: [pull_source_config_one, pull_source_config_two])
+      Pra::PullSourceFactory.stub(:build_pull_source).with(pull_source_config_one).and_return(pull_source_one)
+      Pra::PullSourceFactory.stub(:build_pull_source).with(pull_source_config_two).and_return(pull_source_two)
+      subject.map_config_to_pull_sources(config).should eq([pull_source_one, pull_source_two])
+    end
+  end
+end

data/spec/lib/pra/pull_request_spec.rb

@@ -0,0 +1,4 @@
+require_relative "../../../lib/pra/pull_request"
+
+describe Pra::PullRequest do
+end

data/spec/lib/pra/pull_source_factory_spec.rb

@@ -0,0 +1,40 @@
+require_relative "../../../lib/pra/pull_source_factory"
+
+describe Pra::PullSourceFactory do
+  describe ".build_pull_source" do
+    it "maps the pull source type to class" do
+      pull_source_type_specific_configs = double('pull source type specific configs')
+      pull_source_config = { "type" => "stash", "config" => pull_source_type_specific_configs }
+      subject.should_receive(:map_type_to_klass).with("stash").and_return(Pra::StashPullSource)
+      subject.build_pull_source(pull_source_config)
+    end
+
+    it "constructs the mapped PullSource based object using the given pull source type specific config" do
+      pull_source_type_specific_configs = double('pull source type specific configs')
+      pull_source_config = { "type" => "stash", "config" => pull_source_type_specific_configs }
+      Pra::StashPullSource.should_receive(:new).with(pull_source_type_specific_configs)
+      subject.build_pull_source(pull_source_config)
+    end
+
+    it "returns the instance of the previously constructed PullSource based object" do
+      pull_source = double('the constructed pull source')
+      pull_source_config = { "type" => "stash", "config" => {} }
+      Pra::StashPullSource.should_receive(:new).and_return(pull_source)
+      subject.build_pull_source(pull_source_config).should eq(pull_source)
+    end
+  end
+
+  describe ".map_type_to_klass" do
+    context "when given type is 'stash'" do
+      it "returns the StashPullSource class" do
+        subject.map_type_to_klass("stash").should eq(Pra::StashPullSource)
+      end
+    end
+
+    context "When given type is 'github'" do
+      it "returns the GithubPullSource class" do
+        subject.map_type_to_klass("github").should eq(Pra::GithubPullSource)
+      end
+    end
+  end
+end

data/spec/lib/pra/pull_source_spec.rb

@@ -0,0 +1,17 @@
+require_relative "../../../lib/pra/pull_source"
+
+describe Pra::PullSource do
+  describe "#initialize" do
+    it "assigns the given config hash to an instance variable" do
+      config = double('config hash')
+      pull_source = Pra::PullSource.new(config)
+      pull_source.instance_variable_get(:@config).should eq(config)
+    end
+  end
+
+  describe "#pull_requests" do
+    it "raises an exception forcing inheriting classes to implement this method" do
+      expect { subject.pull_requests }.to raise_error(Pra::PullSource::NotImplemented)
+    end
+  end
+end