tempo-cli 0.1.0

data/lib/tempo/models/time_record.rb

@@ -0,0 +1,235 @@
+module Tempo
+  module Model
+    class TimeRecord < Tempo::Model::Log
+      attr_accessor :project, :description
+      attr_reader :start_time, :end_time, :tags
+
+      class << self
+
+        def current
+          return @current if @current && @current.end_time == :running
+          @current = nil
+        end
+
+        def current=( instance )
+          if instance.class == self
+            @current = instance
+          else
+            raise ArgumentError
+          end
+        end
+      end
+
+      def initialize(options={})
+
+        # declare these first for model organization when sent to YAML
+        @project_title = nil
+        @description = options.fetch :description, ""
+        @start_time = nil
+
+        # verify both start time and end time before sending to super
+        options[:start_time] ||= Time.now
+        verify_start_time options[:start_time]
+        @end_time = options.fetch :end_time, :running
+        verify_end_time options[:start_time], @end_time
+        super options
+
+        project = options.fetch :project, Tempo::Model::Project.current
+        @project = project.kind_of?(Integer) ? project : project.id
+
+        @tags = []
+        tag options.fetch(:tags, [])
+
+        # close out the running time record
+        if running?
+          if not self.class.current
+            self.class.current = self
+          else
+
+            current = self.class.current
+
+            # more recent entries exist, need to close out immediately
+            if current.start_time > @start_time
+              if current.start_time.day > @start_time.day
+                out = self.class.end_of_day @start_time
+                @end_time = out
+                # TODO add a new record onto the next day
+              else
+                @end_time = current.start_time
+              end
+
+            # close out the last current record
+            else
+              self.class.close_current @start_time
+              self.class.current = self
+            end
+          end
+
+        # close out any earlier running timerecords
+        else
+          if self.class.current
+             if self.class.current.start_time < @start_time
+               self.class.close_current @start_time
+             end
+          end
+        end
+      end
+
+      def start_time= time
+        @start_time = time if verify_start_time time
+      end
+
+      def end_time= time
+        @end_time = time if verify_end_time self.start_time, time
+      end
+
+      def valid_start_time? time
+        begin
+          verify_start_time time
+        rescue ArgumentError => e
+          return false
+        end
+        true
+      end
+
+      def valid_end_time? time
+        begin
+          verify_end_time self.start_time, time
+        rescue ArgumentError => e
+          return false
+        end
+        true
+      end
+
+      def project_title
+        Project.find_by_id( @project ).title if @project
+      end
+
+      def duration
+        if @end_time.kind_of? Time
+          end_time = @end_time
+        else
+          end_time = Time.now()
+        end
+        end_time.to_i - @start_time.to_i
+      end
+
+      def running?
+        @end_time == :running
+      end
+
+      def freeze_dry
+        record = super
+        record[:project_title] = project_title
+        record
+      end
+
+      def tag( tags )
+        return unless tags and tags.kind_of? Array
+        tags.each do |tag|
+          tag.split.each {|t| @tags << t if ! @tags.include? t }
+        end
+        @tags.sort!
+      end
+
+      def untag( tags )
+        return unless tags and tags.kind_of? Array
+        tags.each do |tag|
+          tag.split.each {|t| @tags.delete t }
+        end
+      end
+
+      def to_s
+        "#{@start_time} - #{@end_time}, #{project_title}: #{@description}"
+      end
+
+      private
+
+      #close current at the end time, or on the last minute
+      # of the day if end time is another day
+      #
+      def self.close_current end_time
+        if end_time.day > current.start_time.day
+          out = end_of_day current.start_time
+          current.end_time = out
+        else
+          current.end_time = end_time
+        end
+      end
+
+      # check a time against all loaded instances, verify that it doesn't
+      # fall in the middle of any closed time records
+      #
+      def verify_start_time time
+
+        # Check that there are currently
+        # records on the day to iterate through
+        dsym = self.class.date_symbol time
+        return true if not self.class.days_index[dsym]
+
+        self.class.days_index[dsym].each do |record|
+
+          next if record.end_time == :running
+          next if record == self
+          if time < record.end_time
+            raise ArgumentError, "Time conflict with existing record" if time_in_record? time, record
+          end
+        end
+        true
+      end
+
+      def verify_end_time start_time, end_time
+
+        # TODO: a better check for :running conditions
+        return true if end_time == :running
+
+        raise ArgumentError, "End time must be greater than start time" if end_time < start_time
+
+        dsym = self.class.date_symbol end_time
+        start_dsym = self.class.date_symbol start_time
+        raise ArgumentError, "End time must be on the same day as start time: #{start_time} : #{end_time}" if dsym != start_dsym
+
+        # this is necessary if this is the first record
+        # for the day and self is not yet added to index
+        return if not self.class.days_index[dsym]
+
+        self.class.days_index[dsym].each do |record|
+          next if record == self
+          raise ArgumentError, "Time conflict with existing record:" if time_span_intersects_record? start_time, end_time, record
+        end
+        true
+      end
+
+      # this is used for both start time and end times,
+      # so it will return true if the time is :running
+      # or if it is exactly the record start or end time
+      # these conditions need to be checked separately
+      def time_in_record? time, record
+        return false if record.end_time == :running
+        time >= record.start_time && time <= record.end_time
+      end
+
+      # All true conditions should be used to raise errors.
+      # Returns false is when sharing a single end and start point (a valid state).
+      # It does not invalidate a time span earlier than the record with a :running end time,
+      # this condition must be accounted for separately.
+      # It assumes a valid start and end time.
+      def time_span_intersects_record? start_time, end_time, record
+        if record.end_time == :running
+          return true if start_time <= record.start_time && end_time > record.start_time
+          return false
+        end
+        return false if start_time >= record.end_time
+        return true if start_time >= record.start_time && start_time < record.end_time
+        return false if record.end_time == :running
+        return true if end_time > record.start_time
+        return false
+      end
+
+      # returns the last minute of the day
+      def self.end_of_day time
+        Time.new(time.year, time.month, time.day, 23, 59)
+      end
+    end
+  end
+end

