redpomo-reloaded 0.0.13

data/lib/redpomo/config.rb

@@ -0,0 +1,26 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/hash'
+require 'yaml'
+
+require 'redpomo/file_cache'
+require 'redpomo/null_cache'
+
+module Redpomo
+  module Config
+
+    mattr_reader :todo_path, :trackers_data, :cache
+
+    @@cache = NullCache
+
+    def self.load_from_yaml(path)
+      config_path = File.expand_path(path)
+      return unless File.exists?(config_path)
+      data = YAML::load_file(config_path)
+
+      @@todo_path = File.expand_path(data["todo"], File.dirname(config_path))
+      @@trackers_data = data["trackers"].symbolize_keys!
+      @@cache = data["cache"] ? FileCache : NullCache
+    end
+
+  end
+end

data/lib/redpomo/entries_printer.rb

@@ -0,0 +1,33 @@
+require 'redpomo/numeric_ext'
+
+module Redpomo
+  class EntriesPrinter
+
+    def self.print(entries)
+      require 'terminal-table'
+      entries.group_by(&:date).each do |date, entries|
+        duration = 0
+        rows = entries.map do |entry|
+          task = entry.to_task
+          duration += entry.duration
+          [
+            task.context,
+            task.project,
+            task.issue,
+            task.text,
+            entry.duration.seconds_in_words,
+            I18n.l(entry.time, format: "%H:%M"),
+            I18n.l(entry.end_time, :format => "%H:%M")
+          ]
+        end
+        puts Terminal::Table.new(
+          title: "#{ I18n.l(date, format: "%A %x") } - #{ duration.seconds_in_words }",
+          headings: [ "Context", "Project", "Issue #", "Description", "Duration", "From", "To" ],
+          rows: rows
+        )
+        puts
+      end
+    end
+
+  end
+end

data/lib/redpomo/entry.rb

@@ -0,0 +1,65 @@
+require 'csv'
+
+module Redpomo
+  class Entry
+
+    def self.load_from_csv(text)
+      csv_rows(text).map do |data|
+        Entry.new(data[0], DateTime.parse(data[1]), data[2].to_i * 60.0) if data.size >= 3
+      end.compact.sort_by { |entry| entry.datetime }
+    end
+
+    def self.csv_rows(text)
+      if text.match /^Export data created/
+        CSV.parse text.split("\n")[4..-1].join("\n")
+      else
+        CSV.parse text
+      end
+    end
+
+    attr_reader :text, :datetime, :duration
+
+    def initialize(text, datetime, duration)
+      @text = text
+      @datetime = datetime
+      @duration = duration
+    end
+
+    def date
+      datetime.to_date
+    end
+
+    def time
+      datetime.to_time
+    end
+
+    def end_time
+      time + duration
+    end
+
+    def same_date?(entry)
+      date == entry.date
+    end
+
+    def same_text?(entry)
+      text == entry.text
+    end
+
+    def to_task
+      Task.new(nil, text)
+    end
+
+    def push!
+      tracker.push_entry!(self) if pushable?
+    end
+
+    def pushable?
+      tracker.present? && tracker.pushable_entry?(self)
+    end
+
+    def tracker
+      to_task.tracker
+    end
+
+  end
+end

data/lib/redpomo/file_cache.rb

@@ -0,0 +1,44 @@
+require 'singleton'
+require 'redpomo/config'
+
+module Redpomo
+  class FileCache
+
+    include Singleton
+    attr_accessor :cache_path
+
+    def self.get(key, &block)
+      instance.get(key, &block)
+    end
+
+    def get(key, &block)
+      return existing_keys[key] if existing_keys.has_key?(key)
+      if block_given?
+        value = block.call
+        set(key, value)
+        value
+      end
+    end
+
+    private
+
+    def initialize
+      @cache_path = File.expand_path("~/.redpomo-cache~")
+    end
+
+    def existing_keys
+      if File.exists?(cache_path)
+        YAML::load_file(cache_path) || {}
+      else
+        {}
+      end
+    end
+
+    def set(key, val)
+      dict = existing_keys
+      dict[key] = val
+      File.open(cache_path, 'w') { |f| f.write(dict.to_yaml) }
+    end
+
+  end
+end

data/lib/redpomo/fuzzy_converter.rb

