tempo-cli 0.1.0

data/lib/file_record/record.rb

@@ -0,0 +1,120 @@
+module FileRecord
+  class Record
+    class << self
+
+      # record text as a string, and all objects as yaml
+      # don't write over an existing document unless :force = true
+      # @options file file path to record to
+      # @options record string or object to record
+      # options
+      #  - force: true, overwrite file
+      #  - format: 'yaml', 'string'
+      def create( file, record, options={} )
+
+        if record.is_a?(String)
+          format = options.fetch(:format, 'string')
+        else
+          format = options.fetch(:format, 'yaml')
+        end
+
+        if File.exists?(file)
+          raise ArgumentError.new "file already exists" unless options[:force]
+        end
+
+        File.open( file,'w' ) do |f|
+
+          case format
+          when 'yaml'
+            f.puts YAML::dump( record )
+          when 'string'
+            f.puts record
+          else
+            f.puts record
+          end
+        end
+      end
+
+      def log_dirname( model )
+        dir_name = model.name[14..-1].gsub(/([A-Z])/, '_\1').downcase
+        dir = "tempo#{dir_name}s"
+      end
+
+      def log_dir( model )
+        dir_name = log_dirname model
+        dir = File.join(Dir.home,'tempo', dir_name)
+        Dir.mkdir(dir, 0700) unless File.exists?(dir)
+        dir
+      end
+
+      def log_filename( model, time )
+        file = "#{model.day_id( time )}.yaml"
+      end
+
+      def model_filename( model )
+        file_name = model.name[14..-1].gsub(/([A-Z])/, '_\1').downcase
+        file = "tempo#{file_name}s.yaml"
+      end
+
+      # record a child of Tempo::Model::Base
+      def save_model( model )
+        file = model_filename model
+        file_path = File.join(Dir.home,'tempo', file)
+        File.delete( file_path ) if File.exists?( file_path )
+
+        File.open( file_path,'a' ) do |f|
+          model.index.each do |m|
+            f.puts YAML::dump( m.freeze_dry )
+          end
+        end
+      end
+
+      # record a child of Tempo::Model::Log
+      def save_log( model )
+        dir = log_dir model
+
+        model.days_index.each do |day, days_logs|
+          file = "#{day.to_s}.yaml"
+          file_path = File.join(dir, file)
+          File.delete( file_path ) if File.exists?( file_path )
+
+          # don't write to an empty file
+          next if days_logs.empty?
+
+          File.open( file_path,'a' ) do |f|
+            days_logs.each do |log|
+              f.puts YAML::dump( log.freeze_dry )
+            end
+          end
+        end
+      end
+
+      def read_instances( model, file )
+        instances = YAML::load_stream( File.open( file ) )
+        instances.each do |i|
+          model.new( i )
+        end
+      end
+
+      def read_model( model )
+        file = File.join(Dir.home,'tempo', model.file)
+        read_instances model, file
+      end
+
+      def read_log( model, time )
+        dir = File.join(Dir.home,'tempo', model.dir)
+        file = File.join(dir, model.file( time ))
+        if File.exists? file
+          read_instances model, file
+        end
+      end
+    end
+
+    def update
+
+    end
+
+    def delete
+
+    end
+  end
+end

data/lib/tempo/controllers/arrange_controller.rb

@@ -0,0 +1,52 @@
+module Tempo
+  module Controllers
+    class Arrange < Tempo::Controllers::Base
+      @projects = Model::Project
+
+      class << self
+
+        def parse options, args
+
+          return Views::arrange_parse_error unless args.include? ":"
+
+          parent_args = []
+          child_args = []
+          in_parent = true
+          args.each do |a|
+            if a != ":"
+              in_parent ? parent_args << a : child_args << a
+            else
+              in_parent = false
+            end
+          end
+
+          if parent_args.empty?
+            make_root_project options, child_args
+          else
+            make_child_project options, parent_args, child_args
+          end
+        end
+
+        def make_root_project options, args
+          root = match_project :arrange, options, args
+          if root.parent == :root
+            Views::arrange_already_root root
+          else
+            parent = match_project :arrange, {id: true}, root.parent
+            parent.remove_child root
+            @projects.save_to_file
+            Views::arrange_root root
+          end
+        end
+
+        def make_child_project options, parent_args, child_args
+          parent = match_project :arrange, options, parent_args
+          child = match_project :arrange, options, child_args
+          parent << child
+          @projects.save_to_file
+          Views::arrange_parent_child parent, child
+        end
+      end #class << self
+    end
+  end
+end

