logtime 0.0.2

data/lib/app/subcommands/keyword.rb

@@ -0,0 +1,214 @@
+class Keywords < Thor
+    # desc "add <account> <keyword>", "Add a new <keyword> to an <account>"
+    # option :interactive, :type => :boolean, :alias => :i
+    # def add(account, keyword=nil)
+    #     account = Account.find_by(:name => account)
+
+    #     if account.blank?
+    #         say 'no account found', :red
+    #     else
+    #         if options[:interactive]
+    #             say "To stop adding keywords type exit", :cyan
+    #             while true
+    #                 keyword = ask ':'
+    #                 break if keyword == 'exit'
+    #                 if Keyword.new(:keyword => keyword, :account_id => account.id).save
+    #                     say 'added', :green
+    #                 else
+    #                     say 'failed', :red
+    #                 end
+    #             end
+    #         else
+    #             keyword.split(',').each do |k|
+    #                 k = Keyword.new(:keyword => k, :account_id => account.id)
+
+    #                 if k.save
+    #                     say k.keyword + ' keyword added', :green
+    #                 else
+    #                     say 'could not add keyword!', :red
+    #                     error k.errors.first[0].to_s + ' ' + k.errors.first[1]
+    #                 end
+    #             end
+    #         end
+    #     end
+    # end
+
+    # desc "delete <account> <keyword>", "Removes <keyword> on an <account>"
+    # def delete(account, keyword)
+    #     account = Account.search(account)
+
+    #     if account.blank?
+    #         say 'no account found', :red
+    #     else
+    #         keyword.split(',').each do |k|
+    #             k = Keyword.search(k)
+
+    #             if k.blank?
+    #                 say 'could not find keyword!', :red
+    #             else
+    #                 say k.keyword + ' removed', :green if k.destroy
+    #             end
+    #         end
+    #     end
+    # end
+
+    # desc "list", "Lists keywords belonging to an <account>"
+    # option :account
+    # def list(account=nil)
+    #     if account.nil?
+    #         keywords = Keyword.all
+
+    #         table = [['# Keyword', '# Position', '']] # header
+    #         keywords.each do |k|
+    #             stat = k.keyword_statistics.last unless k.keyword_statistics.empty?
+    #             table << [k.keyword, stat.position || '', stat.created_at.pretty ] # row
+    #         end
+
+    #         say ''
+    #         print_table table
+    #         say ''
+    #     else
+    #         account = Account.search(account)
+    #         if account.blank?
+    #             say 'no account found', :red
+    #         elsif account.keywords.empty?
+    #             say 'no keywords exist for that account yet', :red
+    #         else
+    #             table = [['# Keyword', '# Position', '']] # header
+    #             account.keywords.each do |k|
+    #                 stat = k.keyword_statistics.last unless k.keyword_statistics.empty?
+    #                 table << [k.keyword, stat.position || '', stat.created_at.pretty] # row
+    #             end
+
+    #             say ''
+    #             print_table table
+    #             say ''
+    #         end
+    #     end
+    # end
+
+    # desc "stats", "Compare keywords over time"
+    # option :search, :default => 'year', :banner => 'year,month,week,day'
+    # option :length, :type => :numeric, :default => 1
+    # option :engine, :default => :google
+    # def stats(account)
+    #     account = Account.search(account)
+
+    #     if account.blank?
+    #         say 'no account found', :red
+    #     elsif account.keywords.empty?
+    #         say 'no keywords exist for that account yet', :red
+    #     else
+
+    #         table = [['# Keyword', 'n', 'High', 'Low', 'Current', 'Delta']] # header
+    #         searched = 0;
+    #         account.keywords.each do |k|
+    #             stats = KeywordStatistic.send options[:search], k.id, options[:length], options[:engine]
+    #             stats.order(:position)
+
+    #             if !stats.empty?
+    #                 delta = stats.last.position - stats.first.position
+    #                 delta = '' if delta == 0
+    #                 table << [k.keyword, stats.size, stats.last.position, stats.first.position, stats.last.position, delta] # row
+    #                 searched = searched + stats.size
+    #             end
+    #         end
+
+    #         if searched == 0
+    #             say 'these keywords have not been indexed yet', :red
+    #         else
+    #             say ''
+    #             say account.name + ' has ' + searched.to_s + ' recorded positions for ' + account.keywords.size.to_s + ' keywords', :green
+    #             say ''
+    #             print_table table
+    #             say ''
+    #         end
+    #     end
+    # end
+
+    # #desc "import", "imports csv file"
+    # #options :file
+    # #def import(file)
+
+    # #end
+
+    # desc "index", "gets keyword position and saves it for later use"
+    # def index(account)
+    #     account = Account.search(account)
+    #     if account.blank?
+    #         say 'no account found', :red
+    #     else
+    #         table = [['# Keyword', '# Google', '# GoogleUS']] # header
+    #         account.keywords.each do |k|
+    #             # Google
+    #             google = ::Ranking.new(:keyword => k.keyword, :url => account.domain, :limit =>100).from_googleAU
+    #             if !google.blank?
+    #                 KeywordStatistic.new(:keyword_id => k.id, :engine => :google, :position => google).save
+    #                 say '.', :green, false
+    #             else
+    #                 say '.', :red, false
+    #             end
+
+    #             # GoogleUS
+    #             googleUS = ::Ranking.new(:keyword => k.keyword, :url => account.domain, :limit =>100).from_googleUS
+    #             if !googleUS.blank?
+    #                 KeywordStatistic.new(:keyword_id => k.id, :engine => :googleUS, :position => googleUS).save
+    #                 say '.', :green, false
+    #             else
+    #                 say '.', :red, false
+    #             end
+
+    #             # Bing
+    #             # bing = ::Ranking.new(:keyword => k.keyword, :url => account.domain, :limit =>100).from_bingAU
+    #             # if !bing.blank?
+    #             #    KeywordStatistic.new(:keyword_id => k.id, :engine => :bing, :position => bing).save
+    #             #    say '.', :green, false
+    #             # else
+    #             #    say '.', :red, false
+    #             # end
+
+
+    #             # Yahoo
+    #             # yahoo = ::Ranking.new(:keyword => k.keyword, :url => account.domain, :limit =>100).from_yahooAU
+    #             # if !yahoo.blank?
+    #             #    KeywordStatistic.new(:keyword_id => k.id, :engine => :yahoo, :position => yahoo).save
+    #             #    say '.', :green, false
+    #             # else
+    #             #    say '.', :red, false
+    #             # end
+
+    #             table << [k.keyword, google, googleUS]
+    #         end
+
+    #         say ''
+    #         print_table table
+    #         say ''
+    #     end
+    # end
+
+    # desc "export", "export keywords with positions"
+    # option :file
+    # def export(account)
+    #     account = Account.search(account)
+    #     if account.blank?
+    #         say 'no account found', :red
+    #     else
+    #         table = [['# Date', '# Keyword', '# Position']] # header
+
+    #         options[:file] = 'export.csv' unless options.includes? :file
+    #         CSV.open(options[:file], 'w') do |csv|
+    #             account.keywords.each do |keyword|
+    #                 keyword.keyword_statistics.each do |stat|
+    #                     row = [stat.created_at, keyword.keyword, stat.position]
+    #                     table << row
+    #                     csv << row
+    #                 end
+    #             end
+    #         end
+
+    #         say ''
+    #         print_table table
+    #         say ''
+    #     end
+    # end
+end