data/lib/tempo/version.rb

@@ -0,0 +1,3 @@
+module Tempo
+  VERSION = '0.1.0'
+end

data/lib/tempo/views/arrange_view.rb

@@ -0,0 +1,27 @@
+module Tempo
+  module Views
+    class << self
+
+      def arrange_parent_child parent, child
+        ViewRecords::Message.new "parent project:"
+        ViewRecords::Project.new parent
+        ViewRecords::Message.new "child project:"
+        ViewRecords::Project.new child
+      end
+
+      def arrange_root project
+        ViewRecords::Message.new "root project:"
+        ViewRecords::Project.new project
+      end
+
+      def arrange_already_root project
+        ViewRecords::Message.new "already a root project:"
+        ViewRecords::Project.new project
+      end
+
+      def arrange_parse_error
+        ViewRecords::Message.new "arrange requires a colon (:) in the arguments", category: :error
+      end
+    end
+  end
+end

data/lib/tempo/views/base.rb

@@ -0,0 +1,82 @@
+module Tempo
+  module Views
+    class << self
+
+      # called in the pre block, pushes relavent options to the reporter
+      def initialize_view_options command, global_options, options
+        view_opts = {}
+        view_opts[:verbose] = global_options[:verbose]
+        view_opts[:id] = global_options[:id]
+        case command
+        when :project, :p
+          if global_options[:verbose]
+            view_opts[:id] = true
+            view_opts[:tags] = true
+            view_opts[:active] = true
+            view_opts[:depth] = true
+          else
+            if options[:list]
+              view_opts[:depth] = true
+              view_opts[:active] = true
+            end
+            view_opts[:tags] = options[:tag] || options[:untag] ? true : false
+            view_opts[:id] = global_options[:id] || options[:id] ? true : false
+          end
+        end
+        Tempo::Views::Reporter.add_options view_opts
+      end
+
+      # DEPRACATE- View is returned in post
+      #
+      # puts each line if output=true
+      # else returns an array of view lines
+      def return_view( view, options={} )
+        output = options.fetch( :output, true )
+
+        if output
+          if view.is_a? String
+            puts view
+          else
+            view.each { |line| puts line }
+          end
+        end
+        view
+      end
+
+      def options_report( command, global_options, options, args )
+        globals_list = "global options: "
+        global_options.each {|k,v| globals_list += "#{k} = #{v}, " if k.kind_of? String and k.length > 1 and !v.nil? }
+        ViewRecords::Message.new globals_list[0..-2], category: :debug
+
+        options_list = "command options: "
+        options.each {|k,v| options_list += "#{k} = #{v}, " if k.kind_of? String and k.length > 1  and !v.nil? }
+        ViewRecords::Message.new options_list[0..-2], category: :debug
+
+
+        ViewRecords::Message.new "command: #{command}", category: :debug
+        ViewRecords::Message.new "args: #{args}", category: :debug
+      end
+
+      def no_items( items, category=:info )
+        ViewRecords::Message.new "no #{items} exist", category: category
+      end
+
+      def no_match_error( items, request, plural=true )
+        match = plural ? "match" : "matches"
+        ViewRecords::Message.new "no #{items} #{match} the request: #{request}", category: :error
+      end
+
+      def already_exists_error( item, request )
+        ViewRecords::Message.new "#{item} '#{request}' already exists", category: :error
+      end
+
+      def checkout_assistance( options={} )
+        ViewRecords::Message.new "checkout command run with no arguments"
+        ViewRecords::Message.new "perhaps you meant one of these?"
+        ViewRecords::Message.new "  tempo checkout --add <new project name>"
+        ViewRecords::Message.new "  tempo checkout <existing project>"
+        ViewRecords::Message.new "run `tempo checkout --help` for more information"
+      end
+    end
+  end
+end

