gpuzzletime 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da04f6e2158de538ed579e152023e1577f4743eaf869148398cad63cc4602e7e
-  data.tar.gz: 1cbf496d462a395a0466e7fe0d94ef54ef3bd59c64caccfa7c3a77e5ca013fe7
+  metadata.gz: fc1eef3b25f4f3015781febe8555a216bf698792c48156bd329b4141320afc73
+  data.tar.gz: 3ed5f21efea39a9ed1d22dc0f2d88e5f0f84f52354aef61ea796c622c1e1fea8
 SHA512:
-  metadata.gz: e35352a95c6bc0bda0ce852f7b95c9681ca508d094239b754d5081fdb625c0d8e0eafd50983206b70ef2fbd7656164f3965d4d730612eec786c6dd1fe580ae4d
-  data.tar.gz: 8ca1ea92a1036ce3f9a791d2d565728dcc7ecd2afe510cb04f60579e57d0ce3eaf78d7e5c7fb9f3208ec58cbac01c8117e5b3361befc8b4c2b8599869d14d860
+  metadata.gz: 23645f4ee698fc07c15037cf42a90675239d562be0ba88335215877db47a28942886e5f2d3db0cb1e30837636f4b11cf3d2be1ff17405fc6470def9c52f736f6
+  data.tar.gz: bec498910a2e0ff180fc3bba9b7a226ffcf1f7244a770c9b61186196d1f3b0c742fba92875bab91816e59ff1b08c86ed267a1b38a17fed44f1ba28e0c2b43f43

data/.rubocop.yml

@@ -17,3 +17,17 @@ Layout/AlignHash:
   EnforcedHashRocketStyle: table
   EnforcedColonStyle: table
   EnforcedLastArgumentHashStyle: always_inspect # default
+
+Naming/UncommunicativeMethodParamName:
+  AllowedNames:
+    - fn
+    # default allowed names
+    - io
+    - id
+    - to
+    - by
+    - on
+    - in
+    - at
+    - ip
+    - db

data/README.md

@@ -6,7 +6,7 @@ small tooling to transfer timelog-entries from gtimelog's timelog.txt to the Puz
 
 - [x] read timelog.txt
   - [x] from known location
-  - [ ] later: configure location?
+  - [x] later: configure location?
   - [ ] later: auto-detect location?
 - [x] parse out last day
   - [x] especially start/end-times for each entry
@@ -19,8 +19,9 @@ small tooling to transfer timelog-entries from gtimelog's timelog.txt to the Puz
   - [x] get ticket-parser from tags
 - [ ] merge equal adjacent entries into one
 - [ ] complete login/entry automation
-  - [ ] login
-  - [ ] store cookie
+  - [ ] handle authentication
+    - [ ] login and store cookie
+    - [ ] send user and pwd with every request
   - [ ] make entries
   - [ ] open day in browser for review
 - [ ] avoid duplicate entries
@@ -37,7 +38,7 @@ small tooling to transfer timelog-entries from gtimelog's timelog.txt to the Puz
   - [ ] allow to have a list of "favourite" time-accounts
   - [ ] select best-matching time-account according to tags, possibly limited to the favourites
 - [ ] add cli-help
-
+  - [ ] use commander for CLI?
 
 ## Installation
 

data/lib/gpuzzletime.rb

@@ -5,6 +5,17 @@ $LOAD_PATH.unshift File.dirname(__FILE__)
 # Autoloading and such
 module Gpuzzletime
   autoload :App, 'gpuzzletime/app'
+  autoload :Configuration, 'gpuzzletime/configuration'
+  autoload :Entry, 'gpuzzletime/entry'
+  autoload :NamedDate, 'gpuzzletime/named_date'
+  autoload :Script, 'gpuzzletime/script'
   autoload :Timelog, 'gpuzzletime/timelog'
   autoload :VERSION, 'gpuzzletime/version'
+
+  # Collection of commands available at the CLI
+  module Command
+    autoload :Edit, 'gpuzzletime/command/edit'
+    autoload :Show, 'gpuzzletime/command/show'
+    autoload :Upload, 'gpuzzletime/command/upload'
+  end
 end