data/lib/app/subcommands/series.rb

@@ -0,0 +1,58 @@
+module SubCommands
+    class Series < Thor
+        desc "ls", "list series"
+        option :order, :type => :string, :default => "updated_at"
+        def ls
+            series = ::Series.all.order(options[:order].to_sym => :desc)
+
+            series_stats = Statistics.new
+            table = [['#', 'log', 'start', 'end', 'hours']] # header
+            series.each do |s|
+                next if s.log_id.blank?
+
+                start = s.start
+                finish = s.end
+
+                # total time
+                series_stats << timer = start.difference(finish || Time.now)
+
+                start = start.display if start
+                finish = finish.display if finish
+
+                table << [s.id,
+                    Log.find(s.log_id).name,
+                    start, finish || "active",
+                     (timer/3600).round(2).to_s] # row
+            end
+            puts ''
+            print_table table
+            puts ''
+
+            say [series.count.to_s, "series out of", ::Series.count].join(' '), :cyan
+            say [(series_stats.mean/3600).round(2), " hours avg"].join(' '), :cyan
+        end
+
+        desc "rm [ID]", "remove series"
+        option :confirm, :type => :boolean, :default => false, :alias => '-y'
+        def rm(id)
+            if ::Series.where(id: id).count == 0
+                say "Series #" + id.to_s + " not found", :red
+                exit
+            end
+
+            series = ::Series.find(id)
+
+            if !options[:confirm]
+                say "You must --confirm before removing this series", :red
+                exit
+            end
+
+            if !series.finished?
+                series.log.deactivate
+            end
+
+            destroyed = series.destroy
+            say "Series #" + id.to_s + " has been destroyed", :green
+        end
+    end
+end