data/lib/tempo/views/formatters/base.rb

@@ -0,0 +1,30 @@
+# Tempo View Formatters are triggered by the View Reporter.
+# The View Reporter sends it's stored view messages to each
+# of it's formatters. It calls the method format_records and
+# passes in the view records.  If the formatter has a class method
+# that handles the type of block passed in, it will process
+# that view record. These class methods take the name "<record type>_block"
+# where record type can be any child class of ViewRecord::Base
+# see the screen formatter for an example of processing blocks.
+
+module Tempo
+  module Views
+    module Formatters
+
+      class Base
+
+        # Here we check if our class methods include a proc block to handle the particular
+        # record type.  See View Records for all possible record types.  See screen formatter
+        # for examples of proc blocks.
+        #
+        def format_records records, options={}
+          @options = options
+          records.each do |record|
+            class_block = "#{record.type}_block"
+            send( class_block, record ) if respond_to? class_block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tempo/views/formatters/screen.rb

@@ -0,0 +1,86 @@
+# Tempo View Formatters are triggered by the View Reporter.
+# The View Reporter sends it's stored view messages to each
+# of it's formatters. It calls the method process records and
+# passes in the view records.  If the formatter has a class method
+# that handles the type of block passed in, it will process
+# that view record. These class methods take the name "<record type>_block"
+# where record type can be any child class of ViewRecord::Base
+# see <TODO> for an example of proc blocks.
+
+module Tempo
+  module Views
+    module Formatters
+
+      class Screen < Tempo::Views::Formatters::Base
+
+        def message_block record
+          record.format do |m|
+            case m.category
+            when :error
+              raise m.message
+            when :info, :debug
+              puts m.message
+            end
+            m.message
+          end
+        end
+
+        def duration_block record
+          record.format do |d|
+            puts "#{ d.hours.to_s }:#{ d.minutes.to_s.rjust(2, '0') }"
+          end
+        end
+
+        # spacer for project titles, active project marked with *
+        def active_indicator( project )
+          indicator = project.current ? "* " : "  "
+        end
+
+        def tag_partial tags, title_length
+          max_length = ViewRecords::Project.max_title_length
+          max_length += ViewRecords::Project.max_depth * 2 if @options[:depth]
+          max_length += 6 if @options[:id]
+          max_length += 2 if @options[:active]
+          spacer = [0, max_length - title_length].max
+          view = "  " + ( " " * spacer )
+          return  view + "tags: none" if tags.length < 1
+
+          view += "tags: ["
+          tags.each { |t| view += "#{t}, "}
+          view[0..-3] + "]"
+        end
+
+        def id_partial id
+          @options[:id] ? "[#{id}] ".rjust(6, ' ') : ""
+        end
+
+        def project_block record
+
+          record.format do |r|
+            @options[:active] = @options.fetch( :active, false )
+            record = r.title
+
+            id = id_partial r.id
+            active = @options[:active] ? active_indicator( r ) : ""
+            depth = @options[:depth] ? "  " * r.depth : ""
+            title = r.title
+            view = "#{id}#{active}#{depth}#{title}"
+            tags = @options[:tags] ? tag_partial( r.tags, view.length ) : ""
+            view += tags
+            puts view
+          end
+        end
+
+        def timerecord_block record
+          record.format do |r|
+            id = id_partial r.id
+            running = r.running ? "*" : " "
+            description = r.description.empty? ? "#{r.project}" : "#{r.project}: #{r.description}"
+            view =  "#{id}#{r.start_time.strftime('%H:%M')} - #{r.end_time.strftime('%H:%M')}#{running} [#{r.duration.format}] #{description}"
+            puts view
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tempo/views/projects_view.rb