data/lib/gpuzzletime/app.rb

@@ -7,195 +7,60 @@ require 'pathname'
 module Gpuzzletime
   # Wrapper for everything
   class App
-    CONFIGURATION_DEFAULTS = {
-      base_url: 'https://time.puzzle.ch',
-      rounding: 15,
-      dir:      Pathname.new('~/.config/gpuzzletime').expand_path,
-    }.freeze
-
     def initialize(args)
-      @config  = load_config(CONFIGURATION_DEFAULTS[:dir].join('config'))
-      @command = (args[0] || :show).to_sym
-
-      case @command
-      when :show, :upload
-        @date = named_dates(args[1] || 'last') || :all
-      when :edit
-        @file = args[1]
-      else
-        raise ArgumentError, "Unsupported Command #{@command}"
-      end
+      @config = Configuration.instance
+      command = (args[0] || :show).to_sym
+
+      @command = case command
+                 when :show
+                   @date = NamedDate.new.date(args[1])
+                   Gpuzzletime::Command::Show.new(@config)
+                 when :upload
+                   @date = NamedDate.new.date(args[1])
+                   Gpuzzletime::Command::Upload.new(@config)
+                 when :edit
+                   Gpuzzletime::Command::Edit.new(@config, args[1])
+                 else
+                   raise ArgumentError, "Unsupported Command #{@command}"
+                 end
     end
 
     def run
-      case @command
-      when :show
-        fill_entries(@command)
-        entries.each do |date, entries|
-          puts date, '----------'
-          entries.each do |entry|
-            puts entry
-          end
-          puts nil
-        end
-      when :upload
-        fill_entries(@command)
-        entries.each do |date, entries|
-          puts "Uploading #{date}"
-          entries.each do |start, entry|
-            open_browser(start, entry)
-          end
-        end
-      when :edit
-        launch_editor
+      if @command.needs_entries?
+        fill_entries
+        @command.entries = entries
       end
+
+      @command.run
     end
 
     private
 
-    def load_config(config_fn)
-      user_config = config_fn.exist? ? YAML.load_file(config_fn) : {}
-
-      CONFIGURATION_DEFAULTS.merge(user_config)
-    end
-
     def entries
       @entries ||= {}
     end
 
-    def timelog
+    def timeload
       Timelog.load
     end
 
-    def fill_entries(purpose)
+    def fill_entries
       timelog.each do |date, lines|
-        # this is mixing preparation, assembly and output, but gets the job done
         next unless date                           # guard against the machine
         next unless @date == :all || @date == date # limit to one day if passed
 
         entries[date] = []
-
         start = nil # at the start of the day, we have no previous end
 
-        lines.each do |entry|
-          finish = round_time(entry[:time], @config[:rounding]) # we use that twice
-          hidden = entry[:description].match(/\*\*$/) # hide lunch and breaks
+        lines.each do |line|
+          entry = Entry.from_timelog(line)
+          entry.start_time = start
 
-          if start && !hidden
-            case purpose # assemble data according to command
-            when :show
-              entries[date] << [
-                start, '-', finish,
-                [
-                  entry[:ticket],
-                  entry[:description],
-                  entry[:tags],
-                  infer_account(entry),
-                ].compact.join(' ∴ '),
-              ].compact.join(' ')
-            when :upload
-              entries[date] << [start, entry]
-            end
-          end
+          entries[date] << entry if entry.valid?
 
-          start = finish # store previous ending for nice display of next entry
+          start = entry.finish_time # store previous ending for nice display of next entry
         end
       end
     end