data/lib/app/subcommands/tags.rb

@@ -0,0 +1,79 @@
+module SubCommands
+    class Tags < Thor
+        desc "add", "create new tag"
+        def add(tag)
+            tag = ::Tag.new(tag: tag.strip)
+
+            if !tag.save
+                tag.errors.full_messages.each do |error|
+                    say error, :red
+                end
+                exit 1
+            end
+
+            say tag.tag + " added!", :green
+        end
+
+        desc "rm", "remove tag"
+        # option :prune, :type => :boolean, :alias => '-p', :default => false not implemented yet
+        def rm(tag)
+            tag = ::Tag.where(tag: tag)
+            p tag.inspect
+        end
+
+        desc "ls", "list tags"
+        option :order, :type => :string, :default => "created_at"
+        def ls
+            tags = ::Tag.order(options[:order].to_sym => :desc)
+
+            table = [['#', '']] # header
+            tags.each do |tag|
+                table << [tag.id, tag.tag] # row
+            end
+            print_table table
+        end
+
+        # desc "add <name> <domain>", "Adds an account that owns a <domain>"
+        # def add(name, domain)
+        #     account = Account.new({
+        #         :name => name,
+        #         :domain => domain
+        #     })
+
+        #     if account.save
+        #         say name + ' added', :green
+        #     else
+        #         say 'could not add account!', :red
+        #         error account.errors.first[0].to_s + ' ' + account.errors.first[1]
+        #     end
+        # end
+
+        # desc "delete <account>", "Deletes <account>"
+        # #option :force, :type => :boolean, :alias => '-f', :default => false
+        # def delete(account)
+        #     account = Account.search(account)
+
+        #     if account.blank?
+        #         say 'no account found', :red
+        #     else
+        #         say 'WARNING ', :red, false
+        #         should_destroy = ask "Are you sure you want to delete " + account.name + "?",  :limited_to => ["y", "n"]
+        #         account.destroy and say account.name + ' destroyed!', :red if should_destroy == 'y'
+        #         say 'no action was taken', :green if should_destroy == 'n'
+        #     end
+        # end
+
+        # desc "list", "Lists all accounts"
+        # def list
+        #     accounts = Account.all
+
+        #     table = [['# Name', '# Domain', '# Keywords']] # header
+        #     accounts.each do |a|
+        #         table << [a.name, a.domain, a.keywords.size] # row
+        #     end
+        #     say ''
+        #     print_table table
+        #     say ''
+        # end
+    end
+end

data/lib/commands/add.rb

