clockout 0.3.2 → 0.4

data/bin/clock

@@ -177,10 +177,11 @@ else
     end
     
     clock = Clockout.new(path, user)
+    printer = Printer.new(clock)
 
     if (opts[:estimations])
-        clock.print_estimations
+        printer.print_estimations
     else
-        clock.print_chart(opts[:condensed])
+        printer.print_chart(opts[:condensed])
     end
 end

data/lib/clockout.rb

@@ -1,131 +1,45 @@
 require 'grit'
-require 'time'
 require 'yaml'
 
+require 'printer'
+require 'record'
+
 COLS = 80
 DAY_FORMAT = '%B %e, %Y'
 
-class Commit
-    attr_accessor :message, :minutes, :date, :diffs, :sha, :clocked_in, :clocked_out, :addition, :overriden, :author, :estimated
-    def initialize(commit = nil)
-        @addition = 0
-        if commit
-            @author = commit.author.email
-            @date = commit.committed_date
-            @message = commit.message.gsub("\n",' ')
-            @sha = commit.id
-        end
-    end
-end
-
-class Clock
-    attr_accessor :in, :out, :date, :author
-    def initialize(type, date, auth)
-        @in = (type == :in)
-        @out = (type == :out)
-        @date = date
-        @author = auth
-    end
-end
-
-def puts_error(str)
-    puts "Error: ".red + str
-end
+class Clockout
+    attr_accessor :blocks, :time_per_day
 
-def align(strings, cols = COLS, sep = " ")
-    ret = ""
-    size = 0
-    strings.each do |string, method|
-        ultimate = (string == strings.keys[-1])
-        penultimate = (string == strings.keys[-2])
-
-        out = string
-        out += " " unless (ultimate || penultimate)
-
-        if ultimate
-            # Add seperator
-            cols_left = cols - size - out.length
-            ret += sep*cols_left if cols_left > 0
-        elsif penultimate
-            last = strings.keys.last.length
-            max_len = cols - size - last - 1
-            if string.length > max_len
-                # Truncate
-                out = string[0..max_len-5].strip + "... "
-            end
+    def commits_to_records(grit_commits)
+        my_files = eval($opts[:my_files])
+        not_my_files = eval($opts[:not_my_files] || "")
+        grit_commits.map do |commit| 
+            c = Commit.new(commit) 
+            c.calculate_diffs(my_files, not_my_files)
+            c
         end
-
-        # Apply color & print
-        ret += method.to_proc.call(out)
-
-        size += out.length
     end
 
-    ret
-end
-
-class String
-    def colorize(color)
-        "\e[0;#{color};49m#{self}\e[0m"
-    end
-
-    def red() colorize(31) end
-    def yellow() colorize(33) end
-    def magenta() colorize(35) end
-    def light_blue() colorize(94) end
-end
-
-class Numeric
-    def as_time(type = nil, min_s = " min", hr_s = " hrs")
-        type = (self < 60) ? :minutes : :hours if !type
-        if type == :minutes
-            "#{self.round(0)}#{min_s}"
-        else
-            "#{(self/60.0).round(2)}#{hr_s}"
+    def clocks_to_records(clocks, in_out)
+        clocks.map do |c| 
+            Clock.new(in_out, c.first[0], c.first[1])
         end
     end
-end
 
-class Clockout
-    def diffs(commit)
-        plus, minus = 0, 0
-
-        commit.stats.to_diffstat.each do |diff_stat|
-            my_files = $opts[:my_files]
-            not_my_files = $opts[:not_my_files]
-            should_include = (diff_stat.filename =~ eval(my_files))
-            should_ignore = not_my_files && (diff_stat.filename =~ eval(not_my_files))
-            if should_include && !should_ignore
-                plus += diff_stat.additions
-                minus += diff_stat.deletions
+    def try_overriding_record(record)
+        overrides = $opts[:overrides]
+        overrides.each do |k, v|
+            if record.sha.start_with? k
+                record.minutes = v
+                record.overriden = true
+                return true
             end
-        end
+        end if overrides
 
-        # Weight deletions half as much, since they are typically
-        # faster to do & also are 1:1 with additions when changing a line
-        plus+minus/2
+        false
     end
 