-
-    def round_time(time, interval)
-      return time unless interval
-
-      hour, minute = time.split(':')
-      minute = (minute.to_i / interval.to_f).round * interval.to_i
-
-      if minute == 60
-        [hour.succ, 0]
-      else
-        [hour, minute]
-      end.map { |part| part.to_s.rjust(2, '0') }.join(':')
-    end
-
-    def open_browser(start, entry)
-      xdg_open "'#{@config[:base_url]}/ordertimes/new?#{url_options(start, entry)}'", silent: true
-    end
-
-    def xdg_open(args, silent: false)
-      opener   = 'xdg-open' # could be configurable, but is already a proxy
-      silencer = '> /dev/null 2> /dev/null'
-
-      if system("which #{opener} #{silencer}")
-        system "#{opener} #{args} #{silencer if silent}"
-      else
-        abort <<~ERRORMESSAGE
-          #{opener} not found
-
-          This binary is needed to launch a webbrowser and open the page
-          to enter the worktime-entry into puzzletime.
-
-          If this needs to be configurable, please open an issue at
-          https://github.com/kronn/gpuzzletime/issues/new
-        ERRORMESSAGE
-      end
-    end
-
-    def launch_editor
-      editor = `which $EDITOR`.chomp
-
-      file = @file.nil? ? Timelog.timelog_txt : parser_file(@file)
-
-      exec "#{editor} #{file}"
-    end
-
-    def url_options(start, entry)
-      account = infer_account(entry)
-      {
-        work_date:                    entry[:date],
-        'ordertime[ticket]':          entry[:ticket],
-        'ordertime[description]':     entry[:description],
-        'ordertime[from_start_time]': start,
-        'ordertime[to_end_time]':     round_time(entry[:time], @config[:rounding]),
-        'ordertime[account_id]':      account,
-        'ordertime[billable]':        infer_billable(account),
-      }
-        .map { |key, value| [key, ERB::Util.url_encode(value)].join('=') }
-        .join('&')
-    end
-
-    def named_dates(date)
-      case date
-      when 'yesterday'        then Date.today.prev_day.to_s
-      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
-      end
-    end
-
-    def parser_file(parser_name)
-      @config[:dir].join("parsers/#{parser_name}") # FIXME: security-hole, prevent relative paths!
-                   .expand_path
-    end
-
-    def infer_account(entry)
-      return unless entry[:tags]
-
-      tags = entry[:tags].split
-      parser_name = tags.shift
-
-      parser = parser_file(parser_name)
-
-      return unless parser.exist?
-
-      cmd = %(#{parser} "#{entry[:ticket]}" "#{entry[:description]}" #{tags.map(&:inspect).join(' ')})
-      `#{cmd}`.chomp # maybe only execute if parser is in correct dir?
-    end
-
-    def infer_billable(account)
-      script = @config[:dir].join('billable')
-
-      return 1 unless script.exist?
-
-      `#{script} #{account}`.chomp == 'true' ? 1 : 0
-    end
   end
 end

data/lib/gpuzzletime/command/edit.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Gpuzzletime
+  module Command
+    # edit one file. without argument, it will edit the timelog, otherwise a
+    # parser-script is loaded
+    class Edit
+      def initalize(config, file)
+        @config = config
+        @script = Script.new(@config[:dir])
+        @file   = file
+      end
+
+      def needs_entries?
+        false
+      end
+
+      def run
+        launch_editor(@file)
+      end
+
+      private
+
+      def launch_editor(file)
+        editor = `which $EDITOR`.chomp
+
+        file = file.nil? ? Timelog.timelog_txt : @script.parser(@file)
+
+        exec "#{editor} #{file}"
+      end
+    end
+  end
+end

data/lib/gpuzzletime/command/show.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Gpuzzletime
+  module Command
+    # show entries of one day or all of them
+    class Show
+      def initialize(config)
+        @config  = config
+        @entries = {}
+      end
+
+      def needs_entries?
+        true
+      end
+
+      def run
+        @entries.each do |date, list|
+          puts date, '----------'
+          list.each do |entry|
+            puts entry
+          end
+          puts nil
+        end
+      end
+
+      def entries=(entries)
+        entries.each do |date, list|
+          @entries[date] = []
+
+          list.each do |entry|
+            @entries[date] << [
+              entry.start_time, '-', entry.finish_time,
+              [
+                entry.ticket,
+                entry.description,
+                entry.tags,
+                entry.account,
+              ].compact.join(' ∴ '),
+            ].compact.join(' ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gpuzzletime/command/upload.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Gpuzzletime
+  module Command
+    # Upload entries to puzzletime
+    class Upload
+      attr_writer :entries
+
+      def initialize(config)
+        @config  = config
+        @entries = {}
+      end
+
+      def needs_entries?
+        true
+      end
+
+      def run
+        @entries.each do |date, list|
+          puts "Uploading #{date}"
+          list.each do |entry|
+            open_browser(entry)
+          end
+        end
+      end
+
+      private
+
+      def open_browser(entry)
+        xdg_open "'#{@config[:base_url]}/ordertimes/new?#{url_options(entry)}'", silent: true
+      end
+
+      def xdg_open(args, silent: false)
+        opener   = 'xdg-open' # could be configurable, but is already a proxy
+        silencer = '> /dev/null 2> /dev/null'
+
+        if system("which #{opener} #{silencer}")
+          system "#{opener} #{args} #{silencer if silent}"
+        else
+          abort <<~ERRORMESSAGE
+            #{opener} not found
+
+            This binary is needed to launch a webbrowser and open the page
+            to enter the worktime-entry into puzzletime.
+
+            If this needs to be configurable, please open an issue at
+            https://github.com/kronn/gpuzzletime/issues/new
+          ERRORMESSAGE
+        end
+      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,
+        }
+          .map { |key, value| [key, ERB::Util.url_encode(value)].join('=') }
+          .join('&')
+      end
+    end
+  end
+end

data/lib/gpuzzletime/configuration.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Gpuzzletime
+  # Wrapper around configuration-options and -loading
+  class Configuration
+    include Singleton
+
+    CONFIGURATION_DEFAULTS = {
+      base_url: 'https://time.puzzle.ch',
+      rounding: 15,
+      dir:      '~/.config/gpuzzletime',
+      timelog:  '~/.local/share/gtimelog/timelog.txt',
+    }.freeze
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @config = load_config(
+        Pathname.new(CONFIGURATION_DEFAULTS[:dir]).join('config')
+      )
+      wrap_with_pathname(:dir)
+      wrap_with_pathname(:timelog)
+    end
+
+    def load_config(fn)
+      user_config = fn.exist? ? YAML.load_file(fn) : {}
+
+      CONFIGURATION_DEFAULTS.merge(user_config)
+    end
+
+    def [](key)
+      @config[key.to_sym]
+    end
+
+    def []=(key, value)
+      @config[key.to_sym] = value
+
+      wrap_with_pathname(key.to_sym) if %w[dir timelog].include?(key.to_s)
+    end
+
+    private
+
+    def wrap_with_pathname(key)
+      return unless @config.key?(key)
+      return @config[key] if @config[key].is_a? Pathname
+
+      @config[key] = Pathname.new(@config[key]).expand_path
+    end
+  end
+end

data/lib/gpuzzletime/entry.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Gpuzzletime
+  # Dataclass to wrap an entry
+  class Entry
+    # allow to read everything
+    attr_reader :date, :start_time, :finish_time, :ticket, :description,
+                :tags, :billable, :account
+
+    # define only trivial writers, omit special and derived values
+    attr_writer :date, :start_time,               :ticket, :description
+
+    def initialize(config = Configuration.instance)
+      @config = config
+      @script = Script.new(@config[:dir])
+    end
+
+    class << self
+      def from_timelog(matched_line)
+        entry = new
+        entry.from_timelog(matched_line)
+        entry
+      end
+    end
+
+    def from_timelog(matched_line)
+      self.date        = matched_line[:date]
+      self.ticket      = matched_line[:ticket]
+      self.description = matched_line[:description]
+      self.finish_time = matched_line[:time]
+      self.tags        = matched_line[:tags]
+
+      infer_ptime_settings
+    end
+
+    def finish_time=(time)
+      @finish_time = round_time(time, @config[:rounding])
+    end
+
+    def tags=(tags)
+      return unless tags
+
+      @tags = tags.split
+    end
+
+    def valid?
+      @start_time && !hidden?
+    end
+
+    def hidden?
+      @description.match(/\*\*$/) # hide lunch and breaks
+    end
+
+    def infer_ptime_settings
+      @account  = infer_account
+      @billable = infer_billable
+    end
+
+    def to_s
+      [
+        @start_time, '-', @finish_time,
+        [
+          @ticket,
+          @description,
+          @tags,
+          @account,
+        ].compact.join(' : '),
+      ].compact.join(' ')
+    end
+
+    # make sortable/def <=>
+    # duration if start and finish is set
+
+    private
+
+    def round_time(time, interval)
+      return time unless interval
+
+      hour, minute = time.split(':')
+      minute = (minute.to_i / interval.to_f).round * interval.to_i
+
+      if minute == 60
+        [hour.succ, 0]
+      else
+        [hour, minute]
+      end.map { |part| part.to_s.rjust(2, '0') }.join(':')
+    end
+
+    def infer_account
+      return unless @tags
+
+      parser_name = tags.shift
+      parser = @script.parser(parser_name)
+
+      return unless parser.exist?
+
+      cmd = %(#{parser} "#{@ticket}" "#{@description}" #{tags.map(&:inspect).join(' ')})
+      `#{cmd}`.chomp # maybe only execute if parser is in correct dir?
+    end
+
+    def infer_billable
+      script = @script.billable
+
+      return 1 unless script.exist?
+
+      `#{script} #{@account}`.chomp == 'true' ? 1 : 0
+    end
+  end
+end

data/lib/gpuzzletime/named_date.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Gpuzzletime
+  # Mapping between semantic/relative names and absolute dates
+  class NamedDate
+    def date(arg = 'last')
+      named_date(arg) || :all
+    end
+
+    def named_date(date)
+      case date
+      when 'yesterday'        then Date.today.prev_day.to_s
+      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
+      end
+    end
+
+    private
+
+    def timelog
+      Timelog.load
+    end
+  end
+end

data/lib/gpuzzletime/script.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Gpuzzletime
+  # Wrapper around all external scripts that might be called to get more
+  # information about the time-entries
+  class Script
+    def initialize(config_dir)
+      @config_dir = config_dir
+    end
+
+    def parser(parser_name)
+      @config_dir.join("parsers/#{parser_name}") # FIXME: security-hole, prevent relative paths!
+                 .expand_path
+    end
+
+    def billable
+      @config_dir.join('billable').expand_path
+    end
+  end
+end

data/lib/gpuzzletime/timelog.rb

@@ -5,18 +5,20 @@ require 'pathname'
 module Gpuzzletime
   # Load and tokenize the data from gtimelog
   class Timelog
+    include Singleton
+
     class << self
       def load
-        new.load
+        instance.load
       end
 
       def timelog_txt
-        Pathname.new('~/.local/share/gtimelog/timelog.txt').expand_path
+        Pathname.new(Configuration.instance[:timelog]).expand_path
       end
     end
 
     def load
-      parse(read)
+      @load ||= parse(read)
     end
 
     def timelog_txt

data/lib/gpuzzletime/version.rb

@@ -2,5 +2,5 @@
 
 # Version
 module Gpuzzletime
-  VERSION = '0.4.0'
+  VERSION = '0.4.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gpuzzletime
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Matthias Viehweger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-09 00:00:00.000000000 Z
+date: 2019-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -134,6 +134,13 @@ files:
 - gpuzzletime.gemspec
 - lib/gpuzzletime.rb
 - lib/gpuzzletime/app.rb
+- lib/gpuzzletime/command/edit.rb
+- lib/gpuzzletime/command/show.rb
+- lib/gpuzzletime/command/upload.rb
+- lib/gpuzzletime/configuration.rb
+- lib/gpuzzletime/entry.rb
+- lib/gpuzzletime/named_date.rb
+- lib/gpuzzletime/script.rb
 - lib/gpuzzletime/timelog.rb
 - lib/gpuzzletime/version.rb
 homepage: https://github.com/kronn/gpuzzletime