@@ -0,0 +1,68 @@
+require 'active_support/core_ext/numeric/time'
+require 'redpomo/entry'
+
+module Redpomo
+  class FuzzyConverter
+
+    def self.convert(entries)
+      past_entry = nil
+      consecutive_entries = []
+
+      entries << nil
+
+      result = []
+
+      entries.each do |entry|
+        if past_entry.present?
+          if entry.present? && entry.same_date?(past_entry) && entry.same_text?(past_entry)
+            consecutive_entries << entry
+          else
+            result << self.fuzzy_entry(consecutive_entries, entry)
+            past_entry = entry
+            consecutive_entries = [ entry ]
+          end
+        else
+          past_entry = entry
+          consecutive_entries = [ entry ]
+        end
+      end
+
+      result
+    end
+
+    def self.fuzzy_entry(entries, next_entry)
+      first_entry = entries.first
+      last_entry = entries.last
+      total_duration = first_entry.time - last_entry.end_time
+      duration_till_next_entry = next_entry.time - last_entry.end_time if next_entry.present?
+
+      entry = if next_entry.nil? || duration_till_next_entry > 1.5 * 3600.0
+        duration = last_entry.end_time - first_entry.time
+        duration += 1.5 * 3600.0 if next_entry.present? && next_entry.same_date?(last_entry)
+        Entry.new(first_entry.text, first_entry.datetime, duration)
+      else
+        duration = next_entry.time - first_entry.time
+        entry = Entry.new(first_entry.text, first_entry.datetime, duration)
+      end
+      entry
+    end
+
+    # def strip!
+    #   end_working_day = Time.new(time.year, time.month, time.day, 18, 30, 0, "+00:00")
+    #   start_launch_time = Time.new(time.year, time.month, time.day, 13, 15, 0, "+00:00")
+    #   end_launch_time = Time.new(time.year, time.month, time.day, 14, 15, 0, "+00:00")
+    #   late_night_day = Time.new(time.year, time.month, time.day, 23, 59, 0, "+00:00")
+
+    #   if time < end_working_day && end_time > end_working_day
+    #     @duration = end_working_day - time
+    #   elsif time < start_launch_time && end_time > end_launch_time
+    #     @duration -= 3600.0
+    #   elsif time < start_launch_time && end_time > start_launch_time
+    #     @duration = start_launch_time - time
+    #   elsif time > end_working_day && end_time > late_night_day
+    #     @duration = late_night_day - time
+    #   end
+    # end
+
+  end
+end

data/lib/redpomo/issue.rb

@@ -0,0 +1,38 @@
+module Redpomo
+  class Issue
+
+    attr_accessor :subject, :description
+    attr_accessor :issue_id, :project_id, :tracker
+    attr_accessor :due_date, :priority_id
+
+    def initialize(tracker, data = {})
+      @subject = data["subject"]
+      @issue_id = data["id"]
+      @project_id = data["project_id"]
+      @priority_id = data["priority"]["id"] if data["priority"].present?
+      @due_date = Date.parse(data["due_date"]) if data["due_date"].present?
+      @tracker = tracker
+    end
+
+    def to_task
+      label = []
+      if @priority_id.present?
+        if priority = @tracker.todo_priority(@priority_id)
+          label << priority
+        end
+      end
+      label << @due_date.strftime("%Y-%m-%d") if @due_date.present?
+      label << @subject
+      label << "##{issue_id}"
+      label << "+#{project_id}"
+      label << "@#{tracker.name}"
+      Task.new(nil, label.join(" "))
+    end
+
+    def create!
+      data = tracker.create_issue!(self)
+      @issue_id = data["issue"]["id"]
+    end
+
+  end
+end

data/lib/redpomo/null_cache.rb

@@ -0,0 +1,9 @@
+module Redpomo
+  class NullCache
+
+    def self.get(key, &block)
+      block.call
+    end
+
+  end
+end

data/lib/redpomo/numeric_ext.rb