@@ -0,0 +1,82 @@
+module Tempo
+  module Views
+    class << self
+
+      def project_view project, depth=0
+        ViewRecords::Project.new project, depth: depth
+      end
+
+      def projects_list_view projects=Tempo::Model::Project.index, parent=:root, depth=0
+        return no_items( "projects" ) if projects.empty?
+
+        Tempo::Model::Project.sort_by_title projects do |projects|
+          projects.each do |p|
+
+            if p.parent == parent
+              project_view p, depth
+
+              if not p.children.empty?
+                next_depth = depth + 1
+                next_parent = p.id
+                child_array = projects_list_view projects, next_parent, next_depth
+              end
+            end
+          end
+        end
+      end
+
+      # list of sorted projects, no hierarchy
+      def projects_flat_list_view projects=Tempo::Model::Project.index
+
+        Tempo::Model::Project.sort_by_title projects do |projects|
+          projects.each do |p|
+            project_view p
+          end
+        end
+      end
+
+      def project_added project
+        ViewRecords::Message.new "added project:"
+        project_view project
+      end
+
+      def project_deleted project
+        ViewRecords::Message.new "deleted project:"
+        project_view project
+      end
+
+      def project_checkout project
+        ViewRecords::Message.new "switched to project:"
+        project_view project
+      end
+
+      def project_already_current project
+        ViewRecords::Message.new "already on project:"
+        project_view project
+      end
+
+      def project_tags project
+        ViewRecords::Message.new "altered project tags:"
+        project_view project
+      end
+
+      def ambiguous_project( matches, command )
+
+        ViewRecords::Message.new "The following projects matched your search:"
+
+        Tempo::Views::Reporter.add_options active: true
+        projects_flat_list_view matches
+
+        ViewRecords::Message.new "please refine your search or use --exact to match args exactly"
+
+        ViewRecords::Message.new "cannot #{command} multiple projects", category: :error
+      end
+
+      def project_assistance
+        ViewRecords::Message.new "you need to set up a new project before running your command"
+        ViewRecords::Message.new "run`tempo project --help` for more information"
+        no_items "projects", :error
+      end
+    end
+  end
+end

data/lib/tempo/views/report_view.rb

@@ -0,0 +1,26 @@
+module Tempo
+  module Views
+    class << self
+
+      def report_records_view options={}
+
+        projects = options.fetch( :projects, Tempo::Model::Project.index )
+        return no_items( "projects" ) if projects.empty?
+
+        time_records = options.fetch( :time_records, Tempo::Model::TimeRecord.days_index )
+        return no_items( "time records" ) if time_records.empty?
+
+        time_records.each do |d_id, days_record|
+
+          day = Tempo::Model::TimeRecord.day_id_to_time d_id
+          ViewRecords::Message.new ""
+          ViewRecords::Message.new day.strftime("Records for %m/%d/%Y:")
+
+          days_record.each do |time_record|
+            time_record_view time_record
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tempo/views/reporter.rb

@@ -0,0 +1,70 @@
+# The Views Reporter is responsible for presenting all the views
+# using the specified formatters. The Reporter is initialized in the GLI pre block,
+# where all additional formats are added.
+# The reporter executes the reports during the post block, displaying all views that
+# have been added by the views.
+#
+# class instance variables:
+#
+# @@formats
+#   an array of formatters, which will be passed the view records on exit
+#   Reporter will always run the error formater first, to check for errors in
+#   the view reports, followed by all added formatters, and then finally the screen
+#   formatter.  This allows additional formatters to add view records, which
+#   will be presented on screen.
+#
+# @@view_records
+#   add view_records
+
+module Tempo
+  module Views
+
+    class Reporter
+      @@formats
+      @@view_records
+      @@options
+
+      class << self
+        attr_accessor :view_records
+
+        def add_format *formats
+          @@formats ||= []
+          formats.each {|format| @@formats << format}
+        end
+
+        def formats
+          @@formats ||= []
+        end
+
+        def options
+          @@options ||= {}
+        end
+
+        def add_options options
+          @@options ||= {}
+          @@options.merge! options
+        end
+
+        def add_view_record record
+          @@view_records ||= []
+
+          if /Views::ViewRecords/.match record.class.name
+            @@view_records << record
+          else
+            raise InvalidViewRecordError
+          end
+        end
+
+        def view_records
+          @@view_records ||= []
+        end
+
+        def report
+          # TODO send records to added formatters
+          screen_formatter = Formatters::Screen.new
+          screen_formatter.format_records view_records, options
+        end
+      end
+    end
+  end
+end

data/lib/tempo/views/time_record_view.rb

@@ -0,0 +1,30 @@
+module Tempo
+  module Views
+    class << self
+
+      def time_record_view time_record
+        ViewRecords::TimeRecord.new time_record
+      end
+
+      def start_time_record_view time_record
+        ViewRecords::Message.new "time record started:"
+        time_record_view time_record
+      end
+
+      def end_time_record_view time_record
+        ViewRecords::Message.new "time record ended:"
+        time_record_view time_record
+      end
+
+      def update_time_record_view time_record
+        ViewRecords::Message.new "time record updated:"
+        time_record_view time_record
+      end
+
+      def delete_time_record_view time_record
+        ViewRecords::Message.new "time record deleted:"
+        time_record_view time_record
+      end
+    end
+  end
+end