tempo-cli 0.1.0

data/lib/tempo/models/base.rb

@@ -0,0 +1,176 @@
+module Tempo
+  module Model
+
+    class IdentityConflictError < Exception
+    end
+
+    class Base
+      attr_reader :id
+
+      class << self
+
+        # Maintain an array of unique ids for the class.
+        # Initialize new members with the next numberical id
+        # Ids can be assigned on init (for the purpose of reading
+        # in records of previous instances). An error will
+        # be raised if there is already an instance with that
+        # id.
+        def id_counter
+          @id_counter ||= 1
+        end
+
+        def ids
+          @ids ||= []
+        end
+
+        def index
+          @index ||= []
+        end
+
+        # example: Tempo::Model::Animal -> tempo_animals.yaml
+        def file
+          FileRecord::Record.model_filename self
+        end
+
+        def save_to_file
+          FileRecord::Record.save_model self
+        end
+
+        def read_from_file
+          FileRecord::Record.read_model self
+        end
+
+        def method_missing meth, *args, &block
+
+          if meth.to_s =~ /^find_by_(.+)$/
+            run_find_by_method($1, *args, &block)
+
+          elsif meth.to_s =~ /^sort_by_(.+)$/
+            run_sort_by_method($1, *args, &block)
+          else
+            super
+          end
+        end
+
+        def run_sort_by_method attribute, args=@index.clone, &block
+          attr = "@#{attribute}".to_sym
+          args.sort! { |a,b| a.instance_variable_get( attr ) <=> b.instance_variable_get( attr ) }
+          return args unless block
+          block.call args
+        end
+
+        def run_find_by_method attrs, *args, &block
+          # Make an array of attribute names
+          attrs = attrs.split('_and_')
+
+          attrs_with_args = [attrs, args].transpose
+
+          filtered = index.clone
+          attrs_with_args.each do | kv |
+            matches = find kv[0], kv[1]
+
+            return matches if matches.empty?
+            matches.each do |match|
+              matches.delete match unless filtered.include? match
+              filtered = matches
+            end
+          end
+          filtered
+        end
+
+        # find by id should be exact, so we remove the array wrapper
+        def find_by_id id
+          matches = find "id", id
+          match = matches[0]
+        end
+
+        # example: Tempo::Model.find("id", 1)
+        #
+        def find key, value
+          key = "@#{key}".to_sym
+          matches = []
+          index.each do |i|
+            stored_value = i.instance_variable_get( key )
+
+            if stored_value.kind_of? String
+              if value.kind_of? Regexp
+                matches << i if value.match stored_value
+              else
+                matches << i if stored_value.downcase.include? value.to_s.downcase
+              end
+
+            elsif stored_value.kind_of? Integer
+              matches << i if stored_value == value.to_i
+            end
+          end
+          matches
+        end
+
+        def delete instance
+          id = instance.id
+          index.delete( instance )
+          ids.delete( id )
+        end
+      end
+
+      def initialize options={}
+        id_candidate = options[:id]
+        if !id_candidate
+          @id = self.class.next_id
+        elsif self.class.ids.include? id_candidate
+          raise IdentityConflictError, "Id #{id_candidate} already exists"
+        else
+          @id = id_candidate
+        end
+        self.class.add_id @id
+        self.class.add_to_index self
+      end
+
+      # record the state of all instance variables as a hash
+      def freeze_dry
+        record = {}
+        state = instance_variables
+        state.each do |attr|
+          key = attr[1..-1].to_sym
+          val = instance_variable_get attr
+
+          #val = val.to_s if val.kind_of? Time
+
+          record[key] = val
+        end
+        record
+      end
+
+      def delete
+        self.class.delete self
+      end
+
+      protected
+
+      def self.add_to_index member
+        @index ||= []
+        @index << member
+        @index.sort! { |a,b| a.id <=> b.id }
+      end
+
+      def self.add_id id
+        @ids ||=[]
+        @ids << id
+        @ids.sort!
+      end
+
+      def self.increase_id_counter
+        @id_counter ||= 0
+        @id_counter = @id_counter.next
+      end
+
+      def self.next_id
+        while ids.include? id_counter
+          increase_id_counter
+        end
+        id_counter
+      end
+    end
+  end
+end
+

