wlog 1.0.0 → 1.0.5

data/lib/wlog/domain/helpers.rb

@@ -37,6 +37,10 @@ class Helpers
       FileUtils.mkdir_p DataDirectory
     end
   nil end
+
+  # Check if the application directory exists. If it does not, it's a first
+  # time system run.
+  def self.first_setup?; !File.exists? TaintFile end
 end
 end # module Wlog
 

data/lib/wlog/domain/issue.rb

@@ -1,6 +1,7 @@
 require 'wlog/db_registry'
 require 'wlog/domain/sql_modules/issue_sql'
 require 'wlog/domain/log_entry'
+require 'wlog/domain/timelog_helper'
 
 module Wlog
 # This aggregates log entries. The total time spent on this issue is
@@ -9,66 +10,99 @@ module Wlog
 class Issue
   include IssueSql
 
-  def initialize
+  def initialize(db_handle)
     @reported_date = Time.now
     @log_entries   = Array.new
-    @status        = 0
+    @status = @seconds = 0
+    @db = db_handle
   end
 
-  def self.find(id)
-    issue = Issue.new
-    ret = DbRegistry.instance.execute(SelectSql, id).first
-    issue.quick_assign! ret
+  def self.find(db, id)
+    issue = Issue.new(db)
+    ret = db.execute(SelectSql, id).first
+    if ret.nil? || ret.empty?
+      issue = nil
+    else 
+      issue.quick_assign! ret
+    end
   issue end
 
-  def self.find_all
+  def self.find_all(db)
+    self.generic_find_all(db, SelectAllSql)
+  end
+
+  def self.find_all_finished(db)
+    self.generic_find_all(db, SelectFinishedSql)
+  end
+
+  def self.find_in_time_range(db, from, to)
     arr = Array.new
-    DbRegistry.instance.execute(SelectAllSql).each do |row|
-      issue = Issue.new
-      issue.quick_assign! row
-      arr.push issue
+    db.execute(SelectTimeRange, from, to).each do |row|
+      tmp = Issue.new(@db)
+      tmp.quick_assign!(row)
+      arr.push tmp
     end
   arr end
 
-  def self.delete(id); DbRegistry.instance.execute(DeleteSql, id) end
+  def self.delete_by_id(db, id); db.execute(DeleteSql, id) end
 
+  # inserts the entry into the database if it has not been stored before.
   def insert
