ptimelog 0.9.0 → 0.12.0

data/lib/ptimelog/command/info.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Ptimelog
+  module Command
+    # Extract and show entries from a Obsidian+DayPlanner list
+    class Info < CmdParse::Command
+      def initialize
+        super('info', takes_commands: false)
+        @configuration = Ptimelog::Configuration.instance
+      end
+
+      def execute
+        puts <<~TXT
+          Configuration
+          -------------
+          base_url:  #{@configuration['base_url']}
+          rounding:  #{@configuration['rounding']}
+          dir:       #{@configuration['dir']}
+
+          #{obsidian_config}#{timelog_config}
+        TXT
+      end
+
+      def obsidian_config
+        return nil unless @configuration['obsidian']
+
+        <<~TXT
+          Datasource: Obsidian (Operon)
+          -----------------------------
+          vault:     #{@configuration['obsidian_vault']}
+          custom keys:
+            ticket:  #{Ptimelog::Operon.custom_keys['ticket']}
+            inferer: #{Ptimelog::Operon.custom_keys['inferer']}
+        TXT
+      end
+
+      def timelog_config
+        return nil unless @configuration['timelog']
+
+        <<~TXT
+          Datasource: Timelog
+          -------------------
+          file:      #{@configuration['timelog_txt']}
+        TXT
+      end
+    end
+  end
+end

data/lib/ptimelog/command/show.rb

@@ -3,45 +3,65 @@
 module Ptimelog
   module Command
     # show entries of one day or all of them
-    class Show < Base
-      def initialize(*args)
-        @durations = Hash.new(0)
+    class Show < CmdParse::Command
+      attr_reader :entries
 
-        super
-      end
+      def initialize
+        super('show', takes_commands: false)
+        @debug = false
+        @durations = false
+        @entries = {}
+        @config = Configuration.instance
 
-      def needs_entries?
-        true
+        options.on('-d', '--durations', 'Summarize durations by ticket') { @durations = true }
+        options.on('--debug', 'Show debugging output') { @debug = true }
       end
 
-      def run
+      def execute(maybe_named_day) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+        debug("Requested Day: #{maybe_named_day}")
+        @day = Ptimelog::NamedDate.new.named_date(maybe_named_day)
+        debug("Resolved Day: #{@day}")
+        data_source = Ptimelog::DataSource.new(@config, @day)
+        debug("Data Source: #{data_source.backend}")
+        @entries = data_source.entries
+        debug("Found Entries: #{@entries.values.sum(&:size)}")
+
         @entries.each do |date, list|
-          puts date,
-               '----------'
-          list.each do |entry|
-            puts entry
-          end
-          puts '----------',
-               "Total work done: #{duration(date)} hours",
-               '----------------------------',
-               nil
+          next if list.empty?
+
+          valids = Ptimelog::Joiner.new(compact_on_ticket_only: @durations).join_similar(
+            list.select(&:valid?).sort_by { |entry| entry.ticket.to_s }
+          ).sort_by(&:start_time)
+          total_duration = duration(valids.sum(&:duration))
+
+          output(date, valids, total_duration)
         end
       end
 
-      def entries=(entries)
-        entries.each do |date, list|
-          @entries[date] = []
+      private
 
-          list.each do |entry|
-            @durations[date] += entry.duration
-            @entries[date] << entry.to_s
-          end
+      def output(date, entries, total_duration)
+        puts date,
+             '----------'
+
+        entries.each do |entry|
+          debug(entry.instance_variable_get(:@inferer_cmd))
+          puts entry
         end
+
+        puts '----------',
+             "Total work done: #{total_duration} hours",
+             '----------------------------',
+             nil
       end
 
-      def duration(date)
-        Time.at(@durations[date]).utc.strftime('%H:%M')
+      def debug(msg)
+        return unless @debug
+
+        warn msg
       end
+
+      def duration(durations) = Time.at(durations).utc.strftime('%H:%M')
     end
   end
 end

