jirawatch 0.5.0

data/README.md

@@ -0,0 +1,71 @@
+# Jirawatch
+Jirawatch is a simple CLI tool that allows you to track the time you spend on a particular Jira issue without having to access your crowded backlog/kanban.
+Tracking time is as simple as typing:
+```
+jirawatch track ISSUE-873
+```
+After that, jirawatch will start tracking your time and, once you're done, you can press `Ctrl-c` to stop the time tracking and allow jirawatch to save it into the Jira worklogs of the related issue.
+If you need to stop tracking time, just press `Ctrl-p` and then press it again to resume.
+
+## Installation
+
+### Gem
+
+Simply run 
+```
+gem install jirawatch
+```
+And you're good to go!
+
+### With Docker/Podman
+
+You can execute `jirawatch` without installing it on your machine! Jirawatch is available via Docker/Podman too.
+To run it just type:
+```
+docker run apontini/jirawatch
+```
+and you're good to go!
+
+If you feel like doing everything by yourself it can be built from the repository with:
+```
+docker build -t <your username>/jirawatch
+docker run <your username>/jirawatch # enjoy the magic
+```
+
+Keep in mind that you need to setup persistence in order to store Jirawatch's configuration files. You can put in your `.bashrc` or `.zshrc` the following alias:
+```
+alias jirawatch="docker run --rm -it -v${HOME}/.jirawatch:/root/.jirawatch -v/etc/localtime:/etc/localtime:ro apontini/jirawatch"
+```
+This will ensure persistence and will not modify your machine with additional packages ;)
+
+### Manually
+
+There's no install script right now unfortunately (it will be coming though!).
+For the time being, you need to install Ruby (2.7.0 was used do develop this gem but it should work from 2.1.0 onwards) using [rbenv](https://github.com/rbenv/rbenv).
+
+As a side note, I highly discourage installing Ruby without rbenv and installing rbenv from a package manager (reason is that rbenv packages are severely outdated most of the time), unless you know what you're doing of course!
+
+After that, clone this repository and build this gem using:
+```
+gem build jirawatch.gemspec
+```
+and install it with:
+```
+gem install jirawatch-<gem-version>.gem
+```
+
+You should now be good to go!
+
+## How to use
+As I stated before, this is not a complex tool! There are a few commands implemented as of right now:
+```
+jirawatch version               # Prints the current jirawatch version
+jirawatch login                 # Allows to log you in to Jira then saves your credentials if the operation succeeded
+jirawatch projects              # Lists all Jira projects
+jirawatch issues [project-key]  # Lists every issue related to a project
+jirawatch track [issue-key]     # Starts tracking time for an issue
+```
+
+You need to register your Jira credentials first, before you can start tracking. Be sure to have a valid API Token for your account (which you can generate at https://id.atlassian.com/manage/api-tokens).
+Then use the `login` command and follow the prompt instructions.
+If everything is successful, you're good to go!

data/bin/jirawatch

@@ -0,0 +1,23 @@
+#!/usr/bin/env -S ruby -W0
+require 'bundler/setup'
+require 'dry/cli'
+Dir["#{__dir__}/../lib/jirawatch/**/*.rb"].sort.map { |file| File.expand_path(file) }.each do |file|
+  require file
+end
+require 'jirawatch'
+
+include Jirawatch::Utils::Messages
+
+begin
+  Dry::CLI.new(Jirawatch).call
+rescue Jirawatch::Errors::CommandFailed => e
+  puts e.message
+  exit -1
+rescue JIRA::HTTPError => e
+  puts e.response.body
+  exit -1
+rescue StandardError => e
+  puts e.backtrace
+  puts e.message
+  exit -1
+end

data/jirawatch.gemspec

@@ -0,0 +1,19 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jirawatch/info'
+
+Gem::Specification.new do |s|
+  s.name        = 'jirawatch'
+  s.version     = Jirawatch::Info::VERSION
+  s.date        = '2020-02-27'
+  s.summary     = "Jira time tracker"
+  s.description = "A simple way to track jira issues time"
+  s.authors     = ["apontini"]
+  s.email       = 'alberto.pontini@gmail.com'
+  s.files       = `git ls-files`.split($/)
+  s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+
+  s.add_dependency "dry-cli"
+  s.add_dependency "jira-ruby"
+  s.add_dependency "tty-editor"
+end

data/lib/jirawatch.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+module Jirawatch
+  extend Dry::CLI::Registry
+  include Jirawatch::Jira::Provisioning
+
+  attr_accessor :configuration
+  attr_accessor :strings
+
+  class << self
+    def configuration
+      @configuration || Jirawatch::Config.new
+    end
+
+    def configure
+      @configuration ||= Jirawatch::Config.new
+      yield @configuration
+    end
+
+    def strings
+      @strings || Jirawatch::Strings.new
+    end
+  end
+
+  unless Dir.exist? configuration.config_path
+    puts "Creating jirawatch config directory at #{configuration.config_path}"
+    FileUtils.mkdir_p configuration.config_path
+  end
+end
+
+Jirawatch.register "version", Jirawatch::CLI::Version
+Jirawatch.register "track", Jirawatch::CLI::Track
+Jirawatch.register "login", Jirawatch::CLI::Login
+Jirawatch.register "projects", Jirawatch::CLI::Projects
+Jirawatch.register "issues", Jirawatch::CLI::Issues

data/lib/jirawatch/cli/authenticated_command.rb

@@ -0,0 +1,31 @@
+require 'jirawatch/jira/provisioning'
+
+module Jirawatch
+  module CLI
+    module AuthenticatedCommand
+      include Jirawatch::Jira::Provisioning
+
+      def self.included(base)
+
+        def base.method_added(name)
+          if name.eql? :call and not method_defined? :alias_call
+            alias_method :alias_call, :call
+
+            define_method(:call) do |**args, &block|
+              @jira_client = login
+
+              fail! Jirawatch.strings.error_login_info_not_found if @jira_client.nil?
+
+              puts "Connected to #{@jira_client.ServerInfo.all.attrs["baseUrl"]}\n\n"
+              send :alias_call, **args
+
+            end
+
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/jirawatch/cli/issues.rb

@@ -0,0 +1,16 @@
+module Jirawatch
+  module CLI
+    class Issues < Dry::CLI::Command
+      include Jirawatch::CLI::AuthenticatedCommand
+
+      argument :project, required: true, desc: "Id or key of the project which issues have to be listed"
+
+      def call(project: nil, **options)
+        puts "Id\t\tKey\t\tType\t\tSummary\n\n"
+        @jira_client.Project.find(project).issues.each do |issue|
+          puts "#{issue.id}\t\t#{issue.key}\t\t#{issue.fields['issuetype']['name']}\t\t#{issue.fields['summary']}"
+        end
+      end
+    end
+  end
+end

data/lib/jirawatch/cli/login.rb

@@ -0,0 +1,27 @@
+require 'jirawatch/jira/provisioning'
+
+module Jirawatch
+  module CLI
+    class Login < Dry::CLI::Command
+      include Jirawatch::Jira::Provisioning
+
+      def call(*)
+        puts "Enter your Jira URL (eg. https://veryimportantcompany.atlassian.net)"
+        site = STDIN.gets.chomp
+        puts "Enter your jira email/username: "
+        name = STDIN.gets.chomp
+        puts "Enter your API auth token: "
+        token = STDIN.gets.chomp
+
+        unless login name, token, site
+          puts "Login failed, no credentials have been saved"
+          return
+        end
+
+        save_credentials name, token, site
+        puts "Login successful, credentials have been saved"
+      end
+    end
+  end
+end
+

data/lib/jirawatch/cli/projects.rb

@@ -0,0 +1,15 @@
+module Jirawatch
+  module CLI
+    class Projects < Dry::CLI::Command
+      include Jirawatch::CLI::AuthenticatedCommand
+
+      def call(*)
+        puts "Id\tKey\tName\n\n"
+        @jira_client.Project.all.each do |project|
+          puts "#{project.id}\t#{project.key}\t#{project.name}"
+        end
+      end
+
+    end
+  end
+end

data/lib/jirawatch/cli/track.rb

@@ -0,0 +1,62 @@
+require 'tty-editor'
+
+module Jirawatch
+  module CLI
+    class Track < Dry::CLI::Command
+      include Jirawatch::CLI::AuthenticatedCommand
+
+      argument :issue_key, required: true, desc: "Issue key that you want to track time for"
+      option :tracking_started_at, aliases: ["-t"], desc: "Specify when you started working on this issue with a HH:mm format"
+      option :worklog_message, aliases: ["-m"], desc: "Specify a work log message"
+
+      def initialize(
+          reader: TTY::Reader.new,
+          worklogger: Jirawatch::Interactors::Worklogger.new
+      )
+        @reader = reader
+        @worklogger = worklogger
+      end
+
+      def call(issue_key:, **options)
+        tracking_started_at = Time.parse(options.fetch(:tracking_started_at, Time.now.to_s))
+        fail! Jirawatch.strings.error_invalid_tracking_start if tracking_started_at > Time.now
+
+        issue = @jira_client.Issue.find(issue_key) # Fails if issue doesn't exist
+
+        paused = false
+        tracking_restarted_at = tracking_started_at.to_i
+        partial_time_spent = 0
+
+        worked_hours = (issue.attrs["fields"]["timetracking"]["timeSpentSeconds"]/60)/60
+        worked_minutes = (issue.attrs["fields"]["timetracking"]["timeSpentSeconds"]/60)%60
+        estimate_hours = (issue.attrs["fields"]["timetracking"]["originalEstimateSeconds"]/60)/60
+        estimate_minutes = (issue.attrs["fields"]["timetracking"]["originalEstimateSeconds"]/60)%60
+        puts Jirawatch.strings.tracking_cli_name % [issue_key, issue.attrs["fields"]["summary"]]
+        puts Jirawatch.strings.tracking_cli_time % [tracking_started_at.strftime("%Y-%m-%d %H:%M:%S"), worked_hours, worked_minutes, estimate_hours, estimate_minutes]
+        puts Jirawatch.strings.tracking_cli_inputs
+
+        @reader.on(:keyctrl_p) do
+          unless paused
+            partial_time_spent += Time.now.to_i - tracking_restarted_at
+            time_unit = partial_time_spent / 60 == 1 ? "minute" : "minutes"
+            puts Jirawatch.strings.tracking_paused % [partial_time_spent / 60, time_unit]
+          else
+            tracking_restarted_at = Time.now.to_i
+            puts Jirawatch.strings.tracking_restarted
+          end
+          paused = !paused
+        end
+
+        begin
+          loop do
+            @reader.read_line("")
+          end
+        rescue Interrupt
+          total_time_spent = partial_time_spent + (Time.now.to_i - tracking_restarted_at) unless paused
+          total_time_spent = partial_time_spent if paused
+          @worklogger.call @jira_client, issue_key, total_time_spent, tracking_started_at, default_message: options.fetch(:worklog_message, "")
+        end
+      end
+    end
+  end
+end

data/lib/jirawatch/cli/version.rb

@@ -0,0 +1,12 @@
+require "dry/cli"
+require 'jirawatch/info'
+
+module Jirawatch
+  module CLI
+    class Version < Dry::CLI::Command
+      def call(*)
+        puts Jirawatch::Info::VERSION
+      end
+    end
+  end
+end

data/lib/jirawatch/config.rb

@@ -0,0 +1,15 @@
+module Jirawatch
+  class Config
+
+    attr_accessor :template_worklog_file
+    attr_accessor :config_path
+    attr_accessor :login_file
+    attr_accessor :tracking_file_content
+
+    def initialize
+      @template_worklog_file = "/tmp/jirawatch-%s"
+      @config_path = File.expand_path "~/.jirawatch"
+      @login_file = File.expand_path "~/.jirawatch/access"
+    end
+  end
+end

data/lib/jirawatch/errors/command_failed.rb

@@ -0,0 +1,9 @@
+module Jirawatch
+  module Errors
+    class CommandFailed < StandardError
+      def initialize(msg="Error encountered")
+        super(msg)
+      end
+    end
+  end
+end

data/lib/jirawatch/info.rb

@@ -0,0 +1,5 @@
+module Jirawatch
+  module Info
+    VERSION='0.5.0'.freeze
+  end
+end

data/lib/jirawatch/interactors/worklogger.rb

@@ -0,0 +1,40 @@
+module Jirawatch
+  module Interactors
+    class Worklogger
+      def initialize (editor: TTY::Editor)
+        @editor = editor
+      end
+
+      def call(jira_client, issue_key, total_time_spent, tracking_started_at, default_message: "")
+        # Jira work logs have minute sensitivity thus API calls will fail with a time spent
+        # which is less than 60 seconds
+        fail! Jirawatch.strings.tracking_less_than_60_secs if total_time_spent < 60
+
+        worklog_file = Jirawatch.configuration.template_worklog_file % tracking_started_at.to_i
+        worklog_lines = []
+
+        File.write worklog_file, default_message
+        @editor.open(
+            worklog_file,
+            content: Jirawatch.strings.tracking_file_content % (total_time_spent / 60)
+        ) if default_message.empty?
+
+        File.readlines(Jirawatch.configuration.template_worklog_file % tracking_started_at.to_i).each do |line|
+          worklog_lines << line unless line.start_with?("#") or line.strip.empty?
+        end
+
+        jira_client.Issue.find(issue_key).worklogs.build.save(
+            {
+                timeSpentSeconds: total_time_spent,
+                started: tracking_started_at.strftime("%Y-%m-%dT%H:%M:%S.%L%z"),
+                comment: worklog_lines.join("\n")
+            }
+        ) unless worklog_lines.empty?
+
+        puts Jirawatch.strings.error_empty_worklog if worklog_lines.empty?
+
+        File.delete worklog_file
+      end
+    end
+  end
+end

data/lib/jirawatch/jira/provisioning.rb

@@ -0,0 +1,47 @@
+require 'jira-ruby'
+
+module Jirawatch
+  module Jira
+    module Provisioning
+
+      def login(username = nil, token = nil, site = nil)
+        if username.nil? or token.nil? or site.nil?
+
+          return nil unless File.exist? Jirawatch.configuration.login_file
+
+          File.open(Jirawatch.configuration.login_file).each_line do |line|
+            binding.local_variable_set line.split(' ')[0], line.split(' ')[1]
+          end
+
+        end
+
+        options = {
+            username: username,
+            password: token,
+            site: site,
+            context_path: '',
+            auth_type: :basic,
+            read_timeout: 120
+        }
+
+        client = JIRA::Client.new(options)
+        begin
+          # Get some infos to check if login was successful
+          client.ServerInfo.all.attrs["baseUrl"]
+          return client
+        rescue StandardError => e
+          puts e.message
+        end
+
+        nil
+      end
+
+      def save_credentials(username, token, site)
+        File.open(Jirawatch.configuration.login_file, "w") do |f|
+          f.write ["username #{username}", "token #{token}", "site #{site}"].join "\n"
+        end
+        File.chmod 0600, Jirawatch.configuration.login_file
+      end
+    end
+  end
+end