durt 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a79549849f47d7161682e6dfc419395c07b1a85acb64e3fb1960564c444a1625
+  data.tar.gz: 349b33a912f66978bd7f9d92d0ac90d40f9747a0f5f24ef636d0897886f944c3
+SHA512:
+  metadata.gz: 9e5facc089af1213b1b6ee26344e1e8a766d827c261294281de3004f01c84be1ac79f4adb599ecfeda7c53cd70698767ec89dc0a947f583ba8d6743a2c87ae9e
+  data.tar.gz: e9afa291bf22c73a703326f6312144719300001092bcbc8125885dfe1acaee92b491609306a4ad0350cd9e312abab039a1e62d6a9b3a03fa03b8a2a70594dd30

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Luis Felipe Sanchez (durt.github.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# Durt
+
+Small Ruby program generated using https://github.com/snada/generator-ruby-cmd
+
+## Install
+
+This is a Ruby program and uses Bundler to ensure dependencies consistency. On your machine navigate to the project root and run:
+
+```bash
+# If not already installed:
+gem install bundler
+
+bundle install
+```
+
+This code is packaged as a Ruby gem, and it should be built and installed running these commands:
+
+```bash
+gem build durt.gemspec
+gem install durt
+```
+
+## Setup
+
+First, you will want to initialize your issues database.
+
+```
+durt init
+```
+
+
+Make sure Upwork client (or pick time tracker) is running and in the correct
+project.
+
+Then, create `.durt.yml` at your root folder. Example for Jira project:
+
+```
+# ~/.durt.yml
+
+---
+Jira:
+  :username: username@example.com
+  :password: yourpassword
+  :site: http://yourproject.atlassian.net:443/
+  :context_path: ''
+  :auth_type: :basic
+```
+
+## Usage
+
+If you followed the above instruction and the gem is installed on the system, you should have the binary file ready to run from your command line.
+
+Start by choosing the issue statuses that you'll be able to choose from:
+
+```bash
+durt statuses
+```
+
+Next, pick an issue to work on:
+
+```bash
+durt memo
+```
+
+You will be asked to estimate the time it will take you to work on this issue.
+Valid inputs include: `29 minutes`, `3 hours`, `123249 sec` `3 min`, etc.
+As long as it includes a number and something that resembles a time measure it
+will not complain.
+
+If you wish to execute without installing, you can by launching this command from the project root directory:
+
+```bash
+ruby -Ilib bin/durt memo
+```
+
+Other commands include:
+
+```bash
+durt start
+durt stop
+durt stats
+durt stats-all
+durt edit-estimate
+```
+
+## Testing
+
+This code is covered with both unit tests and feature tests, using Rspec (testing library classes) and Cucumber/Aruba (testing the actual command line program).
+
+You can launch the test suite by running:
+
+```bash
+bundle exec rake spec
+bundle exec rake features
+#launch both:
+bundle exec rake
+```
+
+For unit tests, a simple code coverage tool is provided, and you can see the results by opening the generated `coverage` folder.

data/bin/durt

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/durt'
+
+# Read lines from both file or STDIN
+# lines = (ARGV[0] ? IO.readlines(ARGV[0]) : ARGF.readlines).map(&:chomp)
+
+# puts Durt::VERSION
+
+command = ARGV[0]
+# options = ARGV[1..-1]
+
+def current_project
+  Durt::Project.current_project
+end
+
+NULL_COMMAND = Durt::Command::NullCommand
+VERSION_COMMAND = Durt::Command::Version
+BROWSE_DB_COMMAND = Durt::Command::BrowseDb
+CONSOLE_COMMAND = Durt::Command::Console
+SYNC_COMMAND = Durt::Command::SyncIssues
+
+COMMAND_TRANSLATIONS =
+  {
+    '-v' => VERSION_COMMAND,
+    'db' => BROWSE_DB_COMMAND,
+    'sync' => SYNC_COMMAND,
+    'c' => CONSOLE_COMMAND,
+    nil => NULL_COMMAND
+  }.freeze
+
+command_klass =
+  COMMAND_TRANSLATIONS[command] ||
+  "Durt::Command::#{command.underscore.camelize}"
+    .yield_self { |name| Object.const_defined?(name) && name.constantize } ||
+  NULL_COMMAND
+
+begin
+  command_klass.call
+rescue ActiveRecord::StatementInvalid => e
+  raise e unless Durt.env.production?
+
+  puts e.message
+  puts "Database structure is incorrect"
+  puts "You might need to run 'durt init'"
+end

data/db/config.yml

@@ -0,0 +1,22 @@
+default: &default
+  adapter: sqlite3
+  encoding: unicode
+  pool: 5
+  timeout: 5000
+  host: localhost
+
+development:
+  <<: *default
+  database: <%= ENV['HOME'] %>/.durt/db/development.sqlite3
+
+test: &test
+  <<: *default
+  database: <%= ENV['HOME'] %>/.durt/db/test.sqlite3
+
+production:
+  <<: *default
+  database: <%= ENV['HOME'] %>/.durt/db/production.sqlite3
+
+sample:
+  <<: *default
+  database: db/sample.sqlite3

data/lib/durt.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'pry'
+require 'active_support'
+require 'active_support/inflector'
+require 'erb'
+
+ENV['RAILS_ENV'] = ENV.fetch('DURT_ENV', 'production')
+
+require 'active_record'
+
+module Durt
+  def self.env
+    ActiveSupport::StringInquirer.new(ENV['RAILS_ENV'])
+  end
+end
+
+config_file_path = File.expand_path('../db/config.yml', __dir__)
+
+db_config =
+  YAML.load(ERB.new(IO.read(config_file_path)).result)
+
+raise 'Sample db should be blank and remain unused' if Durt.env.sample?
+
+ActiveRecord::Base.establish_connection(db_config[Durt.env])
+
+require_relative 'durt/version'
+require_relative 'durt/configurable'
+require_relative 'durt/project'
+require_relative 'durt/service'
+require_relative 'durt/command'
+
+require_relative 'durt/global_controller'
+require_relative 'durt/project_controller'
+require_relative 'durt/local_plugin'
+require_relative 'durt/notify_plugin'
+require_relative 'durt/upwork_plugin'
+require_relative 'durt/github_plugin'
+require_relative 'durt/jira_plugin'
+require_relative 'durt/pivotal_plugin'
+require_relative 'durt/ebs_plugin'
+
+require_relative 'durt/issue'
+require_relative 'durt/session'
+require_relative 'durt/status'
+
+require_relative 'durt/null_time_tracker'
+require_relative 'durt/local_bug_tracker'
+require_relative 'durt/notify_tracker'
+require_relative 'durt/upwork_tracker'
+require_relative 'durt/null_bug_tracker'
+require_relative 'durt/github_bug_tracker'
+require_relative 'durt/jira_bug_tracker'
+require_relative 'durt/pivotal_bug_tracker'
+

data/lib/durt/application_record.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Durt
+  class ApplicationRecord < ::ActiveRecord::Base
+    self.abstract_class = true
+
+    scope :to_choice_h, -> { Hash[map { |r| [r.to_s, r] }] }
+
+    def active!
+      reload.update(active: true)
+    end
+  end
+end

data/lib/durt/bug_tracker.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'jira-ruby'
+
+module Durt
+  class BugTracker
+    attr_reader :project
+
+    def initialize(project, config = nil)
+      @project = project
+      @config = config
+
+      after_initialize
+    end
+
+    def after_initialize; end
+
+    def active?
+      true
+    end
+
+    def fetch_issues
+      raise NotImplementedError
+    end
+
+    def fetch_statuses
+      raise NotImplementedError
+    end
+
+    def source_name
+      self.class.name.split('::').last.sub('BugTracker', '')
+    end
+
+    def issues
+      project.issues.where(source: source_name)
+    end
+
+    def statuses
+      Durt::Status.where(source: source_name)
+    end
+  end
+end

data/lib/durt/command.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Durt
+  module Command
+    class Init < ::Durt::Service
+      def initialize
+        durt_db_dir = File.expand_path('~/.durt/db')
+        db_sample = File.expand_path('../../db/sample.sqlite3', __dir__)
+        copy_dest = File.join(durt_db_dir, 'production.sqlite3')
+        dest_exist = File.exist?(copy_dest)
+
+        FileUtils.mkdir_p(durt_db_dir, verbose: true)
+        FileUtils.cp(db_sample, copy_dest, noop: dest_exist, verbose: true)
+      end
+    end
+
+    class BrowseDb < ::Durt::Service
+      def initialize
+        system("sqlitebrowser #{ActiveRecord::Base.connection_config[:database]}")
+      end
+    end
+
+    class Version < ::Durt::Service
+      def initialize
+        puts Durt::VERSION
+      end
+    end
+
+    class NullCommand < ::Durt::Service
+      def initialize
+        puts 'Unknown command'
+        exit
+      end
+    end
+
+    class Console < ::Durt::Service
+      def initialize
+        controller = Durt::GlobalController.new
+
+        steps << ->(_) { controller.console }
+      end
+    end
+
+    class NewProject < ::Durt::Service
+      def initialize
+        controller = Durt::GlobalController.new
+
+        steps << ->(_) { controller.create_project }
+        steps << ->(project) { controller.create_project_config(project) }
+        steps << ->(project) { controller.select_project(project) }
+        steps << ->(project) { controller.switch_to_project(project) }
+      end
+    end
+
+    class SelectProject < ::Durt::Service
+      def initialize
+        controller = Durt::GlobalController.new
+
+        steps << ->(_) { controller.select_project }
+        steps << ->(project) { controller.switch_to_project(project) }
+      end
+    end
+
+    class Filter < ::Durt::Service
+      def initialize
+        project = Durt::Project.current_project
+        controller = Durt::ProjectController.new(project)
+
+        steps << ->(_) { controller.filter }
+      end
+    end
+
+    class Memo < ::Durt::Service
+      def initialize
+        project = Durt::Project.current_project
+        controller = Durt::ProjectController.new(project)
+
+        steps << ->(_) { controller.sync_issues }
+        steps << ->(_) { controller.select_issue }
+        steps << ->(issue) { controller.enter_issue(issue) }
+      end
+    end
+
+    class SelectIssue < ::Durt::Service
+      def initialize
+        project = Durt::Project.current_project
+        controller = Durt::ProjectController.new(project)
+
+        steps << ->(_) { controller.select_issue }
+      end
+    end
+
+    class SyncIssues < ::Durt::Service
+      def initialize
+        project = Durt::Project.current_project
+        controller = Durt::ProjectController.new(project)
+
+        steps << ->(_) { controller.sync_issues }
+      end
+    end
+
+    class NewIssue < ::Durt::Service
+      def initialize
+        project = Durt::Project.current_project
+        controller = Durt::ProjectController.new(project)
+
+        steps << ->(_) { controller.new_issue }
+        steps << ->(issue) { controller.select_issue(issue) }
+        steps << ->(issue) { controller.push_issue(issue) }
+      end
+    end
+
+    class Start < ::Durt::Service
+      def initialize
+        project = Durt::Project.current_project
+        controller = Durt::ProjectController.new(project)
+
+        steps << ->(_) { controller.current_issue }
+        steps << ->(issue) { controller.start_issue(issue) }
+      end
+    end
+
+    class Stop < ::Durt::Service
+      def initialize
+        project = Durt::Project.current_project
+        controller = Durt::ProjectController.new(project)
+
+        steps << ->(_) { controller.current_issue }
+        steps << ->(issue) { controller.stop_issue(issue) }
+      end
+    end
+
+    class Stats < ::Durt::Service
+      def initialize
+        Durt::Project.current_project.active_issue.puts_stats
+      end
+    end
+
+    class ProjectStats < ::Durt::Service
+      def initialize
+        Durt::Project.current_project.puts_stats
+      end
+    end
+  end
+end