-    def prepare_data(commits_in, author)
-        clockins = $opts[:in] || {}
-        clockouts = $opts[:out] || {}
-
-        # Convert clock-in/-outs into Clock objs & commits into Commit objs
-        clocks = []
-        clockins.each { |c| clocks << Clock.new(:in, c.first[0], c.first[1]) }
-        clockouts.each { |c| clocks << Clock.new(:out, c.first[0], c.first[1]) }
-        commits_in.map! do |commit| 
-            c = Commit.new(commit) 
-            c.diffs = diffs(commit)
-            c
-        end
-
-        # Merge & sort everything by date
-        data = (commits_in + clocks).sort { |a,b| a.date <=> b.date }
-
-        # If author is specified, delete everything not by that author
-        data.delete_if { |c| c.author != author } if author
-
+    def run(data)
         blocks = []
         total_diffs, total_mins = 0, 0
 
@@ -193,25 +107,18 @@ class Clockout
                 end
             else
                 # See if this commit was overriden in the config file
-                overrides = $opts[:overrides]
-                overrides.each do |k, v|
-                    if curr_c.sha.start_with? k
-                        curr_c.minutes = v
-                        curr_c.overriden = true
-                        break
-                    end
-                end if overrides
-
-                # If we're ignoring initial & it's initial, set minutes to 0
-                if $opts[:ignore_initial] && !prev_c
-                    curr_c.minutes = 0
-                elsif !curr_c.overriden && prev_c
-                    curr_c.clocked_in = true if prev_c.class == Clock && prev_c.in
-                    # If it added successfully into a block (or was clocked in), we can calculate based on last commit
-                    if add_commit.call(curr_c) || curr_c.clocked_in
-                        curr_c.minutes = (curr_c.date - prev_c.date)/60.0 # clock or commit, doesn't matter
+                if !try_overriding_record(curr_c)
+                    # Otherwise, if we're ignoring initial & it's initial, set minutes to 0
+                    if $opts[:ignore_initial] && !prev_c
+                        curr_c.minutes = 0
+                    else
+                        curr_c.clocked_in = true if prev_c && prev_c.class == Clock && prev_c.in
+                        # If it added successfully into a block (or was clocked in), we can calculate based on last commit
+                        if add_commit.call(curr_c) || curr_c.clocked_in
+                            curr_c.minutes = (curr_c.date - prev_c.date)/60.0 # clock or commit, doesn't matter
+                        end
+                        # Otherwise, we'll do an estimation later, once we have more data
                     end
-                    # Otherwise, we'll do an estimation later, once we have more data
                 end
 
                 if curr_c.minutes
@@ -246,82 +153,21 @@ class Clockout
         blocks
     end
 
-    def print_chart(condensed)
-        cols = condensed ? 30 : COLS
-        total_sum = 0
-        current_day = nil
-        @blocks.each do |block|
-            date = block.first.date.strftime(DAY_FORMAT)
-            if date != current_day
-                puts if (!condensed && current_day)
-
-                current_day = date
-
-                sum = @time_per_day[date]
-                total_sum += sum
-
-                puts align({date => :magenta, sum.as_time(:hours) => :red}, cols, ".".magenta)
-            end
-
-            print_timeline(block) if (!condensed)
-        end
-
-        puts align({"-"*10 => :magenta}, cols)
-        puts align({total_sum.as_time(:hours) => :red}, cols)
-    end
-
-    def print_timeline(block)
-        # subtract from the time it took for first commit
-        time = (block.first.date - block.first.minutes*60).strftime('%l:%M %p')+":  "
-        print time.yellow
-
-        char_count = time.length
-
-        block.each do |commit|
-            c_mins = commit.minutes.as_time(nil, "m", "h")
-            c_mins = "*#{c_mins}" if commit.clocked_in
-            c_mins += "*" if commit.clocked_out
-
-            seperator = " | "
-        
-            add = c_mins.length+seperator.length
-            if char_count + add > COLS-5
-                puts
-                char_count = time.length # indent by the length of the time label on left
-                print " "*char_count
-            end
-
-            char_count += add
-
-            # Blue for clockin/out commits
-            print c_mins+(commit.message ? seperator.red : seperator.light_blue)
-        end
-        puts
-    end
-
-    def print_estimations
-        sum = 0
-        estimations = []
-        @blocks.each do |block|
-            estimations << block.first if block.first.estimated
-        end
+    def prepare_blocks(commits_in, author)
+        clockins = $opts[:in] || {}
+        clockouts = $opts[:out] || {}
 
