get_to_work 0.1.0

data/lib/get_to_work.rb

@@ -0,0 +1,20 @@
+require "pry"
+require "thor"
+require "get_to_work/menu" # thor extensions
+require "get_to_work/menu_presenter"
+
+require "get_to_work/version"
+require "get_to_work/cli"
+require "get_to_work/command"
+require "get_to_work/keychain"
+require "get_to_work/command/bootstrap"
+require "get_to_work/command/start"
+require "get_to_work/command/stop"
+require "get_to_work/service"
+require "get_to_work/service/pivotal_tracker"
+require "get_to_work/service/harvest"
+require "get_to_work/config_file"
+
+module GetToWork
+  # Your code goes here...
+end

data/lib/get_to_work/cli.rb

@@ -0,0 +1,20 @@
+module GetToWork
+  class CLI < Thor
+    include GetToWork::Menu
+
+    desc "bootstrap", "creates .gtw configuration for your current working directory"
+    def bootstrap
+      GetToWork::Command::Bootstrap.run(cli: self)
+    end
+
+    desc "start <Pivotal Tracker Story ID or URL>", "start working on a pivotal tracker story"
+    def start(pt_id = nil)
+      GetToWork::Command::Start.run(cli: self, pt_id: pt_id)
+    end
+
+    desc "stop", "#stop working on your current story"
+    def stop
+      GetToWork::Command::Stop.run(cli: self)
+    end
+  end
+end

data/lib/get_to_work/command.rb

@@ -0,0 +1,35 @@
+require "keychain"
+
+module GetToWork
+  class Command
+    def self.run(opts = {})
+      trap("SIGINT") { exit! }
+      new(opts).run
+    end
+
+    def initialize(opts = {})
+      @cli = opts[:cli]
+    end
+
+    def config_file
+      ConfigFile.instance
+    end
+
+    def last_timer
+      config_file["last_timer"]
+    end
+
+    def last_story
+      config_fild["last_story"]
+    end
+
+    def harvest_service
+      @harvest ||= GetToWork::Service::Harvest.new(
+        GetToWork::ConfigFile.instance.data
+      )
+    end
+
+    def run
+    end
+  end
+end

data/lib/get_to_work/command/bootstrap.rb

@@ -0,0 +1,114 @@
+require "pivotal-tracker"
+
+module GetToWork
+  class Command
+    class Bootstrap < GetToWork::Command
+      KEYCHAIN_SERVICE = "GetToWork::PivotalTracker".freeze
+
+      def run(opts = {})
+        check_for_config_file
+
+        pt = GetToWork::Service::PivotalTracker.new
+
+        @cli.say "\n\nStep #1 #{pt.display_name} Setup", :magenta
+        @cli.say "-----------------------------", :magenta
+
+        if pt.keychain
+          pt.authenticate_with_keychain
+        else
+          username, password = prompt_for_login(pt)
+          auth_with_service(service: pt, username: username, password: password)
+        end
+
+        project = prompt_select_project(pt)
+        pt.save_config("project_id" => project.id)
+
+        GetToWork::ConfigFile.save
+
+
+        @cli.say "\n\nStep #2 #{harvest_service.display_name} Setup", :magenta
+        @cli.say "-----------------------------", :magenta
+
+        unless harvest_service.authenticate_with_keychain
+          subdomain, username, password = prompt_for_subdomain_and_login(harvest_service)
+          auth_with_service(
+            service: harvest_service,
+            username: username,
+            password: password,
+            subdomain: subdomain
+          )
+        end
+
+        harvest_project = prompt_select_project(harvest_service)
+        harvest_task = prompt_select_tasks(harvest_service, harvest_project)
+
+        harvest_service.save_config(
+          "project_id" => harvest_project.id,
+          "task_id" => harvest_task["id"],
+          "subdomain" => harvest_service.subdomain
+        )
+
+        GetToWork::ConfigFile.save
+      end
+
+      def check_for_config_file
+        @config_file = GetToWork::ConfigFile.instance
+
+        if @config_file
+          unless @cli.yes?("Would you like to overwrite your existing #{GetToWork::ConfigFile.filename} file? [y/N]", :green)
+            exit(0)
+          end
+        end
+      end
+
+      def prompt_for_login(service)
+        username = @cli.ask "#{service.display_name} Username:", :green
+        password = @cli.ask "#{service.display_name} Password:", :green, echo: false
+
+        [username, password]
+      end
+
+      def prompt_for_subdomain_and_login(service)
+        subdomain = @cli.ask "#{service.display_name} Subdomain:", :green
+        username, password = prompt_for_login(service)
+
+        [subdomain, username, password]
+      end
+
+      def auth_with_service(service:, username:, password:, subdomain: nil)
+        @cli.say "\n\nAuthenticating with #{service.display_name}...", :magenta
+
+        begin
+          service.authenticate(username: username, password: password, subdomain: subdomain)
+        rescue RestClient::Unauthorized
+          @cli.say "Could not authenticate with #{service.display_name}", :red
+          exit(1)
+        end
+
+        service.update_keychain(account: username)
+      end
+
+      def prompt_select_project(service)
+        project_options = GetToWork::MenuPresenter.with_collection(service.projects)
+
+        @cli.menu_ask(
+          "\nSelect a #{service.display_name} project:",
+          project_options,
+          :green,
+          limited_to: project_options.menu_limit
+        )
+      end
+
+      def prompt_select_tasks(service, project)
+        project_options = GetToWork::MenuPresenter.with_collection(project["tasks"])
+
+        selected_project = @cli.menu_ask(
+          "\nSelect a #{service.display_name} Task:",
+          project_options,
+          :green,
+          limited_to: project_options.menu_limit
+        )
+      end
+    end
+  end
+end

