taco_it 1.3.1 → 1.4.0

data/lib/taco/change.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'time'
+
+# FIXME: put this in a namespace
+class Change
+  class Invalid < Exception; end
+  
+  attr_reader   :created_at
+  attr_accessor :attribute
+  attr_accessor :old_value
+  attr_accessor :new_value  
+  
+  def initialize(args={})
+    args.each do |attr, value|
+      raise ArgumentError.new("Unknown attribute #{attr}") unless self.respond_to?(attr)
+      
+      case attr.to_sym
+      when :created_at
+        value = Time.parse(value) unless value.is_a?(Time)
+      when :attribute
+        value = value.to_sym
+      end
+      
+      instance_variable_set("@#{attr.to_s}", value)
+    end
+    
+    @created_at = Time.parse(@created_at) if @created_at.is_a?(String)
+    @created_at = timescrub(@created_at || Time.now)
+    
+    self
+  end  
+  
+  def self.from_json(the_json)
+    begin
+      hash = JSON.parse(the_json)
+    rescue JSON::ParserError => e
+      raise Change::Invalid.new(e.to_s)
+    end
+
+    Change.new(hash)      
+  end
+  
+  def valid?(opts={})
+    # old_value is optional!
+    #
+    valid = created_at && attribute && new_value
+    raise Invalid if opts[:raise] && !valid
+    valid
+  end
+  
+  def to_json(state=nil)
+    valid? :raise => true
+    hash = { :created_at => created_at, :attribute => attribute, :old_value => old_value, :new_value => new_value }
+    JSON.pretty_generate(hash)
+  end
+  
+  def to_s(opts={})
+    if opts[:simple]
+      "#{attribute} : #{old_value} => #{new_value}"
+    else
+      fields = [ date(created_at), attribute, old_value || '[nil]', new_value ]        
+      "%10s : %12s : %s => %s" % fields        
+    end
+  end
+  
+  private
+    def date(t)
+      t.strftime "%Y/%m/%d %H:%M:%S"
+    end
+    
+    def timescrub(t)
+      Time.new t.year, t.mon, t.day, t.hour, t.min, t.sec, t.utc_offset
+    end
+  
+end

data/lib/taco/cli.rb

@@ -0,0 +1,107 @@
+require 'taco/issue'
+require 'taco/taco'
+require 'taco/tacorc'
+
+class TacoCLI
+  RETRY_NAME = '.taco_retry.txt'
+
+  TACORC_NAME = '.tacorc'
+  INDEX_ERB_NAME = '.index.html.erb'
+  
+  DEFAULT_TACORC_NAME = 'tacorc'
+  DEFAULT_INDEX_ERB_NAME = 'index.html.erb'
+  DEFAULTS_HOME = File.realpath(File.join(File.dirname(__FILE__), 'defaults/'))
+  
+  def initialize
+    @taco = Taco.new
+    
+    @retry_path = File.join(@taco.home, RETRY_NAME)
+
+    @tacorc_path = File.join(@taco.home, TACORC_NAME)
+    @index_erb_path = File.join(@taco.home, INDEX_ERB_NAME)
+    
+    if File.exist? @tacorc_path
+      rc = TacoRc.new @tacorc_path
+      rc.update_schema! Issue
+    end
+  end
+  
+  def init!
+    out = @taco.init!
+
+    FileUtils.copy(File.join(DEFAULTS_HOME, DEFAULT_TACORC_NAME), @tacorc_path)    
+    FileUtils.copy(File.join(DEFAULTS_HOME, DEFAULT_INDEX_ERB_NAME), @index_erb_path)
+    
+    out + "\nPlease edit the config file at #{@tacorc_path}"
+  end
+
+  def list(args)
+    the_list = @taco.list(:short_ids => true, :filters => args).map do |issue, short_id| 
+      "#{short_id} : #{issue.priority} : #{issue.summary}"
+    end
+    return "Found no issues." unless the_list.size > 0
+    the_list.join("\n")
+  end
+  
+  def new!(args, opts)
+    editor_opts = if opts[:retry]
+      raise ArgumentError.new("No previous Issue edit session was found.") unless File.exist?(@retry_path)      
+      { :template => open(@retry_path) { |f| f.read } }
+    elsif args.size == 0
+      { :template => Issue.new.to_template }
+    elsif args.size == 1
+      { :from_file => args[0] }
+    end
+
+    if issue = IssueEditor.new(@taco, @retry_path).new_issue!(editor_opts)
+      "Created Issue #{issue.id}"
+    else
+      "Aborted."
+    end
+  end
+  
+  def show(args, opts)
+    if opts[:all]
+      filters = args.select { |arg| arg.include? ':' }
+      args = @taco.list(:filters => filters).map(&:id)
+    end
+    
+    args.map { |id| @taco.read(id).to_s(opts) }.join("\n\n")
+  end
+  
+  def edit!(args, opts)
+    ie = IssueEditor.new @taco, @retry_path
+    
+    if opts[:retry]
+      raise ArgumentError.new("No previous Issue edit session was found.") unless File.exist?(@retry_path)      
+      template = open(@retry_path) { |f| f.read }
+    end
+    
+    if issue = ie.edit_issue!(@taco.read(args[0]), :template => template)
+      "Updated Issue #{issue.id}"
+    else
+      "Aborted."
+    end
+  end
+  
+  def template(opts)
+    if opts[:defaults]
+      (Issue::TEMPLATE % Issue.new.to_hash).strip
+    else
+      Issue::TEMPLATE.gsub(/%{.*?}/, '').strip
+    end
+  end
+  
+  def html
+    require 'erb'
+    
+    issues = @taco.list
+    ERB.new(open(@index_erb_path) { |f| f.read }).result(binding)    
+  end
+  
+  def push(opts)
+    opts[:message] ||= 'turn and face the strange'
+    cmd = "git add . && git commit -am '#{opts[:message]}' && git push"
+    system(cmd)
+  end
+end