-        if estimations.empty?
-            puts "No estimations made."
-        else
-            estimations.each do |c|
-                date = c.date.strftime('%b %e')+":"
-                sha = c.sha[0..7]
-                time = c.minutes.as_time
+        # Convert clock-in/-outs into Clock objs & commits into Commit objs
+        clocks = clocks_to_records(clockins, :in) + clocks_to_records(clockouts, :out)
+        commits = commits_to_records(commits_in)
 
-                puts align({date => :yellow, sha => :red, c.message => :to_s, time => :light_blue})
+        # Merge & sort everything by date
+        data = (commits + clocks).sort { |a,b| a.date <=> b.date }
 
-                sum += c.minutes
-            end
+        # If author is specified, delete everything not by that author
+        data.delete_if { |c| c.author != author } if author
 
-            puts align({"-"*10 => :light_blue})
-            puts align({sum.as_time(:hours) => :light_blue})
-        end
+        @blocks = run(data)
     end
 
     def self.get_repo(path, original_path = nil)
@@ -372,22 +218,25 @@ class Clockout
         root_path
     end
 
-    def initialize(path, author = nil)
-        repo, root_path = Clockout.get_repo(path) || exit
+    def initialize(path = nil, author = nil)
+        @time_per_day = Hash.new(0)
 
         # Default options
         $opts = {time_cutoff:120, my_files:"/.*/", estimation_factor:1.0}
 
-        # Parse config options
-        clock_opts = Clockout.parse_clockfile(Clockout.clock_path(root_path))
+        if path
+            repo, root_path = Clockout.get_repo(path) || exit
 
-        # Merge with config override options
-        $opts.merge!(clock_opts) if clock_opts
+            # Parse config options
+            clock_opts = Clockout.parse_clockfile(Clockout.clock_path(root_path))
 
-        commits = repo.commits('master', 500)
-        commits.reverse!
+            # Merge with config override options
+            $opts.merge!(clock_opts) if clock_opts
 
-        @time_per_day = Hash.new(0)
-        @blocks = prepare_data(commits, author)
+            commits = repo.commits('master', 500)
+            commits.reverse!
+    
+            prepare_blocks(commits, author)
+        end
     end
 end

data/lib/printer.rb

