ptimelog 0.9.0 → 0.12.0

data/lib/ptimelog/named_date.rb

@@ -9,17 +9,39 @@ module Ptimelog
       named_date(arg) || :all
     end
 
-    def named_date(date)
+    def named_date(date) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/AbcSize
       case date.to_s
-      when 'yesterday'        then Date.today.prev_day.to_s
+      when 'yesterday'        then yesterday
       when 'today'            then Date.today.to_s
-      when 'last', ''         then timelog.to_h.keys.compact.sort[-2] || Date.today.prev_day.to_s
-      when /\d{4}(-\d{2}){2}/ then date
+      when 'last', ''         then (last_entry || yesterday).to_s
+      when 'mon', 'monday'    then previous_weekday('monday')
+      when 'tue', 'tuesday'   then previous_weekday('tuesday')
+      when 'wed', 'wednesday' then previous_weekday('wednesday')
+      when 'thu', 'thursday'  then previous_weekday('thursday')
+      when 'fri', 'friday'    then previous_weekday('friday')
+      when 'sat', 'saturday'  then previous_weekday('saturday')
+      when 'sun', 'sunday'    then previous_weekday('sunday')
+      when /\d{4}(-\d{2}){2}/ then date.to_s
       end
     end
 
     private
 
+    def previous_weekday(date)
+      Date.today.prev_day(7)
+          .step(Date.today.prev_day)
+          .find { |d| d.send(:"#{date}?") }
+          .to_s
+    end
+
+    def last_entry
+      timelog.to_h.keys.compact.sort[-2]
+    end
+
+    def yesterday
+      Date.today.prev_day.to_s
+    end
+
     def timelog
       Timelog.load
     end

data/lib/ptimelog/operon.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'time'
+require 'yaml'
+
+module Ptimelog
+  # Extract entries from the time-sessions Operon tracks on its tasks
+  class Operon # rubocop:disable Metrics/ClassLength
+    # Operon documents its own task-syntax as examples, and the archive is history
+    SKIP_PATHS = ['Operon/Docs', 'archive'].freeze
+
+    FIELD_RE = /\{\{(\w+)::\s*(.*?)\}\}/
+    TASK_RE  = /^\s*-\s\[( |x|X)\]\s/
+    RANGE_RE = %r{
+      \A(?<start>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?)/
+      (?<stop>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?)\z
+    }x
+
+    # A config naming only one key must not lose the other
+    # TODO: determine if this can be done in the Ptimelog::Configuration
+    def self.custom_keys
+      Ptimelog::Configuration::CONFIGURATION_DEFAULTS['operon_custom_keys']
+        .merge(Ptimelog::Configuration.instance['operon_custom_keys'].to_h)
+    end
+
+    def initialize(day)
+      @day = day
+      @configuration = Ptimelog::Configuration.instance
+    end
+
+    # A missing vault would silently look like a day without any tracked time
+    class VaultNotFound < Ptimelog::Error
+      def initialize(path)
+        super(<<~MSG)
+          Could not find your Obsidian vault at #{path}
+
+          Please check 'obsidian_vault' in your ptimelog-config. It should
+          point to the folder which contains your '.obsidian'-directory.
+        MSG
+      end
+    end
+
+    # A session belongs to the day it started on. Plans and running timers are no time yet
+    def entries
+      tasks.flat_map { |task| entries_of(task) }
+           .sort_by(&:start_time)
+    end
+
+    # What a new entry would continue from: a running timer, the last session, the start of the day
+    def previous_entry
+      start = running_timer || entries.last&.finish_time || @configuration['operon_start_time'] || '08:00'
+
+      Ptimelog::Entry.new.tap do |entry|
+        entry.date        = @day
+        entry.description = 'start **'
+        entry.start_time  = start
+        entry.finish_time = start
+      end
+    end
+
+    # An entry can come from any note of the vault, so there is no one file to point at
+    def file = NullPathname.new
+
+    private
+
+    def vault
+      @vault ||= begin
+        path = @configuration['obsidian_vault']
+        raise VaultNotFound, path unless File.directory?(path)
+
+        path
+      end
+    end
+
+    def markdown_files
+      Dir.glob(vault.join('**/*.md')).reject { |fn| ignored?(fn) }
+    end
+
+    def ignored?(fn)
+      relative = fn.delete_prefix("#{vault}/")
+
+      SKIP_PATHS.any? { |path| relative.start_with?("#{path}/") }
+    end
+
+    # Every task of the vault, an inline one on its line, a file task in its frontmatter
+    def tasks
+      markdown_files.flat_map do |fn|
+        frontmatter, body = split_frontmatter(File.read(fn, encoding: 'UTF-8'))
+
+        file_tasks(frontmatter, fn) + inline_tasks(body)
+      end
+    end
+
+    def file_tasks(frontmatter, fn)
+      return [] unless frontmatter.is_a?(Hash)
+
+      [{ fields: frontmatter, description: File.basename(fn, '.md') }]
+    end
+
+    def inline_tasks(body)
+      body.each_line.filter_map do |line|
+        next unless line.match?(TASK_RE)
+
+        { fields: fields_of(line), description: description_of(line) }
+      end
+    end
+
+    def fields_of(line) = line.scan(FIELD_RE).to_h.transform_values(&:strip)
+
+    def description_of(line)
+      line.sub(TASK_RE, '').sub(/\s*\{\{.*\}\}\s*\z/m, '').strip
+    end
+
+    # A file task keeps its fields in frontmatter, an inline task carries them on its line
+    def split_frontmatter(text)
+      return [nil, text] unless text.start_with?('---')
+
+      close = text.index("\n---", 3)
+      return [nil, text] unless close
+
+      [YAML.safe_load(text[4...close], permitted_classes: [Date, Time], aliases: true), text[(close + 4)..]]
+    rescue Psych::Exception
+      [nil, text]
+    end
+
+    def entries_of(task)
+      session_list(task[:fields]['trackers']).filter_map do |session|
+        next unless on_day?(session[:start])
+
+        entry_for(session, task)
+      end
+    end
+
+    # Malformed ranges are dropped, one broken note must not sink a whole day
+    def session_list(sessions)
+      list = sessions.is_a?(String) ? sessions.split('; ') : Array(sessions)
+
+      list.filter_map { |session| RANGE_RE.match(session.to_s.strip) }
+    end
+
+    # A running timer is no session yet, but it says where the work stopped
+    def running_timer
+      started = tasks.filter_map { |task| task[:fields]['activeTracker'] }.find { |at| on_day?(at) }
+
+      started && Time.parse(started).strftime('%R')
+    end
+
+    def on_day?(datetime)
+      Time.parse(datetime).strftime('%F') == @day
+    end
+
+    def entry_for(session, task) # rubocop:disable Metrics/AbcSize
+      fields = task[:fields]
+
+      Ptimelog::Entry.new.tap do |entry|
+        entry.date        = @day
+        entry.ticket      = fields[custom_key('ticket')]
+        entry.description = task[:description]
+        entry.tags        = fields[custom_key('inferer')]
+        entry.start_time  = Time.parse(session[:start]).strftime('%R')
+        entry.finish_time = Time.parse(session[:stop]).strftime('%R')
+
+        entry.infer_ptime_settings
+      end
+    end
+
+    def custom_key(name) = self.class.custom_keys.fetch(name)
+  end
+end