data/lib/get_to_work/command/start.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module GetToWork
+  class Command
+    class Start < GetToWork::Command
+      def initialize(opts = {})
+        super(opts)
+        @pt_id = parse_pt_id(opts[:pt_id])
+      end
+
+      def run
+
+        if @pt_id.nil?
+          prompt_to_use_last_story
+        end
+
+        pt = GetToWork::Service::PivotalTracker.new(config_file.data)
+        story = pt.story(@pt_id)
+
+        entry = {
+          notes: "##{story.id}\n\n#{story.name}\n#{story.url}",
+          project_id: harvest_service.project_id,
+          task_id: harvest_service.task_id,
+        }
+
+        timer = harvest_service.start_timer(entry)
+        save_last_timer(timer)
+        save_last_story(story)
+      end
+
+      def prompt_to_use_last_story
+        last_story = config_file["last_story"]
+
+        if last_story
+          @cli.say "\nWould you like to start a timer for your last story?", :green
+          @cli.say "  ##{last_story[:id.to_s]} ", [:bold, :cyan]
+          @cli.say "#{last_story[:name.to_s]}", :magenta
+          answer = @cli.yes? "\n[y/N]", :green
+
+          if answer
+            @pt_id = last_story["id"]
+          else
+            exit(0)
+          end
+        else
+          @cli.say "Couldn't find your last started timer. Please specify a story id."
+          exit(0)
+        end
+      end
+
+      def parse_pt_id(pt_id)
+        return nil if pt_id.nil?
+
+        pt_id.delete("#")
+        pt_id.match(/\d+$/)[0]
+      end
+
+      def save_last_story(story)
+        config_file[:last_story.to_s] = {
+          "id" => story.id,
+          "name" => story.name
+        }
+
+        config_file.save
+      end
+
+      def save_last_timer(timer)
+        config_file[:last_timer.to_s] = timer.id
+        config_file.save
+      end
+    end
+  end
+end

data/lib/get_to_work/command/stop.rb

@@ -0,0 +1,19 @@
+module GetToWork
+  class Command
+    class Stop < GetToWork::Command
+      def run
+        if last_timer
+          @cli.say "\nStopping your current timer...\n\n", :green
+          result = harvest_service.stop_timer(last_timer)
+
+          if result["id"]
+            config_file.data.delete("last_timer")
+            config_file.save
+          end
+        else
+          @cli.say "\nYour timer has already been stopped.\n\n", :red
+        end
+      end
+    end
+  end
+end

data/lib/get_to_work/config_file.rb