data/lib/ptimelog/command/upload.rb

@@ -5,24 +5,39 @@ require 'erb'
 module Ptimelog
   module Command
     # Upload entries to puzzletime
-    class Upload < Base
-      attr_writer :entries
+    class Upload < CmdParse::Command
+      def initialize
+        super('upload', takes_commands: false)
 
-      def needs_entries?
-        true
+        @durations = false
+        @entries = {}
+        @config = Configuration.instance
+
+        options.on('-d', '--durations', 'Only upload durations') { @durations = true }
       end
 
-      def run
+      def execute(maybe_named_day)
+        @day = Ptimelog::NamedDate.new.named_date(maybe_named_day)
+        @entries = Ptimelog::DataSource.new(@config, @day).entries
+
         @entries.each do |date, list|
-          puts "Uploading #{date}"
-          list.each do |entry|
-            open_browser(entry)
-          end
+          upload_date(date, list)
         end
       end
 
       private
 
+      def upload_date(date, list)
+        return if list.empty?
+
+        valids = Ptimelog::Joiner.new(compact_on_ticket_only: @durations).join_similar(
+          list.select(&:valid?).sort_by { |entry| entry.ticket.to_s }
+        )
+
+        puts "Uploading #{date}"
+        valids.each { |entry| open_browser(entry) }
+      end
+
       def open_browser(entry)
         xdg_open "'#{@config[:base_url]}/ordertimes/new?#{url_options(entry)}'", silent: true
       end
@@ -47,18 +62,34 @@ module Ptimelog
       end
 
       def url_options(entry)
-        {
-          work_date:                    entry.date,
-          'ordertime[ticket]':          entry.ticket,
-          'ordertime[description]':     entry.description,
-          'ordertime[from_start_time]': entry.start_time,
-          'ordertime[to_end_time]':     entry.finish_time,
-          'ordertime[account_id]':      entry.account,
-          'ordertime[billable]':        entry.billable,
-        }
+        base_params(entry)
+          .merge(duration_params(entry))
           .map { |key, value| [key, ERB::Util.url_encode(value)].join('=') }
           .join('&')
       end
+
+      def base_params(entry)
+        {
+          work_date:                entry.date,
+          'ordertime[ticket]':      entry.ticket,
+          'ordertime[description]': entry.description,
+          'ordertime[account_id]':  entry.account,
+          'ordertime[billable]':    entry.billable,
+        }
+      end
+
+      def duration_params(entry)
+        if @durations
+          {
+            'ordertime[hours]': entry.duration_hours,
+          }
+        else
+          {
+            'ordertime[from_start_time]': entry.start_time,
+            'ordertime[to_end_time]':     entry.finish_time,
+          }
+        end
+      end
     end
   end
 end

data/lib/ptimelog/configuration.rb

@@ -2,6 +2,7 @@
 
 require 'singleton'
 require 'pathname'
+require 'yaml'
 
 module Ptimelog
   # Wrapper around configuration-options and -loading
@@ -9,10 +10,14 @@ module Ptimelog
     include Singleton
 
     CONFIGURATION_DEFAULTS = {
-      base_url: 'https://time.puzzle.ch',
-      rounding: 15,
-      dir:      '~/.config/ptimelog',
-      timelog:  '~/.local/share/gtimelog/timelog.txt',
+      'base_url'           => 'https://time.puzzle.ch',
+      'rounding'           => 15,
+      'dir'                => '~/.config/ptimelog',
+      'timelog'            => true,
+      'timelog_txt'        => '~/.local/share/gtimelog/timelog.txt',
+      'obsidian'           => false,
+      'obsidian_vault'     => '~/path/to/obsidian-vault',
+      'operon_custom_keys' => { 'ticket' => 'ticket', 'inferer' => 'ptimelog' }.freeze,
     }.freeze
 
     def initialize