data/lib/ptimelog/script.rb

@@ -10,7 +10,7 @@ module Ptimelog
 
     def inferer(name)
       return NullPathname.new if name.to_s.empty?
-      raise if name =~ %r{[\\/]} # prevent relavtive paths, stupidly, FIXME: really check FS
+      raise if %r{[\\/]}.match?(name) # prevent relavtive paths, stupidly, FIXME: really check FS
 
       @config_dir.join('inferers').join(name).expand_path
     end

data/lib/ptimelog/timelog.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'singleton'
 require 'pathname'
 
 module Ptimelog
@@ -13,7 +14,19 @@ module Ptimelog
       end
 
       def timelog_txt
-        Pathname.new(Configuration.instance[:timelog]).expand_path
+        Pathname.new(Configuration.instance[:timelog_txt]).expand_path
+      end
+
+      def previous_entry
+        lines = timelog_txt.readlines.last(10)
+
+        last_line = lines.map(&:chomp).delete_if do |line|
+          line.empty? || line.end_with?('**')
+        end.last
+
+        last_entry = instance.tokenize(last_line)
+
+        Entry.from_timelog(last_entry)
       end
     end
 
@@ -25,10 +38,23 @@ module Ptimelog
       self.class.timelog_txt
     end
 
+    def previous_entry
+      self.class.previous_entry
+    end
+
     def read
       timelog_txt.read
     end
 
+    # TODO: spec and activate this code
+    # def add(_entry)
+    #   @new_lines = []
+    #   add_empty_line if @timelog.previous_entry.date == yesterday
+    #   add_entry(*parse_task(task))
+    #
+    #   save_file
+    # end
+
     def parse(data)
       data.split("\n")
           .map { |line| tokenize(line) }
@@ -46,5 +72,44 @@ module Ptimelog
       regexp = /^#{re_date} #{re_time}: #{re_tick}?#{re_desc}#{re_tags}?$/
       line.match(regexp)
     end