@@ -0,0 +1,49 @@
+require "yaml"
+require "singleton"
+
+module GetToWork
+  class ConfigFile
+    attr_reader :data
+    include Singleton
+
+    def initialize
+      setup_data(self.class.path)
+    end
+
+    def setup_data(path)
+      @data = begin
+                YAML.load_file(path)
+              rescue Errno::ENOENT
+                {}
+              end
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def self.save
+      instance.save
+    end
+
+    def save
+      File.open(self.class.path, "w") { |f| f.write YAML.dump(@data) }
+    end
+
+    def self.exist?
+      File.exist? path
+    end
+
+    def self.path
+      File.join(Dir.pwd, filename)
+    end
+
+    def self.filename
+      ".get-to-work"
+    end
+  end
+end

data/lib/get_to_work/keychain.rb

@@ -0,0 +1,46 @@
+module GetToWork
+  KEYCHAIN_PREFIX = "GetToWork".freeze
+
+  class Keychain
+    def update(opts = {})
+      relative_service_name = opts[:service]
+      @absolute_service_name =
+        self.class.absolute_service_name(relative_service_name)
+
+      update_or_create_keychain_item(opts)
+    end
+
+    def self.find(service:)
+      ::Keychain.generic_passwords.where(
+        service: absolute_service_name(service)
+      ).all
+    end
+
+    def self.absolute_service_name(relative_name)
+      "#{KEYCHAIN_PREFIX}::#{relative_name}"
+    end
+
+    private
+
+    def update_or_create_keychain_item(opts = {})
+      keychain_items = self.class.find(service: opts[:service])
+      ::Keychain.generic_passwords.where(
+        service: @absolute_service_name
+      )
+
+      if item = keychain_items.first
+        item.account = opts[:account]
+        item.password = opts[:password]
+      else
+        create_keychain_item(opts)
+      end
+    end
+
+    def create_keychain_item(opts = {})
+      relative_service_name = opts[:service]
+      opts[:service] = self.class.absolute_service_name(relative_service_name)
+
+      ::Keychain.generic_passwords.create(opts)
+    end
+  end
+end

data/lib/get_to_work/menu.rb

@@ -0,0 +1,9 @@
+module GetToWork
+  module Menu
+    def menu_ask(statement, options, *args)
+      print_table(options.table) # Assuming MenuPresenter type
+      choice = ask(statement, *args)
+      options.item_for(choice: choice)
+    end
+  end
+end

data/lib/get_to_work/menu_presenter.rb

@@ -0,0 +1,26 @@
+module GetToWork
+  class MenuPresenter
+    def self.with_collection(options)
+      new(options)
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def table
+      @options.map.with_index do |option, i|
+        [i + 1, option.name]
+      end
+    end
+
+    def item_for(choice:)
+      index = choice.to_i - 1
+      @options[index]
+    end
+
+    def menu_limit
+      (1..@options.count).map(&:to_s)
+    end
+  end
+end

data/lib/get_to_work/service.rb

@@ -0,0 +1,64 @@
+module GetToWork
+  class Service
+    attr_reader :api_token
+
+    class << self
+      attr_accessor :yaml_key, :name, :display_name
+    end
+
+    def yaml_key
+      self.class.yaml_key
+    end
+
+    def name
+      self.class.name
+    end
+
+    def display_name
+      self.class.display_name
+    end
+
+    def initialize(data_hash = nil)
+      return if data_hash.nil?
+
+      @data = data_hash[yaml_key]
+      if @data
+        @data.each { |name, value| instance_variable_set("@#{name}", value) }
+        authenticate_with_keychain
+      end
+    end
+
+    def update_keychain(account:)
+      raise "@api_token not set for #{name}" if @api_token.nil?
+      raise "@name not set for #{name}" if @api_token.nil?
+
+      GetToWork::Keychain.new.update(
+        service: self.class.name,
+        account: account,
+        password: @api_token
+      )
+    end
+
+    def api_token
+      if keychain && @api_token.nil?
+        @api_token = keychain.password
+        set_client_token(@api_token)
+      end
+
+      @api_token
+    end
+
+    def set_client_token(token)
+      # noop
+    end
+
+    def keychain
+      @keychain ||= GetToWork::Keychain.find(service: name).last
+    end
+
+    def save_config(opts)
+      config_file = GetToWork::ConfigFile.instance
+      config_file[yaml_key] = opts
+    end
+  end
+end