@@ -0,0 +1,41 @@
+module Commands
+	module Add
+		def self.included(thor)
+		    thor.class_eval do
+				option :tag, :type => :string, :alias => '-t', default: ""
+				option :estimate, :type => :string, :alias => '-e', default: false
+				option :start, :type => :boolean, default: true
+				desc "add [NAME]", "create new log"
+				def add(name)
+					log = Log.new(name: name).tag(options[:tag])
+
+					# estimate option
+					if options[:estimate]
+						estimation = ChronicDuration.parse(options[:estimate]) if !estimation
+						if !estimation
+							say "could not parse estimation time: " + options[:estimate], :red
+							exit
+						end
+						log.estimation = estimation
+					end
+
+					# save log
+					if !log.save
+						log.errors.full_messages.each do |error|
+							say error, :red
+						end
+						exit
+					end
+
+					# start option
+					if options[:start]
+						log.activate if Series.begin(log_id: log.id)
+						say name.to_s + " added and started", :green
+					else
+						say name.to_s + " added", :green
+					end
+				end
+			end
+		end
+	end
+end

data/lib/commands/list.rb

@@ -0,0 +1,67 @@
+module Commands
+    module List
+        def self.included(thor)
+            thor.class_eval do
+                option :active, :type => :boolean, :default => true
+                #option :tag, :type => :string, :alias => '-t'
+                desc "ls", "list time series"
+                def ls(tag='')
+                    logs = Log.where(active: options[:active]).includes(:series).includes(:tags)
+                    logs = logs.tagged(tag) if !tag.blank?
+
+                    creep_stats = Statistics.new
+                    table = [['#', 'name', 'active', 'tags', 'series', 'time', 'estimate', 'creep %']] # header
+                    logs.each do |log|
+
+                        # tags
+                        tags = log.tags.map do |t|
+                            t.tag
+                        end
+
+                        # only show logs with tag, if selected
+                        # if !tag.blank?
+                        #     next unless tags.include? tag
+                        # end
+
+                        # active text
+                        active = "ACTIVE" if log.active == "t"
+
+                        # total counter
+                        total_time = (log.total/3600).round(2)
+
+                        # estimation creep
+                        if log.estimation
+                            creep = (total_time/log.estimation)*100
+                            creep_stats << creep
+                            creep = creep.round(3)
+                            estimation = (log.estimation/3600).round(3) # log estimation to hours
+                        end
+
+                        table << [log.id,
+                            log.name,
+                            active || '',
+                            tags,
+                            log.series.count || '',
+                            total_time || '',
+                            estimation || '',
+                            creep || '']
+                    end
+
+                    if logs.count == 0
+                        puts ""
+                        say "No logs found", :red
+                        puts ""
+                        exit
+                    else
+                        puts ""
+                        print_table table
+                        puts ""
+                        say [logs.count.to_s, "logs out of", Log.count.to_s].join(' '), :cyan
+                        say [creep_stats.count, "estimations"].join(' '), :cyan
+                        say [creep_stats.mean.round(2), "percent mean creep"].join(' '), :cyan
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/commands/start.rb

@@ -0,0 +1,28 @@
+module Commands
+	module Start
+		def self.included(thor)
+		    thor.class_eval do
+				desc "start [NAME]", "start new timer"
+				def start(name)
+
+					# not found
+					if Log.where(name: name).count == 0
+						say name.to_s + " not found", :red
+						exit
+					end
+
+					log = Log.find_by(name: name)
+
+					# already active?
+					if log.active == "t"
+						say name.to_s + " already active", :red
+						exit
+					end
+
+					# begin new series, activate log
+					series = Series.begin(log_id: log.id) and log.activate
+				end
+			end
+		end
+	end
+end

data/lib/commands/stop.rb

@@ -0,0 +1,29 @@
+module Commands
+    module Stop
+        def self.included(thor)
+            thor.class_eval do
+                desc "stop [NAME]", "stop active timer"
+                def stop(name)
+                    if Log.where(name: name).count == 0
+                        say name.to_s + " not found", :red
+                        exit
+                    end
+
+                    log = Log.find_by(name: name)
+                    if log.active == "f"
+                        say name.to_s + " not active", :red
+                        exit
+                    end
+
+                    series = log.series.last
+                    if series.stop and log.deactivate
+                        say name + " stopped!", :green
+
+                        # this_series = log.series.last
+                        say (series.total/3600).round(3).to_s + " hours out of " + (log.total/3600).round(3).to_s, :cyan
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/commands/version.rb