@@ -0,0 +1,30 @@
+class Numeric
+  module Units
+    Sec        = 1
+    Min        = Sec     * 60
+    Hour       = Min     * 60
+    Day        = Hour    * 24
+    Week       = Day     * 7
+    Month      = Week    * 4
+    Year       = Day     * 365
+    Decade     = Year    * 10
+    Century    = Decade  * 10
+    Millennium = Century * 10
+    Eon        = 1.0/0
+  end
+
+  def seconds_in_words
+    return "0 secs" if self.zero?
+    unit = get_unit(self)
+    unit_difference = self / Units.const_get(unit.capitalize)
+    unit = unit.to_s.downcase + ('s' if self > 1)
+    "#{unit_difference.to_i} #{unit}"
+  end
+
+  private
+  def get_unit(time_difference)
+    Units.constants.each_cons(2) do |con|
+      return con.first if (Units.const_get(con[0])...Units.const_get(con[1])) === time_difference
+    end
+  end
+end

data/lib/redpomo/task.rb

@@ -0,0 +1,103 @@
+require 'active_support/core_ext/module/delegation'
+require 'todo'
+require 'redpomo/tracker'
+
+module Todo
+  class Task
+
+    def self.projects_regex
+       /(?:\s+|^)\+[\w\-]+/
+    end
+
+  end
+end
+
+module Redpomo
+  class Task
+
+    delegate :orig, to: :@task
+    delegate :priority, to: :@task
+    delegate :date, to: :@task
+
+    ISSUES_REGEXP = /(?:\s+|^)#[0-9]+/
+
+    def initialize(list, text)
+      @task = Todo::Task.new(text)
+      @list = list
+    end
+
+    def context
+      @task.contexts.map do |context|
+        context.gsub /^@/, ''
+      end.first
+    end
+
+    def project
+      @task.projects.map do |context|
+        context.gsub /^\+/, ''
+      end.first
+    end
+
+    def issue
+      orig.scan(ISSUES_REGEXP).map(&:strip).map do |issue|
+        issue.gsub(/^#/, '').to_i
+      end.first
+    end
+
+    def text
+      @task.text.gsub(ISSUES_REGEXP, '').strip
+    end
+
+    def close_issue!(message = nil)
+      tracker.close_issue!(issue, message)
+    end
+
+    def done!
+      @list.remove!(self)
+    end
+
+    def add!
+      TaskList.add!(self)
+    end
+
+    def open_in_browser!
+      require 'launchy'
+      Launchy.open(url)
+    end
+
+    def start_pomodoro!
+      require 'applescript'
+      command = 'tell application "Pomodoro" to start "'
+      command << orig
+      command << '"'
+      AppleScript.execute(command)
+    end
+
+    def url
+      return nil unless tracker.present?
+      if issue.present?
+        "#{tracker.base_url}/issues/#{issue}"
+      elsif project.present?
+        "#{tracker.base_url}/projects/#{project}"
+      else
+        "#{tracker.base_url}/projects/#{tracker.default_project}"
+      end
+    end
+
+    def tracker
+      Tracker.find(context) if context.present?
+    end
+
+    def to_issue
+      issue = Issue.new(tracker)
+      issue.subject = text
+      issue.project_id = project
+      issue.due_date = date
+      issue.priority_id = tracker.issue_priority_id(priority) if tracker.present?
+      issue
+    end
+
+  end
+end
+
+

data/lib/redpomo/task_list.rb

@@ -0,0 +1,61 @@
+require 'todo'
+require 'redpomo/task'
+
+module Redpomo
+  class TaskList < Array
+
+    def self.find(task_number)
+      list = TaskList.new(Config.todo_path)
+      list.find(task_number)
+    end
+
+    def self.pull_from_trackers!
+      list = TaskList.new(Config.todo_path)
+      list.pull_from_trackers!
+    end
+
+    def self.add!(task)
+      list = TaskList.new(Config.todo_path)
+      list.add!(task)
+    end
+
+    def initialize(path)
+      @path = path
+      File.read(path).split("\n").each do |line|
+        push Task.new(self, line)
+      end
+    end
+
+    def find(task_number)
+      slice(task_number.to_i - 1)
+    end
+
+    def remove!(task)
+      delete(task)
+      write!
+    end
+
+    def add!(task)
+      push task
+      write!
+    end
+
+    def pull_from_trackers!
+      issue_tasks = Tracker.all.map(&:issues).flatten.map(&:to_task)
+      delete_if do |task|
+        task.tracker.present?
+      end
+      self << issue_tasks
+      self.flatten!
+      write!
+      Redpomo.ui.info "Pulled #{issue_tasks.count} issues."
+    end
+
+    def write!
+      File.open(@path, 'w') do |file|
+        file.write map(&:orig).join("\n") + "\n"
+      end
+    end
+
+  end
+end