@@ -21,10 +26,14 @@ module Ptimelog
 
     def reset
       @config = load_config(
-        Pathname.new(CONFIGURATION_DEFAULTS[:dir]).join('config')
+        Pathname.new(CONFIGURATION_DEFAULTS['dir'])
+                .expand_path
+                .join('config')
       )
-      wrap_with_pathname(:dir)
-      wrap_with_pathname(:timelog)
+      wrap_with_pathname('dir')
+
+      wrap_with_pathname('timelog_txt') if self['timelog']
+      wrap_with_pathname('obsidian_vault') if self['obsidian']
     end
 
     def load_config(fn)
@@ -34,19 +43,20 @@ module Ptimelog
     end
 
     def [](key)
-      @config[key.to_sym]
+      @config[key.to_s]
     end
 
     def []=(key, value)
-      @config[key.to_sym] = value
+      @config[key.to_s] = value
 
-      wrap_with_pathname(key.to_sym) if %w[dir timelog].include?(key.to_s)
+      wrap_with_pathname(key.to_s) if %w[dir obsidian_vault timelog_txt].include?(key.to_s)
     end
 
     private
 
     def wrap_with_pathname(key)
       return unless @config.key?(key)
+      return unless @config[key].is_a? String
       return @config[key] if @config[key].is_a? Pathname
 
       @config[key] = Pathname.new(@config[key]).expand_path

data/lib/ptimelog/data_source.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ptimelog
+  # Facade around several datasources, currently intended to cover the
+  # timelog.txt and the tasks of an Obsidian vault
+  class DataSource
+    def initialize(configuration, day)
+      @configuration = configuration
+      @day = day
+    end
+
+    def type
+      if @configuration['timelog']
+        :timelog
+      elsif @configuration['obsidian']
+        :obsidian
+      end
+    end
+
+    def entries
+      case type
+      when :obsidian then { @day => backend.entries }
+      when :timelog then Ptimelog::Day.new(@day).entries
+      else
+        []
+      end
+    end
+
+    def file
+      case type
+      when :obsidian then backend.file
+      when :timelog then backend.timelog_txt
+      end
+    end
+
+    def backend
+      @backend ||= case type
+                   when :obsidian then Operon.new(@day)
+                   when :timelog then Timelog.instance
+                   end
+    end
+  end
+end

data/lib/ptimelog/day.rb

@@ -9,10 +9,11 @@ module Ptimelog
 
     def entries
       timelog.each_with_object({}) do |(date, lines), entries|
-        next unless date                           # guard against the machine
-        next unless @date == :all || @date == date # limit to one day if passed
+        next unless date # guard against the machine
+        next unless @date.to_s == 'all' || @date == date # limit to one day if passed
 
-        entries[date] = join_similar(entries_of_day(lines)) # lines |> entries_of_day |> join_similar"
+        # lines |> entries_of_day |> join_similar
+        entries[date] = join_similar(entries_of_day(lines))
       end
     end
 
@@ -22,6 +23,10 @@ module Ptimelog
       Timelog.load
     end
 
+    def join_similar(list)
+      Ptimelog::Joiner.new.join_similar(list)
+    end
+
     def entries_of_day(lines)
       entries = []
       start = nil # at the start of the day, we have no previous end
@@ -30,42 +35,12 @@ module Ptimelog
         entry = Entry.from_timelog(line)
         entry.start_time = start
 
-        entries << entry if entry.valid?
+        entries << entry if entry.valid? && entry.selected?
 
         start = entry.finish_time # store previous ending for nice display of next entry
       end
 
       entries
     end
-
-    def join_similar(list)
-      return [] if list.empty?
-      return list if list.one?
-
-      one, *tail = list
-      two, *rest = tail
-
-      joined = maybe_join(one, two)
-
-      if joined.one?
-        join_similar(joined + rest)
-      else
-        [one] + join_similar(tail)
-      end
-    end
-
-    def maybe_join(one, two)
-      if one.ticket == two.ticket &&
-         one.description == two.description &&
-         one.finish_time == two.start_time
-
-        joined = one.dup
-        joined.finish_time = two.finish_time
-
-        [joined]
-      else
-        [one, two]
-      end
-    end
   end
 end