@@ -0,0 +1,141 @@
+def puts_error(str)
+    puts "Error: ".red + str
+end
+
+class String
+    def colorize(color)
+        "\e[0;#{color};49m#{self}\e[0m"
+    end
+
+    def red() colorize(31) end
+    def yellow() colorize(33) end
+    def magenta() colorize(35) end
+    def light_blue() colorize(94) end
+end
+
+class Numeric
+    def as_time(type = nil, min_s = " min", hr_s = " hrs")
+        type = (self < 60) ? :minutes : :hours if !type
+        if type == :minutes
+            "#{self.round(0)}#{min_s}"
+        else
+            "#{(self/60.0).round(2)}#{hr_s}"
+        end
+    end
+end
+
+class Printer
+	def initialize(clockout)
+		@clockout = clockout
+	end
+
+	def align(strings, cols = COLS, sep = " ")
+	    ret = ""
+	    size = 0
+	    strings.each do |string, method|
+	        ultimate = (string == strings.keys[-1])
+	        penultimate = (string == strings.keys[-2])
+
+	        out = string
+	        out += " " unless (ultimate || penultimate)
+
+	        if ultimate
+	            # Add seperator
+	            cols_left = cols - size - out.length
+	            ret += sep*cols_left if cols_left > 0
+	        elsif penultimate
+	            last = strings.keys.last.length
+	            max_len = cols - size - last - 1
+	            if string.length > max_len
+	                # Truncate
+	                out = string[0..max_len-5].strip + "... "
+	            end
+	        end
+
+	        # Apply color & print
+	        ret += method.to_proc.call(out)
+
+	        size += out.length
+	    end
+
+	    ret
+	end
+
+	def print_chart(condensed)
+        cols = condensed ? 30 : COLS
+        total_sum = 0
+        current_day = nil
+        @clockout.blocks.each do |block|
+            date = block.first.date.strftime(DAY_FORMAT)
+            if date != current_day
+                puts if (!condensed && current_day)
+
+                current_day = date
+
+                sum = @clockout.time_per_day[date]
+                total_sum += sum
+
+                puts align({date => :magenta, sum.as_time(:hours) => :red}, cols, ".".magenta)
+            end
+
+            print_timeline(block) if (!condensed)
+        end
+
+        puts align({"-"*10 => :magenta}, cols)
+        puts align({total_sum.as_time(:hours) => :red}, cols)
+    end
+
+    def print_timeline(block)
+        # subtract from the time it took for first commit
+        time = (block.first.date - block.first.minutes*60).strftime('%l:%M %p')+":  "
+        print time.yellow
+
+        char_count = time.length
+
+        block.each do |commit|
+            c_mins = commit.minutes.as_time(nil, "m", "h")
+            c_mins = "*#{c_mins}" if commit.clocked_in
+            c_mins += "*" if commit.clocked_out
+
+            seperator = " | "
+        
+            add = c_mins.length+seperator.length
+            if char_count + add > COLS-5
+                puts
+                char_count = time.length # indent by the length of the time label on left
+                print " "*char_count
+            end
+
+            char_count += add
+
+            # Blue for clockin/out commits
+            print c_mins+(commit.message ? seperator.red : seperator.light_blue)
+        end
+        puts
+    end
+
+    def print_estimations
+        sum = 0
+        estimations = []
+        @clockout.blocks.each do |block|
+            estimations << block.first if block.first.estimated
+        end
+
+        if estimations.empty?
+            puts "No estimations made."
+        else
+            estimations.each do |c|
+                date = c.date.strftime('%b %e')+":"
+                sha = c.sha[0..7]
+                time = c.minutes.as_time
+
+                puts align({date => :yellow, sha => :red, c.message => :to_s, time => :light_blue})
+
+                sum += c.minutes
+            end
+
+            puts align({"-"*10 => :light_blue})
+            puts align({sum.as_time(:hours) => :light_blue})
+        end
+    end
+end

data/lib/record.rb

@@ -0,0 +1,54 @@
+class Record
+    attr_accessor :date, :author
+end
+
+class Commit < Record
+    # From Grit::Commit object
+    attr_accessor :message, :stats, :diffs, :sha
+    # Time calc
+    attr_accessor :minutes, :addition, :overriden, :estimated
+    # Whether it's been padded by a clock in/out
+    attr_accessor :clocked_in, :clocked_out
+    
+    def initialize(commit = nil, date = nil)
+        @addition = 0
+        @date = date
+        if commit
+            @author = commit.author.email
+            @date = commit.committed_date
+            @message = commit.message.gsub("\n",' ')
+            @sha = commit.id
+            @stats = commit.stats
+        end
+    end
+
+    def calculate_diffs(my_files, not_my_files)
+        return @diffs if @diffs
+
+        plus, minus = 0, 0
+
+        @stats.to_diffstat.each do |diff_stat|
+            should_include = (diff_stat.filename =~ my_files)
+            should_ignore = not_my_files && (diff_stat.filename =~ not_my_files)
+            if should_include && !should_ignore
+                plus += diff_stat.additions
+                minus += diff_stat.deletions
+            end
+        end
+
+        # Weight deletions half as much, since they are typically
+        # faster to do & also are 1:1 with additions when changing a line
+        @diffs = plus+minus/2
+    end
+end
+
+class Clock < Record
+    # Whether its in or out
+    attr_accessor :in, :out
+    def initialize(type, date, auth)
+        @in = (type == :in)
+        @out = (type == :out)
+        @date = date
+        @author = auth
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockout
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: '0.4'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-22 00:00:00.000000000 Z
+date: 2013-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grit
@@ -27,7 +27,23 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: An sort of extension to Git to support clocking hours worked on a project.
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Sort of an extension to Git to support clocking hours worked on a project.
 email:
 - danhassin@mac.com
 executables:
@@ -35,7 +51,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/record.rb
 - lib/clockout.rb
+- lib/printer.rb
 - !binary |-
   YmluL2Nsb2Nr
 homepage: http://rubygems.org/gems/clockout