data/lib/taco/defaults/tacorc

@@ -0,0 +1,10 @@
+# Empty lines and lines beginning with # will be ignored.
+#
+
+#
+# schema_attr_update <attribute name>, [ default: <default attribute value> ], [ validate: <list of type-correct valid values, or lambda validator> ]
+#
+
+schema_attr_update :kind, default: 'Defect', validate: [ 'Defect', 'FeatReq' ]
+schema_attr_update :status, default: 'Open', validate: [ 'Open', 'Closed' ]
+schema_attr_update :priority, default: 3, validate: [ 1, 2, 3, 4, 5 ]

data/lib/taco/issue.rb

@@ -0,0 +1,240 @@
+require 'taco/schema'
+require 'taco/change'
+require 'securerandom'
+
+class Issue  
+  include Comparable
+  include Schema
+  
+  alias_method :schema_valid?, :valid?
+  
+  attr_reader :changelog
+
+  schema_attr :id,          class: String,      settable: false
+  schema_attr :created_at,  class: Time,        settable: false
+  schema_attr :updated_at,  class: Time,        settable: false
+  
+  schema_attr :summary,     class: String,      settable: true
+  schema_attr :kind,        class: String,      settable: true
+  schema_attr :status,      class: String,      settable: true
+  schema_attr :owner,       class: String,      settable: true
+  schema_attr :priority,    class: Fixnum,      settable: true
+  schema_attr :description, class: String,      settable: true
+    
+  TEMPLATE =<<-EOT.strip
+# Lines beginning with # will be ignored.
+Summary     : %{summary}
+Kind        : %{kind}
+Status      : %{status}
+Priority    : %{priority}
+Owner       : %{owner}
+
+# Everything between the --- lines is Issue Description
+---
+%{description}
+---
+EOT
+
+  class Invalid < Exception; end
+  class NotFound < Exception; end
+  
+  def initialize(attributes={}, changelog=[])
+    attributes = Hash[attributes.map { |k, v| [ k.to_sym, v ] }]
+
+    @new = attributes[:created_at].nil? && attributes[:id].nil?      
+
+    @changelog = []
+            
+    attributes.each do |attr, value|
+      schema_attr = self.class.schema_attributes[attr]
+      raise ArgumentError.new("unknown attribute: #{attr}") unless schema_attr
+      if schema_attr[:settable]
+        self.send "#{attr}=", attributes[attr]
+      end
+    end
+    
+    self.id = attributes[:id] || SecureRandom.uuid.gsub('-', '')
+    self.created_at = attributes[:created_at] || Time.now
+    self.updated_at = attributes[:updated_at] || Time.now
+    
+    if changelog.size > 0
+      @changelog = changelog.map do |thing|
+        if thing.is_a? Change
+          thing
+        else
+          Change.new thing
+        end
+      end
+    end
+    
+    self
+  end
+  
+  def schema_attribute_change(attribute, old_value, new_value)
+    if self.class.schema_attributes[attribute][:settable]
+      self.updated_at = Time.now
+      @changelog << Change.new(:attribute => attribute, :old_value => old_value, :new_value => new_value)
+    end
+  end   
+  
+  def new?
+    @new
+  end
+  
+  def <=>(other)
+    if self.class.schema_attributes.all? { |attr, opts| self.send(attr) == other.send(attr) }
+      r = 0
+    else
+      if self.created_at == other.created_at
+        r = self.id <=> other.id
+      else
+        r = self.created_at <=> other.created_at
+      end
+
+      # this clause should not return 0, we've already established inequality
+      #      
+      r = -1 if r == 0
+    end
+    
+    r
+  end
+
+  def inspect
+    fields = self.class.schema_attributes.map do |attr, opts|
+      "@#{attr}=#{self.send(attr).inspect}"
+    end.join ', '
+    
+    "#<#{self.class}:0x%016x %s>" % [ object_id, fields ]
+  end
+      
+  def to_s(opts={})
+    text = <<-EOT.strip
+ID          : #{id}
+Created At  : #{date(created_at)}
+Updated At  : #{date(updated_at)}
+
+Summary     : #{summary}
+Kind        : #{kind}
+Status      : #{status}
+Priority    : #{priority}
+Owner       : #{owner}
+
+---
+#{description}
+EOT
+
+    if opts[:changelog]
+      changelog_str = changelog.map { |c| %Q|# #{c.to_s.strip.gsub(/\n/, "\n# ")}| }.join("\n")      
+      text << %Q|\n---\n\n#{changelog_str}|
+    end
+    
+    text
+  end
+  
+  def valid?(opts={})
+    valid = schema_valid?
+    error = schema_errors.first
+    raise Invalid.new("attribute #{error.first}: #{error[1].inspect} is not a valid value") if !valid && opts[:raise]
+    valid
+  end
+  
+  def to_json(state=nil)
+    valid? :raise => true
+    hash = { :issue => self.to_hash, :changelog => changelog }
+    JSON.pretty_generate(hash)
+  end
+  
+  def to_template
+    if new?
+      header = "# New Issue\n#"
+      body = TEMPLATE % self.to_hash
+      footer = ""
+    else
+      header =<<-EOT
+# Edit Issue
+#
+# ID          : #{id}
+# Created At  : #{created_at}
+# Updated At  : #{updated_at}
+#
+EOT
+      body = TEMPLATE % self.to_hash
+      
+      footer =<<-EOT      
+# ChangeLog
+#
+#{changelog.map { |c| %Q|# #{c.to_s.strip.gsub(/\n/, "\n# ")}| }.join("\n")}      
+EOT
+    end
+    
+    (header + "\n" + body + "\n\n" + footer).strip
+  end
+  
+  def self.from_json(the_json)
+    begin
+      hash = JSON.parse(the_json)
+    rescue JSON::ParserError => e
+      raise Issue::Invalid.new(e.to_s)
+    end
+    
+    Issue.new(hash['issue'], hash['changelog'])    
+  end    
+  
+  def self.from_template(text)
+    issue = { :description => '' }
+    reading_description = false
+    
+    text.lines.each_with_index do |line, index|
+      next if line =~ /^#/ || (!reading_description && line =~ /^\s*$/)
+      
+      if line =~ /^---$/
+        # FIXME: this means that there can be multiple description blocks in the template!
+        #
+        reading_description = !reading_description
+        next
+      end
+      
+      if !reading_description && line =~ /^(\w+)\s*:\s*(.*)$/
+        key, value = $1.downcase.to_sym, $2.strip
+        
+        if schema_attributes.include?(key) && schema_attributes[key][:settable]
+          issue[key] = value
+        else
+          raise ArgumentError.new("Unknown Issue attribute: #{key} on line #{index+1}") unless schema_attributes.include?(key)
+          raise ArgumentError.new("Cannot set write-protected Issue attribute: #{key} on line #{index+1}")
+        end
+      elsif reading_description
+        issue[:description] += line
+      else
+        raise ArgumentError.new("Cannot parse line #{index+1}")
+      end
+    end
+    
+    Issue.new(issue)
+  end
+  
+  def update_from_template!(text)
+    new_issue = Issue.from_template(text)
+    
+    attrs = self.class.schema_attributes.map do |attr, opts|
+      if opts[:settable] && self.send(attr) != (new_value = new_issue.send(attr))
+        self.send("#{attr}=", new_value)
+      end
+    end
+
+    self
+  end  
+  
+  private
+    def date(t)
+      t.strftime "%Y/%m/%d %H:%M:%S"
+    end
+  
+    def dup
+      raise NoMethodError.new
+    end
+    
+    def clone
+      raise NoMethodError.new
+    end
+end

data/lib/taco/schema.rb

@@ -0,0 +1,208 @@
+require 'time'
+
+# Schema characteristics
+#
+# attributes have default validations, coercions, and transformations
+#
+#  FIXME: document
+
+module Schema
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  def to_hash
+    Hash[self.class.schema_attributes.map do |attr, opts|
+      [ attr, send(attr) ]
+    end]
+  end
+  
+  def schema_errors
+    @errors || []
+  end
+  
+  def valid?
+    @errors = nil
+    
+    self.class.schema_attributes.each do |attr, opts|
+      if opts[:validate].nil?
+        case opts[:class].to_s # can't case on opts[:class], because class of opts[:class] is always Class :-)
+        when 'String'
+          opts[:validate] = lambda { |v| v !~ /\A\s*\Z/ }
+        end
+      end
+      
+      if opts[:validate]
+        value = eval(attr.to_s)
+        
+        valid = if opts[:validate].is_a?(Array)
+          opts[:validate].include? value
+        elsif opts[:validate].is_a?(Proc)
+          opts[:validate].call(value)
+        end
+        
+        unless valid
+          @errors = [ [ attr, value ] ]
+          return false
+        end
+      end
+    end
+    
+    true
+  end
+    
+  module ClassMethods
+    def schema_attributes
+      @schema_attrs
+    end
+    
+    def schema_attr_remove(name)
+      raise KeyError.new("attribute #{name}: does not exist in class #{self.name}") unless @schema_attrs.include? name      
+      @schema_attrs.delete(name)
+      self.send(:remove_method, name)
+      self.send(:remove_method, "#{name}=".to_s)
+    end
+    
+    def schema_attr_replace(name, opts)
+      raise KeyError.new("attribute #{name}: does not exist in class #{self.name}") unless @schema_attrs.include? name      
+      schema_attr_remove(name)
+      schema_attr(name, opts)
+    end
+    
+    def schema_attr_update(name, opts)
+      raise KeyError.new("attribute #{name}: does not exist in class #{self.name}") unless @schema_attrs.include? name      
+      raise KeyError.new("attribute #{name}: cannot update non-settable attribute") unless @schema_attrs[name][:settable]
+      schema_attr_replace(name, @schema_attrs[name].merge(opts))
+    end
+    
+    def schema_attr(name, opts)      
+      @schema_attrs ||= {}
+
+      raise TypeError.new("attribute #{name}: missing or invalid :class") unless opts[:class].is_a?(Class)
+      
+      if opts[:default].nil?
+        opts[:default] = case opts[:class].to_s # can't case on opts[:class], because class of opts[:class] is always Class :-)
+        when 'String'
+          ''
+        when 'Fixnum'
+          0
+        when 'Time'
+          lambda { Time.new }
+        else
+          raise ArgumentError.new("Sorry, no default default exists for #{opts[:class]}")
+        end
+      end
+            
+      unless opts[:default].is_a?(opts[:class]) || opts[:default].is_a?(Proc)
+        raise TypeError.new("attribute #{name}: invalid :default")
+      end
+      
+      if opts[:validate]
+        unless opts[:validate].is_a?(Array) || opts[:validate].is_a?(Proc)
+          raise ArgumentError.new("attribute #{name}: expecting Array or Proc for :validate")
+        end
+        
+        if opts[:validate].is_a?(Array)
+          raise TypeError.new("attribute #{name}: wrong type in :validate Array") unless opts[:validate].all? { |v| v.is_a?(opts[:class]) }
+        end
+      end
+
+      raise ArgumentError.new("attribute #{name}: already exists") if @schema_attrs[name]
+      
+      @schema_attrs[name] = opts
+      
+      value_getter = if opts[:default].is_a?(Proc)
+        %Q(
+            opts = self.class.schema_attributes[:#{name}]
+            value = opts[:default].call
+            raise TypeError.new("attribute #{name}: expected type #{opts[:class]}, received \#{value.class}") unless opts[:class] == value.class            
+        )        
+      else
+        %Q(value = #{opts[:default].inspect})
+      end
+      module_eval %Q(
+                      def #{name}
+                        if @#{name}.nil?
+                          #{value_getter}
+                          self.#{name}= value
+                        end
+                        @#{name}
+                      end
+                    )
+        
+      unless opts[:coerce] == false # possible values are false=no-coerce, nil=default-coerce, Proc=custom-coerce
+        case opts[:class].to_s # can't case on opts[:class], because class of opts[:class] is always Class :-)
+        when 'Fixnum'
+          unless opts[:coerce].is_a? Proc
+            # the default coercion for Fixnum
+            opts[:coerce] = lambda do |value|
+              unless value.is_a?(Fixnum) # FIXME: this "unless value.is_a?(same class as 'when')" is copy-pasta.  fix it.
+                raise TypeError.new("attribute #{name}: cannot coerce from \#{value.class}") unless value.is_a?(String)
+                i = value.to_i
+                raise TypeError.new("attribute #{name}: failed to coerce from \#{value}") unless i.to_s == value
+                value = i
+              end
+              value
+            end
+          end
+        when 'Time'
+          unless opts[:coerce].is_a? Proc
+            # the default coercion for Time
+            opts[:coerce] = lambda do |value|
+              unless value.is_a?(Time) # FIXME: this "unless value.is_a?(same class as 'when')" is copy-pasta.  fix it.
+                raise TypeError.new("attribute #{name}: cannot coerce from \#{value.class}") unless value.is_a?(String)
+                begin
+                  value = Time.parse(value)
+                rescue ArgumentError
+                  raise TypeError.new("attribute #{name}: cannot coerce from \#{value.class}")
+                end                  
+              end
+              value
+            end
+          end          
+        end
+        
+        coerce = 'value = opts[:coerce].call(value)' if opts[:coerce]
+      end
+      
+      unless opts[:transform] == false # possible values are false=no-transform, nil=default-transform, Proc=custom-transform
+        case opts[:class].to_s # can't case on opts[:class], because class of opts[:class] is always Class :-)
+        when 'String'
+          unless opts[:transform].is_a? Proc
+            # the default transform for String: remove excess whitespace
+            opts[:transform] = lambda { |s| s.strip }
+          end
+        when 'Time'
+          unless opts[:transform].is_a? Proc
+            # the default transform for Time: remove subsecond precision.  subsec precision is not recorded in to_s, so unless
+            #                                 we scrub it out, the following happens:
+            #                                 foo.a_time = Time.new
+            #                                 Time.parse(foo.a_time.to_s) == foo.a_time # returns false most of the time!
+            opts[:transform] = lambda { |t| Time.new t.year, t.mon, t.day, t.hour, t.min, t.sec, t.utc_offset }
+          end            
+        end
+        
+        transform = 'value = opts[:transform].call(value)' if opts[:transform]
+      end
+      
+      callback = %Q(
+        if self.respond_to? :schema_attribute_change
+          self.schema_attribute_change(:#{name}, @#{name}, value)
+        end
+      )
+      
+      setter_method = %Q(
+        def #{name}=(value)
+          opts = self.class.schema_attributes[:#{name}]
+          #{coerce}
+          raise TypeError.new("attribute #{name}: expected type #{opts[:class]}, received \#{value.class}") unless opts[:class] == value.class
+          #{transform}
+          #{callback}            
+          @#{name} = value
+        end
+      )
+      module_eval setter_method
+      module_eval "private :#{name}=" unless opts[:settable]
+    end
+  end
+end