data/lib/tempo/controllers/base.rb

@@ -0,0 +1,117 @@
+module Tempo
+  module Controllers
+    class Base
+      class << self
+
+        def filter_projects_by_title options, args
+          if options[:exact]
+            match = reassemble_the args
+            match = [match]
+            model_match @projects, match, "title", :exact
+          else
+            model_match @projects, args, "title", :fuzzy
+          end
+        end
+
+        # Takes an array of source strings
+        # and filters them down to the ones
+        # that match positively against every
+        # member of the matches array
+        #
+        def fuzzy_match haystack, matches, attribute="id"
+
+          matches = [matches] unless matches.is_a? Array
+
+          if haystack.is_a? Array
+            fuzzy_array_match( haystack, matches )
+
+          elsif haystack.superclass == Model::Base
+            model_match( haystack, matches, attribute )
+          end
+        end
+
+        # Gli default behavior: When args are sent in a
+        # command without quotes, they are broken into an array,
+        # and the first block is passed to a flag if present.
+        #
+        # Here we reassemble the string, and add value stored in
+        # a flag in the front. The value is also added back intto the
+        # front of the original array
+
+        def reassemble_the args, flag=nil
+          assembled = ""
+          args.unshift flag if flag
+          args.each { |a| assembled += " #{a}" }
+          assembled.strip!
+        end
+
+        private
+
+        # TODO: escape regex characters ., (), etc.
+        def match_to_regex match, type=:fuzzy
+          match.downcase!
+          if type == :exact
+            /^#{match}$/
+          else
+            /#{match}/
+          end
+        end
+
+        def fuzzy_array_match haystack, matches
+          results = []
+          matches.each do |m|
+            reg = match_to_regex m
+            haystack.each do |h|
+              results << h if reg.match h
+            end
+            haystack = results
+            results = []
+          end
+          haystack
+        end
+
+        def model_match haystack, matches, attribute, type=:fuzzy
+          attribute = "@#{attribute}".to_sym
+          contenders = haystack.index
+          results = []
+          matches.each do |m|
+            reg = match_to_regex m, type
+            contenders.each do |c|
+              results << c if reg.match c.instance_variable_get(attribute).to_s.downcase
+            end
+            contenders = results
+            results = []
+          end
+          contenders
+        end
+
+        def match_project command, options, args
+          if options[:id]
+            match = @projects.find_by_id args[0]
+            Views::no_match_error( "projects", "id=#{args[0]}" ) if not match
+          else
+            matches = filter_projects_by_title options, args
+            request = reassemble_the args
+            match = single_match matches, request, command
+          end
+          match
+        end
+
+        # verify one and only one match returned in match array
+        # returns the single match
+        def single_match matches, request, command
+
+          if matches.length == 0
+            Views::no_match_error "projects", request
+            return false
+          elsif matches.length > 1
+            Views::ambiguous_project matches, command
+            return false
+          else
+            match = matches[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tempo/controllers/checkout_controller.rb

@@ -0,0 +1,42 @@
+module Tempo
+  module Controllers
+    class Checkout < Tempo::Controllers::Base
+      @projects = Model::Project
+
+      class << self
+
+        def add_project options, args
+          request = reassemble_the args, options[:add]
+
+          if @projects.include? request
+            Views::already_exists_error "project", request
+
+          else
+            project = @projects.new({ title: request, current: true })
+            @projects.save_to_file
+            Views::project_checkout project
+          end
+        end
+
+        def existing_project options, args
+
+          match = match_project :checkout, options, args
+
+          if match
+            if @projects.current == match
+              Views::project_already_current match
+            else
+              @projects.current = match
+              @projects.save_to_file
+              Views::project_checkout match
+            end
+          end
+        end
+
+        def assistance
+          Views::checkout_assistance
+        end
+      end #class << self
+    end
+  end
+end

data/lib/tempo/controllers/end_controller.rb

@@ -0,0 +1,42 @@
+require 'chronic'
+
+module Tempo
+  module Controllers
+    class End < Tempo::Controllers::Base
+      @projects = Model::Project
+      @time_records = Model::TimeRecord
+
+      class << self
+
+        def end_timer options, args
+
+          return Views.project_assistance if Model::Project.index.empty?
+
+          if not options[:at]
+            time_out = Time.new()
+          else
+            time_out = Time.parse options[:at]
+          end
+
+          return Views.no_match_error( "valid timeframe", options[:at], false ) if not time_out
+
+          options = { end_time: time_out }
+          options[:description] = reassemble_the args
+
+          @time_records.load_last_day
+          record = @time_records.current
+
+          return Views.no_items( "running time records", :error ) if ! record
+
+          record.end_time = time_out
+          record.description = options[:description] if options[:description]
+          @time_records.save_to_file
+
+          Views.end_time_record_view record
+
+        end
+
+      end #class << self
+    end
+  end
+end

data/lib/tempo/controllers/projects_controller.rb

@@ -0,0 +1,107 @@
+module Tempo
+  module Controllers
+    class Projects < Tempo::Controllers::Base
+      @projects = Model::Project
+
+      class << self
+
+        def load
+          if File.exists?( File.join( ENV['HOME'], 'tempo', @projects.file ))
+            @projects.read_from_file
+          end
+        end
+
+        def index options, args
+
+          request = reassemble_the args
+
+          if args.empty?
+            Views::projects_list_view
+
+          else
+            matches = filter_projects_by_title options, args
+
+            if matches.empty?
+              Views::no_match_error "projects", request
+
+            else
+              Views::projects_list_view matches
+            end
+          end
+        end
+
+        def show_active
+          if @projects.index.empty?
+            Views::no_items "projects"
+          else
+            Views::Reporter.add_options active: true
+            Views::project_view @projects.current
+          end
+        end
+
+        def add options, args, tags=nil
+          request = reassemble_the args
+
+          if @projects.include? request
+            Views::already_exists_error "project", request
+
+          else
+            project = @projects.new({ title: request, tags: tags })
+
+            if @projects.index.length == 1
+              @projects.current = project
+            end
+
+            @projects.save_to_file
+
+            Views::project_added project
+          end
+        end
+
+        def delete options, args
+
+          reassemble_the args, options[:delete]
+          match = match_project :delete, options, args
+
+          if match
+            if match == @projects.current
+              return Views::ViewRecords::Message.new "cannot delete the active project", category: :error
+            end
+
+            if @projects.index.include?(match)
+              match.delete
+              @projects.save_to_file
+              Views::projects_list_view if options[:list]
+              Views::project_deleted match
+            end
+          end
+        end
+
+        # add a project with tags, or tag or untag an existing project
+        def tag options, args
+
+          # TODO @projects_find_by_tag if args.empty?
+
+          tags = options[:tag].split if options[:tag]
+          untags = options[:untag].split if options[:untag]
+
+          # add a new project
+          if options[:add]
+            add options, args, tags
+
+          else
+            command = options[:tag] ? "tag" : "untag"
+            match = match_project command, options, args
+
+            if match
+              match.tag tags
+              match.untag untags
+              @projects.save_to_file
+              Views::project_tags match
+            end
+          end
+        end
+      end #class << self
+    end
+  end
+end

data/lib/tempo/controllers/records_controller.rb

@@ -0,0 +1,21 @@
+module Tempo
+  module Controllers
+    class Records < Tempo::Controllers::Base
+      @projects = Model::Project
+
+      class << self
+
+        def initialize_from_records options, args
+          if File.exists?( File.join( ENV['HOME'], 'tempo' ))
+
+            Tempo::Controllers::Projects.load
+
+          else
+            FileRecord::Directory.create_new
+          end
+        end
+
+      end #class << self
+    end
+  end
+end

data/lib/tempo/controllers/report_controller.rb

@@ -0,0 +1,55 @@
+module Tempo
+  module Controllers
+    class Report < Tempo::Controllers::Base
+      @projects = Model::Project
+      @time_records = Model::TimeRecord
+
+      class << self
+
+        def report options, args
+
+          return Tempo::Views.project_assistance if Tempo::Model::Project.index.empty?
+
+          # A from flag has been supplied by the user
+          # and possible a to flag as well,
+          # so we return a period of day records
+          #
+          if options[:from] != "last record"
+            from = Time.parse options[:from]
+            return Views.no_match_error( "valid timeframe", options[:from], false ) if from.nil?
+
+            to = Time.parse options[:to]
+            return Views.no_match_error( "valid timeframe", options[:to], false ) if to.nil?
+
+            @time_records.load_days_records from, to
+
+            error_timeframe = " from #{from.strftime('%m/%d/%Y')} to #{to.strftime('%m/%d/%Y')}"
+
+          # no arguments or flags have been supplied, so we return the
+          # current day record
+          #
+          elsif args.empty?
+            @time_records.load_last_day
+
+          # arguments have been supplied,
+          # so we return the records for a single day
+          #
+          else
+            time = reassemble_the args
+
+            day = Time.parse time
+            return Views.no_match_error( "valid timeframe", time, false ) if day.nil?
+
+            @time_records.load_day_record day
+
+            error_timeframe = " on #{day.strftime('%m/%d/%Y')}"
+          end
+
+          return Views.no_items( "time records#{error_timeframe}", :error ) if @time_records.index.empty?
+
+          Views.report_records_view
+        end
+      end #class << self
+    end
+  end
+end

data/lib/tempo/controllers/start_controller.rb

@@ -0,0 +1,42 @@
+require 'chronic'
+
+module Tempo
+  module Controllers
+    class Start < Tempo::Controllers::Base
+      @projects = Model::Project
+      @time_records = Model::TimeRecord
+
+      class << self
+
+        def start_timer options, args
+
+          return Views.project_assistance if Model::Project.index.empty?
+
+          if not options[:at]
+            time_in = Time.new()
+          else
+            time_in = Time.parse options[:at]
+          end
+
+          return Views.no_match_error( "valid timeframe", options[:at], false ) if time_in.nil?
+
+          opts = { start_time: time_in }
+          opts[:description] = reassemble_the args
+
+          if options[:end]
+            time_out = Time.parse options[:end]
+            return Views.no_match_error( "valid timeframe", options[:end], false ) if time_out.nil?
+            opts[:end_time] = time_out
+          end
+          @time_records.load_last_day
+          record = @time_records.new(opts)
+          @time_records.save_to_file
+
+          Views.start_time_record_view record
+
+        end
+
+      end #class << self
+    end
+  end
+end

data/lib/tempo/controllers/update_controller.rb

@@ -0,0 +1,78 @@
+require 'chronic'
+
+module Tempo
+  module Controllers
+    class Update < Tempo::Controllers::Base
+      @projects = Model::Project
+      @time_records = Model::TimeRecord
+
+      class << self
+
+        def parse options, args
+
+          reassemble_the args
+
+          return Views.project_assistance if Model::Project.index.empty?
+
+          if options[:on]
+            day = Time.parse options[:on]
+            return Views.no_match_error( "valid timeframe", options[:from], false ) if day.nil?
+            @time_records.load_day_record day
+          else
+            day = @time_records.load_last_day
+          end
+
+          if options[:id]
+            record = @time_records.find_by_id( options[:id], day )
+            return Views.no_match_error( "time record on #{day.strftime('%m/%d/%Y')}", "id = #{options[:id]}", false ) if !record
+          else
+            record = @time_records.index.last
+            return Views.no_items( "time records on #{day.strftime('%m/%d/%Y')}", :error ) if ! record
+          end
+
+
+          if options[:delete]
+            record.delete
+            @time_records.save_to_file
+            Views.delete_time_record_view record
+
+          else
+            if options[:start]
+              start_time = Time.parse options[:start]
+              return Views.no_match_error( "valid timeframe", options[:at], false ) if start_time.nil?
+
+              # TODO: add "today " to start time and try again if not valid
+              if record.valid_start_time? start_time
+                record.start_time = start_time
+              else
+                return Views::ViewRecords::Message.new "cannot change start time to #{start_time.strftime('%H:%M')}", category: :error
+              end
+            end
+
+            if options[:end]
+              end_time = Time.parse options[:end]
+              return Views.no_match_error( "valid timeframe", options[:at], false ) if end_time.nil?
+
+              # TODO: add "today " to end time and try again if not valid
+              if record.valid_end_time? end_time
+                record.end_time = end_time
+              else
+                return Views::ViewRecords::Message.new "cannot change end time to #{end_time.strftime('%H:%M')}", category: :error
+              end
+            end
+
+            if options[:project]
+              record.project = @projects.current.id
+            end
+
+            options[:description] = reassemble_the args
+            record.description = options[:description] if options[:description] && !options[:description].empty?
+
+            @time_records.save_to_file
+            Views.update_time_record_view record
+          end
+        end
+      end #class << self
+    end
+  end
+end