+
+    # TODO: spec and maybe activate this code. this might be covered by the "add"-command already.
+    # def parse_task(line)
+    #   matches = line.match('(?<time>\d{1,2}:\d{2} )?(?<offset>[+-]\d+ )?(?<task>.*)')
+    #   formatted_time = if matches[:time]
+    #                      Time.parse(matches[:time])
+    #                    else
+    #                      Time.now
+    #                    end
+    #                    .localtime
+    #                    .then { |time| time + (matches[:offset].to_i * 60) }
+    #                    .strftime('%F %R')
+    #
+    #   [formatted_time, matches[:task]]
+    # end
+
+    # TODO: spec and activate this code.
+    # def add_entry(date_time, task)
+    #   @new_lines << "#{date_time}: #{task}"
+    # end
+
+    # TODO: spec and activate this code.
+    # def add_empty_line
+    #   @new_lines << ''
+    # end
+
+    # TODO: spec and activate this code.
+    # def save_file
+    #   @timelog.timelog_txt.open('a') do |log|
+    #     @new_lines.each do |line|
+    #       log << "#{line}\n"
+    #     end
+    #   end
+    # end
+
+    # TODO: spec and activate this code.
+    # def yesterday
+    #   NamedDate.new.named_date('yesterday')
+    # end
   end
 end

data/lib/ptimelog/version.rb

@@ -15,6 +15,14 @@
 # any remaining questions, please open an issue or even better a pull-request
 # with an improvement. Keep in mind that this is also covered by rspec so I
 # expect (pun intended) 100% test-coverage for any additional code.
+#
+# Without much preparation came the addition of cmdparse to this gem. While
+# adding it, it became apparent that a duplication between the gemspec and the
+# main executable may exist. In order to avoid this dreadfully duplicated
+# description, a constant for this has been added to this module. So, the
+# correct subtitle of this documentation-block would be "and a Banner not named
+# Bruce."
 module Ptimelog
-  VERSION = '0.9.0'
+  VERSION = '0.12.0'
+  BANNER = 'Move time-entries from gTimelog or Obsidian to PuzzleTime'
 end

data/lib/ptimelog.rb

@@ -6,20 +6,31 @@ $LOAD_PATH.unshift File.dirname(__FILE__)
 module Ptimelog
   autoload :App, 'ptimelog/app'
   autoload :Configuration, 'ptimelog/configuration'
-  autoload :Day, 'ptimelog/day'
+  autoload :DataSource, 'ptimelog/data_source'
   autoload :DeprecationWarning, 'ptimelog/deprecation_warning'
   autoload :Entry, 'ptimelog/entry'
+  autoload :Error, 'ptimelog/error'
+  autoload :Joiner, 'ptimelog/joiner'
   autoload :NamedDate, 'ptimelog/named_date'
   autoload :NullPathname, 'ptimelog/null_pathname'
   autoload :Script, 'ptimelog/script'
-  autoload :Timelog, 'ptimelog/timelog'
   autoload :VERSION, 'ptimelog/version'
 
+  # datasources
+
+  # obsidian
+  autoload :Operon, 'ptimelog/operon'
+
+  # timelog.txt
+  autoload :Day, 'ptimelog/day'
+  autoload :Timelog, 'ptimelog/timelog'
+
   # Collection of commands available at the CLI
   module Command
     autoload :Add, 'ptimelog/command/add'
-    autoload :Base, 'ptimelog/command/base'
+    autoload :Confirm, 'ptimelog/command/confirm'
     autoload :Edit, 'ptimelog/command/edit'
+    autoload :Info, 'ptimelog/command/info'
     autoload :Show, 'ptimelog/command/show'
     autoload :Upload, 'ptimelog/command/upload'
     autoload :Version, 'ptimelog/command/version'

data/opencode.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "agent": {
+    "researcher": {
+      "permission": {
+        "edit": "deny",
+        "skill": "deny",
+        "question": "allow",
+      }
+    },
+    "assistant": {
+      "permission": {
+        "bash": {
+          "*": "ask",
+          "rspec*": "allow",
+          "rubocop*": "allow",
+          "rake*": "allow",
+          "git status*": "allow",
+          "git diff*": "allow",
+          "git log*": "allow",
+          "git show*": "allow",
+          "git add --intent-to-add*": "allow",
+          "git add*": "ask",
+          "git commit*": "ask",
+          "git push*": "deny",
+          "ls*": "allow",
+          "tail *": "allow",
+          "head *": "allow",
+          "grep*": "allow",
+          "cat*": "allow",
+          "pwd": "allow"
+        },
+      }
+    }
+  }
+}
+