data/lib/ptimelog/entry.rb

@@ -4,17 +4,21 @@ require 'time'
 
 module Ptimelog
   # Dataclass to wrap an entry
-  class Entry
-    # allow to read everything
-    attr_reader :date, :start_time, :finish_time, :ticket, :description,
-                :tags, :billable, :account
+  class Entry # rubocop:disable Metrics/ClassLength
+    SEPARATOR = '|'
 
     # define only trivial writers, omit special and derived values
-    attr_writer :date,                            :ticket, :description
+    attr_accessor :date, :ticket, :description
+
+    # allow to read everything else
+    attr_reader :start_time, :finish_time, :tags, :billable, :account, :publishable
 
     BILLABLE     = 1
     NON_BILLABLE = 0
 
+    class AdditionError < ::StandardError
+    end
+
     def initialize(config = Configuration.instance)
       @config = config
       @script = Script.new(@config[:dir])
@@ -38,6 +42,34 @@ module Ptimelog
       infer_ptime_settings
     end
 
+    def +(other) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      raise AdditionError, "Tickets don't match or empty" if @ticket != other.ticket || @ticket.to_s == ''
+      raise AdditionError, 'O RLY? Date is different' if @date != other.date
+      raise AdditionError, 'At least one is invalid' if [self, other].reject(&:valid?).any?
+
+      both_have_tags = [self, other].all? { |entry| !entry.tags.nil? }
+      raise AdditionError, 'Tags do not match' if both_have_tags && tag_list.sort != other.tag_list.sort
+
+      joined = self.class.new
+      joined.ticket = @ticket
+      joined.date = @date
+      joined.description = [@description, other.description].uniq.join(', ')
+      joined.tags = [tag_list, other.tag_list].uniq.join(' ')
+
+      joined.infer_ptime_settings
+
+      earlier, later = [self, other].sort
+
+      joined.start_time = earlier.start_time
+      joined.finish_time = if earlier.finish_time == later.start_time
+                             later.finish_time
+                           else
+                             (Time.parse(earlier.finish_time) + later.duration).strftime('%H:%M')
+                           end
+
+      joined
+    end
+
     def start_time=(time)
       @start_time = round_time(time, @config[:rounding])
     end
@@ -47,50 +79,81 @@ module Ptimelog
     end
 
     def tags=(tags)
+      raise 'HELL' unless tags.is_a?(String) || tags.nil?
+
       @tags = case tags
               when '', nil then nil
               else tags.split.compact
               end
     end
 
-    def valid?
-      @start_time && !hidden?
-    end
+    def valid? = @start_time && duration.positive? && !hidden?
 
-    def hidden?
-      @description.to_s.end_with?('**') # hide lunch and breaks
-    end
+    # hide lunch and breaks
+    def hidden? = @description.to_s.end_with?('**') || !publishable?
 
-    def billable?
-      @billable == BILLABLE
-    end
+    # or something like @tags.to_a.include?('special-team'), still needs to be implemented...
+    def selected? = true
+
+    def billable? = @billable == BILLABLE
+
+    def publishable? = @publishable != false
 
     def infer_ptime_settings
       return if hidden?
       return unless @script.inferer(script_name).exist?
 
-      @account, @billable = infer_account_and_billable
+      @account, @billable, @publishable = infer_entry_attributes
     end
 
     def duration
       (Time.parse(@finish_time) - Time.parse(@start_time)).to_i
     end
 
+    def duration_hours
+      format('%.02f', duration / 3600.0)
+    end
+
     def to_s