data/lib/tempo/models/composite.rb

@@ -0,0 +1,71 @@
+# Composite Model extends base to accomodate tree structures
+# Each instance can be a root instance, or a child of another
+# instance, and each instance can have any number of children.
+# report_trees is a utility method for testing the validity of the
+# model, and cam be used as a template for creating tree reports.
+
+module Tempo
+  module Model
+    class Composite < Tempo::Model::Base
+      attr_accessor :parent, :children
+
+      class << self
+
+        def report_trees
+          report_array = "["
+          @index.each do |member|
+            if member.parent == :root
+              report_array += "["
+              report_array += member.report_branches
+              report_array += "],"
+            end
+          end
+          if report_array[-1] == ","
+            report_array = report_array[0..-2]
+          end
+          report_array += "]"
+        end
+
+        def delete instance
+          instance.children.each do |child_id|
+            child = find_by_id child_id
+            instance.remove_child child
+          end
+          super instance
+        end
+      end
+
+      def initialize(options={})
+        super options
+        @parent = options.fetch(:parent, :root)
+        @children = options.fetch(:children, [])
+      end
+
+      def << child
+        @children << child.id unless @children.include? child.id
+        @children.sort!
+        child.parent = self.id
+      end
+
+      def remove_child( child )
+        @children.delete child.id
+        child.parent = :root
+      end
+
+      def report_branches
+        report = self.id.to_s
+        child_report = ",["
+        @children.each do |c|
+          child = self.class.find_by_id c
+          child_report += "#{child.report_branches},"
+        end
+        if child_report == ",["
+          child_report = ""
+        else
+          child_report = child_report[0..-2] + "]"
+        end
+        report += child_report
+      end
+    end
+  end
+end

data/lib/tempo/models/log.rb

