abt-cli 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 929ab52c8ebd307b90ddb7daa14f2f63eeeebda8ed9905490a13dcd2f67770da
+  data.tar.gz: e2582299b29e39faa8d4baccaba42954e7140a447d30c3c56a92507ac00f4a09
+SHA512:
+  metadata.gz: dec30158debfe3e97c4969d8724d5f56d04725f0cab1aedf79840bb01ef81d9f17c5245cc538c559e47bfa245f36c5aeed8d02dc6ff21fcbae46b30f79e88c5b
+  data.tar.gz: c74d6a7ae33ff5843385796cf21d764de61d0981501b5ac7e24691a7c61c85ae6f646abacd1f1b74417d29559ae022881969dd71598acf1190487c6b64c0af02

data/bin/abt

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'dry-inflector'
+require 'faraday'
+require 'oj'
+
+require_relative '../lib/abt.rb'
+
+begin
+  Abt::Cli.new(ARGV).perform
+rescue Interrupt
+  abort 'Aborted'
+end

data/lib/abt.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{File.dirname(File.absolute_path(__FILE__))}/abt/*.rb").sort.each do |file|
+  require file
+end

data/lib/abt/asana_client.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Abt
+  class AsanaClient
+    API_ENDPOINT = 'https://app.asana.com/api/1.0'
+    VERBS = %i[get post patch].freeze
+
+    attr_reader :access_token
+
+    def initialize(access_token:)
+      @access_token = access_token
+    end
+
+    VERBS.each do |verb|
+      define_method(verb) do |*args|
+        request(verb, *args)['data']
+      end
+    end
+
+    def get_paged(path, query = {})
+      records = []
+
+      loop do
+        result = request(:get, path, query.merge(limit: 100))
+        records += result['data']
+        break if result['next_page'].nil?
+
+        path = result['next_page']['path'][1..-1]
+      end
+
+      records
+    end
+
+    def request(*args)
+      response = connection.public_send(*args)
+
+      if response.success?
+        Oj.load(response.body)
+      else
+        error_class = Abt::HttpError.error_class_for_status(response.status)
+        encoded_response_body = response.body.force_encoding('utf-8')
+        raise error_class, "Code: #{response.status}, body: #{encoded_response_body}"
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new(API_ENDPOINT) do |connection|
+        connection.headers['Authorization'] = "Bearer #{access_token}"
+        connection.headers['Content-Type'] = 'application/json'
+      end
+    end
+  end
+end

data/lib/abt/cli.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+Dir.glob("#{File.expand_path(__dir__)}/cli/*.rb").sort.each do |file|
+  require file
+end
+
+module Abt
+  class Cli
+    include Dialogs
+
+    attr_reader :command, :args
+
+    def initialize(argv)
+      (@command, *@args) = argv
+
+      @args += args_from_stdin unless STDIN.isatty # Add piped arguments
+    end
+
+    def perform(command: @command, args: @args)
+      handle_global_commands!
+
+      abort('No provider arguments') if args.empty?
+
+      process_providers(command: command, args: args)
+    end
+
+    def print_provider_command(provider, arg_str, description)
+      puts "#{provider}:#{arg_str} # #{description}"
+    end
+
+    private
+
+    def handle_global_commands! # rubocop:disable Metrics/MethodLength
+      case command
+      when nil
+        warn("No command specified\n\n")
+        puts(Abt::Help::Cli.content)
+        exit
+      when '--help', '-h', 'help', 'commands'
+        puts(Abt::Help::Cli.content)
+        exit
+      when 'help-md'
+        puts(Abt::Help::Markdown.content)
+        exit
+      when '--version', '-v', 'version'
+        puts(Abt::VERSION)
+        exit
+      end
+    end
+
+    def args_from_stdin
+      input = STDIN.read
+
+      return [] if input.nil?
+
+      input.split("\n").map do |line|
+        line.split(' # ').first # Exclude comment part of piped input lines
+      end
+    end
+
+    def process_providers(command:, args:)
+      used_providers = []
+      args.each do |provider_args|
+        (provider, arg_str) = provider_args.split(':')
+
+        if used_providers.include?(provider)
+          warn "Dropping command for already used provider: #{provider_args}"
+          next
+        end
+
+        used_providers << provider if process_provider_command(provider, command, arg_str)
+      end
+
+      warn 'No matching providers found for command' if used_providers.empty?
+    end
+
+    def process_provider_command(provider, command, arg_str)
+      command_class = class_for_provider_and_command(provider, command)
+
+      return false unless command_class
+
+      if STDOUT.isatty
+        warn "===== #{command} #{provider}#{arg_str.nil? ? '' : ":#{arg_str}"} =====".upcase
+      end
+
+      command_class.new(arg_str: arg_str, cli: self).call
+      true
+    end
+
+    def class_for_provider_and_command(provider, command)
+      inflector = Dry::Inflector.new
+      provider_class_name = inflector.camelize(inflector.underscore(provider))
+
+      return unless Abt::Providers.const_defined? provider_class_name
+
+      provider_class = Abt::Providers.const_get provider_class_name
+      command_class_name = inflector.camelize(inflector.underscore(command))
+      return unless provider_class.const_defined? command_class_name
+
+      provider_class.const_get command_class_name
+    end
+  end
+end

data/lib/abt/cli/dialogs.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    module Dialogs
+      def prompt(question)
+        STDERR.print "#{question}: "
+        read_user_input.strip
+      end
+
+      def prompt_choice(text, options, allow_back_option = false)
+        if options.one?
+          warn "Selected: #{options.first['name']}"
+          return options.first
+        end
+
+        warn "#{text}:"
+
+        print_options(options)
+        select_options(options, allow_back_option)
+      end
+
+      private
+
+      def print_options(options)
+        options.each_with_index do |option, index|
+          warn "(#{index + 1}) #{option['name']}"
+        end
+      end
+
+      def select_options(options, allow_back_option)
+        while (number = read_option_number(options.length, allow_back_option))
+          if number.nil?
+            return nil if allow_back_option
+
+            abort
+          end
+
+          option = options[number - 1]
+
+          warn "Selected: (#{number}) #{option['name']}"
+          return option
+        end
+      end
+
+      def read_option_number(options_length, allow_back_option)
+        STDERR.print "(1-#{options_length}#{allow_back_option ? ', q: back' : ''}): "
+
+        input = read_user_input
+
+        return nil if allow_back_option && input == 'q'
+
+        option_number = input.to_i
+        if option_number <= 0 || option_number > options_length
+          warn 'Invalid selection'
+          return nil
+        end
+
+        option_number
+      end
+
+      def read_user_input
+        open('/dev/tty', &:gets).strip
+      end
+    end
+  end
+end

data/lib/abt/git_config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Abt
+  class GitConfig
+    class << self
+      def local(*args)
+        git_config(true, *args)
+      end
+
+      def global(*args)
+        git_config(false, *args)
+      end
+
+      def prompt_local(*args)
+        prompt_for_config(true, *args)
+      end
+
+      def prompt_global(*args)
+        prompt_for_config(false, *args)
+      end
+
+      def unset_local(key)
+        unset(true, key)
+      end
+
+      def unset_global(key)
+        unset(false, key)
+      end
+
+      private
+
+      def unset(local, key)
+        `git config --#{local ? 'local' : 'global'} --unset #{key.inspect}`
+      end
+
+      def git_config(local, key, value = nil)
+        if value
+          `git config --#{local ? 'local' : 'global'} --replace-all #{key.inspect} #{value.inspect}`
+          value
+        else
+          git_value = `git config --get #{key.inspect}`.strip
+          git_value.empty? ? nil : git_value
+        end
+      end
+
+      def prompt(msg)
+        STDERR.print "#{msg} > "
+        value = read_user_input.strip
+        warn
+        value
+      end
+
+      def prompt_for_config(local, key, prompt_msg, remedy = '') # rubocop:disable Metrics/MethodLength
+        value = git_config(local, key)
+
+        return value unless value == '' || value.nil?
+
+        warn <<~TXT
+          Missing git config "#{key}":
+          To find this value:
+          #{remedy}
+        TXT
+
+        new_value = prompt(prompt_msg)
+
+        if new_value.empty?
+          abort 'Empty value, aborting'
+        else
+          git_config(local, key, new_value)
+        end
+      end
+
+      def read_user_input
+        open('/dev/tty', &:gets)
+      end
+    end
+  end
+end

data/lib/abt/harvest_client.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Abt
+  class HarvestClient
+    API_ENDPOINT = 'https://api.harvestapp.com/v2'
+    VERBS = %i[get post patch].freeze
+
+    attr_reader :access_token, :account_id
+
+    def initialize(access_token:, account_id:)
+      @access_token = access_token
+      @account_id = account_id
+    end
+
+    VERBS.each do |verb|
+      define_method(verb) do |*args|
+        request(verb, *args)
+      end
+    end
+
+    def get_paged(path, query = {})
+      result_key = path.split('?').first.split('/').last
+
+      page = 1
+      records = []
+
+      loop do
+        result = get(path, query.merge(page: page))
+        records += result[result_key]
+        break if result['total_pages'] == page
+
+        page += 1
+      end
+
+      records
+    end
+
+    def request(*args)
+      response = connection.public_send(*args)
+
+      if response.success?
+        Oj.load(response.body)
+      else
+        error_class = Abt::HttpError.error_class_for_status(response.status)
+        encoded_response_body = response.body.force_encoding('utf-8')
+        raise error_class, "Code: #{response.status}, body: #{encoded_response_body}"
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new(API_ENDPOINT) do |connection|
+        connection.headers['Authorization'] = "Bearer #{access_token}"
+        connection.headers['Harvest-Account-Id'] = account_id
+        connection.headers['Content-Type'] = 'application/json'
+      end
+    end
+  end
+end

data/lib/abt/help.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+Dir.glob("#{File.expand_path(__dir__)}/help/*.rb").sort.each do |file|
+  require file
+end
+
+module Abt
+  module Help
+    class << self
+      def examples # rubocop:disable Metrics/MethodLength
+        {
+          'Multiple providers and arguments can be passed, e.g.:' => {
+            'abt init asana harvest' => nil,
+            'abt pick-task asana harvest' => nil,
+            'abt start asana harvest' => nil,
+            'abt clear asana harvest' => nil
+          },
+          'Command output can be piped, e.g.:' => {
+            'abt tasks asana | grep -i <name of task>' => nil,
+            'abt tasks asana | grep -i <name of task> | abt start' => nil
+          }
+        }
+      end
+
+      def providers
+        provider_definitions
+      end
+
+      private
+
+      def commandize(string)
+        string = string.to_s
+        string[0] = string[0].downcase
+        string.gsub(/([A-Z])/, '-\1').downcase
+      end
+
+      def provider_definitions
+        Abt::Providers.constants.sort.each_with_object({}) do |provider_name, definition|
+          provider_class = Abt::Providers.const_get(provider_name)
+
+          definition[commandize(provider_name)] = command_definitions(provider_class)
+        end
+      end
+
+      def command_definitions(provider_class)
+        provider_class.constants.sort.each_with_object({}) do |command_name, definition|
+          command_class = provider_class.const_get(command_name)
+
+          if command_class.respond_to?(:command) && command_class.respond_to?(:description)
+            definition[command_class.command] = command_class.description
+          end
+        end
+      end
+    end
+  end
+end