-      billable = billable? ? '$' : nil
+      billable = billable? ? '($)' : nil
+
+      tags = tag_list.join(' ') if tag_list.any?
+      desc = [@ticket, @description].compact.join(': ')
+      acc  = [@account, billable].compact.join(' ') if @account
+
       [
-        @start_time, '-', @finish_time,
-        [@ticket, @description, @tags, @account, billable].compact.join(' ∴ '),
+        @start_time, '-', @finish_time, SEPARATOR,
+        "#{duration_hours}h", SEPARATOR,
+        [desc, tags, acc].compact.join(" #{SEPARATOR} "),
       ].compact.join(' ')
     end
 
-    # make sortable/def <=>
+    def <=>(other)
+      @start_time <=> other.start_time
+    end
+
+    def ==(other)
+      comparable_attrs = %i[date ticket description start_time finish_time tags]
+
+      self.class == other.class &&
+        comparable_attrs.map { |attr| send(attr) == other.send(attr) }
+    end
+
+    protected
+
+    def tag_list
+      list = [first_tag] + tail_tags.split
+      list.reject(&:empty?).compact
+    end
+
+    def first_tag = @tags.to_a.first.to_s
+    def tail_tags = @tags.to_a[1..].to_a.join(' ')
 
     private
 
     def round_time(time, interval)
       return time unless interval
-      return unless time.to_s =~ /\d\d:\d\d/
+      return unless /\d\d:\d\d/.match?(time.to_s)
 
       hour, minute = time.split(':')
       minute = (minute.to_i / interval.to_f).round * interval.to_i
@@ -103,21 +166,25 @@ module Ptimelog
     end
 
     def script_name
-      @script_name ||= @tags.to_a.first.to_s
+      @script_name ||= first_tag
     end
 
     def script_args
-      @script_args ||= @tags.to_a[1..-1].to_a.map(&:inspect).join(' ')
+      @script_args ||= tail_tags.split.map(&:inspect).join(' ')
     end
 
-    def infer_account_and_billable
+    def infer_entry_attributes
       script = @script.inferer(script_name)
 
       cmd = %(#{script} "#{@ticket}" "#{@description}" #{script_args})
+      @inferer_cmd = cmd
 
-      account, billable = `#{cmd}`.chomp.split
+      results = `#{cmd}`.chomp.split
+      account = results[0]
+      billable = ((results[1] || 'false').to_s == 'true' ? BILLABLE : NON_BILLABLE)
+      publishable = ((results[2] || 'true').to_s == 'true')
 
-      [account, (billable == 'true' ? BILLABLE : NON_BILLABLE)]
+      [account, billable, publishable]
     end
   end
 end

data/lib/ptimelog/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ptimelog
+  # Superclass for all Errors that are somewhat expected
+  class Error < StandardError
+  end
+end

data/lib/ptimelog/joiner.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Ptimelog
+  # Join two directly adjacent entries or adjacent entries with the same ticket
+  class Joiner
+    def initialize(compact_on_ticket_only: false)
+      @compact_on_ticket_only = compact_on_ticket_only
+    end
+
+    def join_similar(list)
+      return [] if list.empty?
+      return list if list.one?
+
+      one, *tail = list
+      two, *rest = tail
+
+      joined = maybe_join(one, two)
+
+      if joined.one?
+        join_similar(joined + rest)
+      else
+        [one] + join_similar(tail)
+      end
+    end
+
+    private
+
+    def maybe_join(one, two)
+      return [one, two] if one.ticket != two.ticket || one.ticket.to_s == ''
+      return [one, two] if tags_are_present_but_differ(one, two)
+
+      if @compact_on_ticket_only ||
+         (one.description == two.description && one.finish_time == two.start_time)
+        [one + two]
+      else
+        [one, two]
+      end
+    end
+
+    def tags_are_present_but_differ(one, two)
+      both_have_tags = [one, two].all? { |entry| !entry.tags.nil? }
+      tags_differ = (one.tags.sort != two.tags.sort)
+
+      both_have_tags && tags_differ
+    end
+  end
+end