@@ -0,0 +1,194 @@
+module Tempo
+  module Model
+    class Log < Tempo::Model::Base
+      attr_accessor :start_time
+      attr_reader :d_id
+
+      class << self
+
+        # Maintain arrays of unique ids for each day.
+        # days are represented as symbols in the hash,
+        # for example Jan 1, 2013 would be  :"130101"
+        # id counter is managed through the private methods
+        # increase_id_counter and next_id below
+        def id_counter time
+          dsym = date_symbol time
+          @id_counter = {} unless @id_counter.kind_of? Hash
+          @id_counter[ dsym ] ||= 1
+        end
+
+        def ids time
+          dsym = date_symbol time
+          @ids = {} unless @ids.kind_of? Hash
+          @ids[dsym] ||= []
+        end
+
+        # all instances are saved in the index inherited from base.
+        # Additionally, the days index organizes all instances into
+        # arrays by day.  This is used for saving to file.
+        def days_index
+          @days_index = {} unless @days_index.kind_of? Hash
+          @days_index
+        end
+
+        def file time
+          FileRecord::Record.log_filename( self, time )
+        end
+
+        def dir
+          FileRecord::Record.log_dirname( self )
+        end
+
+        def records
+          path = FileRecord::Record.log_dir( self )
+          Dir[path + "/*.yaml"]
+        end
+
+        def save_to_file
+          FileRecord::Record.save_log( self )
+        end
+
+
+        def read_from_file time
+          dsym = date_symbol time
+          @days_index[ dsym ] = [] if not days_index.has_key? dsym
+          FileRecord::Record.read_log( self, time )
+        end
+
+        # load all the records for a single day
+        def load_day_record time
+          dsym = date_symbol time
+          if not days_index.has_key? dsym
+            @days_index[ dsym ] = []
+            read_from_file time
+          end
+        end
+
+        # load the records for each day from time 1 to time 2
+        def load_days_records time_1, time_2
+
+          return if time_1.nil? || time_2.nil?
+
+          days = ( time_2.to_date - time_1.to_date ).to_i
+          return if days < 0
+
+          (days + 1).times { |i| load_day_record( time_1.add_days( i ))}
+        end
+
+        # load the records for the most recently recorded day
+        def load_last_day
+          reg = /(\d+)\.yaml/
+          if records.last
+            d_id = reg.match(records.last)[1] if records.last
+            time = day_id_to_time d_id if d_id
+            load_day_record time
+            return time
+          end
+        end
+
+        # takes and integer, and time or day_id
+        # and returns the instance that matches both
+        # the id and d_id
+        def find_by_id id, time
+          time = day_id time
+          ids = find "id", id
+          d_ids = find "d_id", time
+
+          #return the first and only match in the union
+          #of the arrays
+          (ids & d_ids)[0]
+        end
+
+        # day_ids can be run through without change
+        # Time will be converted into "YYYYmmdd"
+        # ex: 1-1-2014 => "20140101"
+        def day_id time
+          if time.kind_of? String
+            return time if time =~ /^\d{8}$/
+          end
+          raise ArgumentError, "Invalid Time" if not time.kind_of? Time
+          time.strftime("%Y%m%d")
+        end
+
+        def day_id_to_time d_id
+          time = Time.new(d_id[0..3].to_i, d_id[4..5].to_i, d_id[6..7].to_i)
+        end
+
+        def delete instance
+          id = instance.id
+          dsym = date_symbol instance.d_id
+
+          index.delete instance
+          days_index[dsym].delete instance
+          @ids[dsym].delete id
+        end
+      end
+
+      def initialize( options={} )
+        @start_time = options.fetch(:start_time, Time.now )
+        @start_time = Time.new(@start_time) if @start_time.kind_of? String
+
+        self.class.load_day_record(@start_time)
+        @d_id = self.class.day_id @start_time
+
+        id_candidate = options[:id]
+        if !id_candidate
+          @id = self.class.next_id @start_time
+        elsif self.class.ids( @start_time ).include? id_candidate
+          raise IdentityConflictError, "Id #{id_candidate} already exists"
+        else
+          @id = id_candidate
+        end
+
+        self.class.add_id @start_time, @id
+        self.class.add_to_index self
+        self.class.add_to_days_index self
+      end
+
+      def freeze_dry
+        record = super
+        record.delete(:d_id)
+        record
+      end
+
+      protected
+
+      class << self
+
+        def add_to_days_index member
+          @days_index = {} unless @days_index.kind_of? Hash
+          dsym = date_symbol member.start_time
+          @days_index[dsym] ||= []
+          @days_index[dsym] << member
+          @days_index[dsym].sort! { |a,b| a.start_time <=> b.start_time }
+        end
+
+        def add_id time, id
+          dsym = date_symbol time
+          @ids = {} unless @ids.kind_of? Hash
+          @ids[dsym] ||= []
+          @ids[dsym] << id
+          @ids[dsym].sort!
+        end
+
+        def date_symbol time
+          day_id( time ).to_sym
+        end
+
+        def increase_id_counter time
+          dsym = date_symbol time
+          @id_counter = {} unless @id_counter.kind_of? Hash
+          @id_counter[ dsym ] ||= 0
+          @id_counter[ dsym ] = @id_counter[ dsym ].next
+        end
+
+        def next_id time
+          while ids(time).include? id_counter time
+            increase_id_counter time
+          end
+          id_counter time
+        end
+      end
+    end
+  end
+end

data/lib/tempo/models/project.rb

@@ -0,0 +1,73 @@
+module Tempo
+  module Model
+    class Project < Tempo::Model::Composite
+      attr_accessor :title
+      attr_reader :tags
+      @current = 0
+
+      class << self
+
+        def current( instance=nil )
+          @current
+        end
+
+        def current=( instance )
+          if instance.class == self
+            @current = instance
+          else
+            raise ArgumentError
+          end
+        end
+
+        def include?( title )
+          matches = find_by_title( title )
+          return false if matches.empty?
+          matches.each do |match|
+            return true if match.title == title
+          end
+          false
+        end
+      end
+
+      def initialize(options={})
+        super options
+        @title = options.fetch(:title, "new project")
+        @tags = []
+        tag options.fetch(:tags, [])
+        current = options.fetch(:current, false)
+        self.class.current = self if current
+      end
+
+      def current?
+        self.class.current == self
+      end
+
+      def freeze_dry
+        record = super
+        if self.class.current == self
+          record[:current] = true
+        end
+        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
+        puts "id: #{id}, title: #{title}, tags: #{tags}"
+      end
+    end
+  end
+end