-    DbRegistry.instance
-      .execute(InsertSql, @description, 
+    unless @id
+      @db.execute(InsertSql, @description, 
         @reported_date.to_i, @due_date.to_i, @status)
+      @id = @db.last_row_from(TableName).first[0]
+    end
   end
 
-  def delete; DbRegistry.instance.execute(DeleteSql, @id) end
+  def delete; @db.execute(DeleteSql, @id) end
 
   def update
-    DbRegistry.instance
-      .execute(UpdateSql, @description, @reported_date.to_i, 
-               @due_date.to_i, @status, @id)
+    @db.execute(UpdateSql, @description, @reported_date.to_i, 
+                @due_date.to_i, @status, @seconds, @id)
   end
 
   # Add a log entry object to the issue
+  # TODO this does nothing / used for nothing yet
   def add_log_entry(le)
     @log_entries.push le
   end
 
   def quick_assign!(row)
-    @id, @description, @reported_date, @due_date , @status =\
-      row[0], row[1], Time.at(row[2]), Time.at(row[3]), row[4]
+    @id, @description, @reported_date, @due_date, @status, @seconds =\
+      row[0], row[1], Time.at(row[2]), Time.at(row[3]), row[4], row[5] || 0
   nil end
 
+  # Log the seconds into the issue
+  def log_time(seconds)
+    @seconds += seconds
+    update
+  end
+
   def to_s
     "+ Issue ##{@id}#{$/}"\
     "  - Reported : #{@reported_date}#{$/}"\
     "  - Due      : #{@due_date}#{$/}"\
     "  - Entries  : #{@log_entries.count}#{$/}"\
-    "  - Status   : "\
+    "  - Status   : #{Statuses[@status]}#{$/}"\
+    "  - Time     : #{TimelogHelper.time_to_s(@seconds)}#{$/}"\
     "#{$/}"\
-    "  - #{@description}"
+    "  - #{@description}#{$/}"
   end
 
+  # Mark issue as started
   def mark_started!; @status = 0 end
+  
+  # Mark the issue as working
   def mark_working!; @status = 1 end
+  
+  # Mark the issue as finished
   def mark_finished!; @status = 2 end
+
+  # Archive the issue
+  def archive!; @status = 3 end
+
+  # Get the status as a string
   def status_s; Statuses[@status] end
 
   # [String] Description of the issue at hand
@@ -91,9 +125,29 @@ class Issue
   # 2 for finished)
   attr_accessor :status
 
+  # The seconds that you have wasted your life on in order to get something
+  # done
+  attr_accessor :seconds
+
+  # The database handle for this AR
+  attr_accessor :db
+
 private
 
-  Statuses = {0 => "new", 1 => "started work", 2 => "finished"}
+  Statuses = {
+    0 => "new", 1 => "started work", 
+    2 => "finished", 3 => "archived"}
+
+private_class_method
+
+  def self.generic_find_all(db, sql)
+    arr = Array.new
+    db.execute(sql).each do |row|
+      issue = Issue.new(db)
+      issue.quick_assign! row
+      arr.push issue
+    end
+  arr end
 
 end # class  Issue
 end # module Wlog

data/lib/wlog/domain/key_value.rb

@@ -12,44 +12,48 @@ module Wlog
 class KeyValue
   include KeyValueSql
 
+  def initialize(db_handle)
+    @db = db_handle
+  end
+
   # Insert a key in the storage. If exists, replace the value with new one
   # @return nil
-  def self.put!(key, value)
-    if self.get(key).nil?
-      self.create!(key, value)
+  def put!(key, value)
+    if get(key).nil?
+      create!(key, value)
     else 
-      self.update(key, value)
+      update(key, value)
     end
-  nil end
+  end
 
   # Get a certain value by key
   # @return the value given the key. nil if not found
-  def self.get(key)
-    ret = DbRegistry.instance.execute(Select, key)
-    ret = ret.empty? ? nil : ret.first
+  def get(key)
+    ret = @db.execute(Select, key)
+    ret = ret.empty? ? nil : ret.first[1]
   end
 
   # destroy by key
-  def self.destroy!(key)
-    DbRegistry.instance.execute(DeleteSql, key)
+  def destroy!(key)
+    @db.execute(DeleteSql, key)
   nil end
 
+  # The db handle
+  attr_accessor :db
+
 private
 
   # We want to provide a simple interface to the kv store, so the user should
   # not really care about updates
-  def self.update(key,value)
-    DbRegistry.instance.execute(UpdateSql, value, key)
+  def update(key,value)
+    @db.execute(UpdateSql, value, key)
   end
 
   # Create a pair... ;)
-  def self.create!(key, value)
-    DbRegistry.instance.execute(InsertSql, key, value)
+  def create!(key, value)
+    @db.execute(InsertSql, key, value)
   end
 
-  class << self
-    private :new, :allocate
-  end
 end 
 end # module Wlog
 

data/lib/wlog/domain/log_entry.rb

@@ -9,41 +9,45 @@ module Wlog
 class LogEntry
   include LogEntrySql
 
-  def initialize
+  def initialize(db_handle)
     @date = Time.new
+    @db = db_handle
   end
 
-  def self.find(id)
-    row = DbRegistry.instance.execute(Select,id).first
-    le = LogEntry.new
-    le.quick_assign!(row[0], row[1], Time.at(row[2]))
+  def self.find(db, id)
+    row = db.execute(Select,id).first
+    le = nil
+    if row && !row.empty?
+    le = LogEntry.new(db)
+    le.quick_assign!(row[0], row[1], Time.at(row[2]), row[3])
+    end
   le end
 
-  def self.find_all
-    self.generic_find_all(SelectAll)
+  def self.find_all(db)
+    self.generic_find_all(db, SelectAll)
   end
 
-  def self.find_all_by_issue_id(id)
-    self.generic_find_all(SelectAllByIssue, id)
+  def self.find_all_by_issue_id(db, id)
+    self.generic_find_all(db, SelectAllByIssue, id)
   end
 
   # Delete a log entry with a given id. 
   # @example Simple usage
   #   # Since this is a class method:
   #   LogEntry.delete(12)
-  def self.delete(id)
-    DbRegistry.instance.execute(DeleteSql,id)
+  def self.delete_by_id(db, id)
+    db.execute(DeleteSql,id)
   end
 
   # update the entry
   def update
-    DbRegistry.instance.execute(UpdateSql,@description,@id)
+    @db.execute(UpdateSql,@description,@id)
   end
 
   # Search by string to find a matching description with 'LIKE'.
-  def self.search_descriptions(term)
+  def self.search_descriptions(db, term)
     all = Array.new
-    DbRegistry.instance.execute(SelectDescriptionLike,"%#{term}%").each do |row|
+    db.execute(SelectDescriptionLike,"%#{term}%").each do |row|
       le = LogEntry.new
       le.quick_assign!(row[0], row[1], Time.at(row[2]))
       all.push le
@@ -51,12 +55,19 @@ class LogEntry
   all end
 
   def insert
-    DbRegistry.instance.execute(InsertSql, @description, @date.to_i, @issue_id)
+    raise 'Need issue_id' unless @issue_id
+    unless @id
+      @db.execute(InsertSql, @description, @date.to_i, @issue_id)
+      @id = @db.last_row_from(TableName).first[0].to_i
+    end
   end
 
   # Delete the loaded log entry currently in memory, by passing its id
   def delete
-    self.delete(self.id)
+    if @id
+      LogEntry.delete_by_id(@db, @id)
+      @id = nil
+    end
   end
 
   def quick_assign!(id,desc,date,issue_id)
@@ -66,8 +77,8 @@ class LogEntry
   # Print things nicely formmated no more than 80 cars (well, unless you stick
   # the time in the end which is not counted for).
   def to_s
-    str    = "[#{id}] "
-    tmp    = @description + " [#{@date.strftime("%H:%M:%S")}]"
+    str    = "[#{@id}] "
+    tmp    = "#{@description} [#{@date.strftime("%H:%M:%S")}]"
     desc   = Helpers.break_string(tmp,80)
     indent = " " * (id.to_s.split('').count + 5)
     desc.gsub!(/#{$/}/, "#{$/}#{indent}")
@@ -86,11 +97,14 @@ class LogEntry
   # The issue id (parent of this log entry)
   attr_accessor :issue_id
  
+  # The db handle 
+  attr_accessor :db
+
 private
-  def self.generic_find_all(sql, *params)
+  def self.generic_find_all(db, sql, *params)
     all = Array.new
-    DbRegistry.instance.execute(sql, *params).each do |row|
-      le = LogEntry.new
+    db.execute(sql, *params).each do |row|
+      le = LogEntry.new(db)
       le.quick_assign!(row[0], row[1], Time.at(row[2]), row[3])
       all.push le
     end

data/lib/wlog/domain/session.rb

@@ -0,0 +1,17 @@
+module Wlog
+# This is the session that contains data about a particular run (for example
+# what kind of database to use, etc). NOTE: this is a placeholder for now. 
+# Eventually this should be the object passed on sessions (for example, the
+# active records should get the session object, and extract what they need from
+# it - the db reference).
+# @author Simon Symeonidis
+class Session
+
+  def initialize(dbhandle)
+    @db = dbhandle
+  end
+
+  attr_accessor :db
+
+end
+end

data/lib/wlog/domain/sql_modules/issue_sql.rb

@@ -8,21 +8,29 @@ module IssueSql
   # Standard insert
   InsertSql = \
     "INSERT INTO #{TableName} "\
-    "(description, reported_date, due_date, status) "\
-    "values (?,?,?,?);"
+    "(description, reported_date, due_date, status, timelog) "\
+    "values (?,?,?,?,0);"
   # Standard delete
   DeleteSql = "DELETE FROM #{TableName} WHERE id = ? ;"
 
   # Standard update
   UpdateSql = "UPDATE #{TableName} SET "\
-    "description = ? , reported_date = ? , due_date = ? , status = ?"\
+    "description = ? , reported_date = ? , due_date = ? , status = ?, "\
+    "timelog = ? "\
     "WHERE id = ?;"
   
   # Select by id
   SelectSql = "SELECT * FROM #{TableName} WHERE id = ? ;"
 
-  # Select all the issues
-  SelectAllSql = "SELECT * FROM #{TableName}; "
+  # Select all the issues (which are not archived)
+  SelectAllSql = "SELECT * FROM #{TableName} WHERE status <> 3; "
+
+  # Select issues that are finished
+  SelectFinishedSql = "SELECT * FROM #{TableName} WHERE status = 2"
+
+  # Select issues given a time range
+  SelectTimeRange = "SELECT * FROM #{TableName}"\
+    " WHERE reported_date >= ? AND reported_date <= ?"
 end
 end
 

data/lib/wlog/domain/static_configurations.rb

@@ -17,8 +17,17 @@ module StaticConfigurations
   # Absolute path to the data directory
   DataDirectory = "#{AppDirectory}data/"
 
+  # Where the template files exist
+  TemplateDir = "#{AppDirectory}templates/"
+
   # Default database name (when unspecified)
   DefaultDb = "default"
+
+  # This is used to see if it is the first setup or not
+  TaintFile = "#{AppDirectory}tainted"
+
+  # The configuration file
+  ConfigFile = "#{AppDirectory}config"
 end
 end # module Wlog
 

data/lib/wlog/domain/sys_config.rb

@@ -1,23 +1,93 @@
 require 'wlog/domain/key_value'
+require 'wlog/domain/static_configurations'
+require 'wlog/tech/wlog_string'
+require 'wlog/tech/uncolored_string'
 
 module Wlog
 # System preferences helper, that stores last accessed stuff and other fluff.
 # @author Simon Symeonidis
 class SysConfig
+
+  def initialize(db)
+    @db = db
+    @key_value = KeyValue.new(@db)
+  end
+
   # load the last focused issue
-  def self.last_focus
-    KeyValue.get('last_focus')
+  def last_focus
+    @key_value.get('last_focus')
   end
 
   # store the last focused issue
-  def self.last_focus=(issue)
-    KeyValue.put!('last_focus', "#{issue}")
+  def last_focus=(issue)
+    @key_value.put!('last_focus', "#{issue}")
+  end
+
+  def self.ansi?
+    self.read_attributes['ansi'] == 'yes'
+  end
+
+  def self.not_ansi!
+    self.store_config('ansi', 'no')
+  end
+
+  def self.ansi!
+    self.store_config('ansi', 'yes')
+  end
+
+  # Store a term into the configuration file
+  def self.store_config(term,value)
+    values = self.read_attributes
+    values[term] = value
+    self.write_attributes(values)
+  end
+
+  # Get a term from the configuration file. Return nil if not found
+  def self.get_config(term)
+    self.read_attributes[term]
+  end
+
+  # Get the string decorator.
+  def self.string_decorator
+    if self.ansi?
+      WlogString
+    else
+      UncoloredString
+    end
   end
 
+  attr_accessor :db
+
 private
-  class << self
-    private :new, :allocate
+
+  # terms is a hash -> {:a => :b, :c => :d}
+  # write each key value to a file like this:
+  #   a:b
+  #   c:d
+  #   ...
+  def self.write_attributes(terms)
+    include StaticConfigurations
+    str = terms.inject(""){|str,e| str += "#{e[0]}:#{e[1]}#{$/}"}
+    fh = File.open(ConfigFile, 'w')
+    fh.write(str)
+    fh.close
   end
+
+  # Load a hash from a text file.
+  # @see self.write_attributes
+  def self.read_attributes
+    include StaticConfigurations
+    FileUtils.touch ConfigFile
+    lines = File.open(ConfigFile, 'r').read.split(/#{$/}/)
+    terms = lines.map{|e| e.split(':')}
+    values = Hash.new(nil)
+    terms.each do |term_tuple| # [term, value]
+      values[term_tuple[0]] = term_tuple[1]
+    end
+  values end
+
+  attr :key_value
+
 end
 end # module Wlog