@@ -0,0 +1,12 @@
+module Commands
+	module Version
+		def self.included(thor)
+		    thor.class_eval do
+				desc "version", ""
+				def version
+					io.read 'VERSION'
+				end
+			end
+		end
+	end
+end

data/lib/helpers/estimate.rb

@@ -0,0 +1,13 @@
+module EstimateHelper
+	class Estimate
+		def initialize(time=0)
+			@time = time
+		end
+
+		def difference(estimate=false)
+			if !estimate
+				estimate = Time.now
+			end
+		end
+	end
+end

data/lib/helpers/statistics.rb

@@ -0,0 +1,48 @@
+module StatisticsHelper
+	class Series < Array
+		def sum
+			inject(0.0) { |result, el| result + el }
+		end
+
+		def mean
+			return 0 if size == 0
+			avg = sum / size
+		end
+
+		alias :average :mean
+		alias :avg :mean
+	end
+
+	class Statistics
+		def initialize
+			@statistics = Series.new
+		end
+
+		def add(statistic)
+			@statistics << statistic
+		end
+
+		def count
+			@statistics.count
+		end
+
+		def mean
+			@statistics.mean
+		end
+
+		def <<(statistic)
+			add(statistic)
+		end
+
+		def +(statistics)
+			@statistics + statistics.data
+		end
+
+		def data
+			@statistics
+		end
+
+		alias :average :mean
+		alias :avg :mean
+	end
+end

data/lib/helpers/time_difference.rb

@@ -0,0 +1,20 @@
+module TimeDifferenceHelper
+	def difference(relative)
+		if relative > self
+			difference = relative - self
+		else
+			difference = self - relative
+		end
+
+		# hours = difference / 3600
+		# difference -= hours * 3600
+		# minutes = difference / 60
+		# difference -= minutes * 60
+		# seconds = difference
+		# "#{hours.to_s.rjust(2, '0')}:#{minutes.to_s.rjust(2, '0')}:#{seconds.to_s.rjust(2, '0')}"
+
+		# hours = difference / 3600
+		return difference
+	end
+	Time.send :include, self
+end

data/lib/helpers/time_display.rb

@@ -0,0 +1,5 @@
+module TimeDisplayHelper
+	def display_time(time)
+		time.strftime("%H:%M:%S %d/%m/%y") if time.is_a? Time
+	end
+end

data/lib/helpers/time_to_words.rb

@@ -0,0 +1,33 @@
+module TimeToWordsHelper
+    def time_to_words_ago(time)
+        a = (Time.now-time).to_i
+        case a
+            when 0 then 'just now'
+            when 1 then 'a second ago'
+            when 2..59 then a.to_s+' seconds ago'
+            when 60..119 then 'a minute ago' # 120 = 2 minutes
+            when 120..3540 then (a/60).to_i.to_s+' minutes ago'
+            when 3541..7100 then 'an hour ago' # 3600 = 1 hour
+            when 7101..82800 then ((a+99)/3600).to_i.to_s+' hours ago'
+            when 82801..172000 then 'a day ago' # 86400 = 1 day
+            when 172001..518400 then ((a+800)/(60*60*24)).to_i.to_s+' days ago'
+            when 518400..1036800 then 'a week ago'
+            else ((a+180000)/(60*60*24*7)).to_i.to_s+' weeks ago'
+        end
+    end
+
+    def time_to_words(seconds)
+        seconds
+        case a
+            when 0..60 then 'seconds'
+            when 60..69 then 'minute'
+            when 70..3600 then 'minutes'
+            when 3600..7199 then 'day'
+            when 7200..107999 then 'days' # 3600 = 1 hour
+            when 108000..215999 then 'month'
+            when 216000..1296000 then 'months'
+            when 1296000..1296000 then 'year'
+            else 'years'
+        end
+    end
+end