gitgo 0.3.3

data/lib/gitgo/helper/format.rb

@@ -0,0 +1,200 @@
+require 'rack/utils'
+require 'redcloth'
+require 'gitgo/helper/utils'
+
+module Gitgo
+  module Helper
+    class Format
+      include Rack::Utils
+      include Helper::Utils
+      
+      attr_reader :controller
+      
+      def initialize(controller)
+        @controller = controller
+      end
+      
+      def url(*paths)
+        controller.url(paths)
+      end
+      
+      def refs
+        @refs ||= controller.repo.git.grit.refs
+      end
+      
+      def ref_name(sha)
+        reference = refs.find {|ref| ref.commit.id == sha}
+        reference ? reference.name : sha
+      end
+      
+      #
+      # general formatters
+      #
+      
+      def text(str)
+        str = escape_html(str)
+        str.gsub!(/[A-Fa-f\d]{40}/) {|sha| sha_a(sha) }
+        str
+      end
+      
+      def sha(sha)
+        escape_html(sha)
+      end
+      
+      def textile(str)
+        ::RedCloth.new(str).to_html
+      end
+      
+      #
+      # links
+      #
+      
+      def sha_a(sha)
+        "<a class=\"sha\" href=\"#{url('obj', sha)}\" title=\"#{sha}\">#{sha}</a>"
+      end
+      
+      def path_a(type, treeish, path)
+        "<a class=\"#{type}\" href=\"#{url(type, treeish, *path)}\">#{escape_html(path.pop || treeish)}</a>"
+      end
+      
+      def full_path_a(type, treeish, path)
+        "<a class=\"#{type}\" href=\"#{url(type, treeish, *path)}\">#{escape_html File.join(path)}</a>"
+      end
+      
+      def commit_a(treeish)
+        "<a class=\"commit\" href=\"#{url('commit', treeish)}\">#{escape_html treeish}</a>"
+      end
+      
+      def tree_a(treeish, *path)
+        path_a('tree', treeish, path)
+      end
+      
+      def blob_a(treeish, *path)
+        path_a('blob', treeish, path)
+      end
+      
+      def history_a(treeish)
+        "<a class=\"history\" href=\"#{url('commits', treeish)}\" title=\"#{escape_html treeish}\">history</a>"
+      end
+      
+      def issue_a(doc)
+        target = doc.graph_head? ? doc.graph_head : "#{doc.graph_head}##{doc.sha}"
+        "<a id=\"#{doc.sha}\" href=\"#{url('issue', target)}\">#{titles(doc.graph_titles)}</a>"
+      end
+      
+      def doc_a(doc)
+        target = doc.graph_head? ? doc.graph_head : "#{doc.graph_head}##{doc.sha}"
+        "<a id=\"#{doc.sha}\" href=\"#{url(doc.type, target)}\">#{escape_html doc.summary}</a>"
+      end
+      
+      def index_key_a(key)
+        "<a href=\"#{url('repo', 'index', key)}\">#{escape_html key}</a>"
+      end
+      
+      def index_value_a(key, value)
+        "<a href=\"#{url('repo', 'index', key, value)}\">#{escape_html value}</a>"
+      end
+      
+      def each_path(treeish, path)
+        paths = path.split("/")
+        base = paths.pop
+        paths.unshift(treeish)
+
+        object_path = ['tree']
+        paths.collect! do |path| 
+          object_path << path
+          yield "<a href=\"#{url(*object_path)}\">#{escape_html path}</a>"
+        end
+
+        yield(base) if base
+        paths
+      end
+      
+      #
+      # documents
+      #
+      
+      def tree(hash, io=[], &block)
+        dup = {}
+        hash.each_pair do |key, value|
+          dup[key] = value.dup
+        end  
+        
+        tree!(dup, io, &block)
+      end
+      
+      def tree!(hash, io=[], &block)
+        nodes = flatten(hash)[nil]
+        nodes = collapse(nodes)
+        nodes.shift
+        
+        render(nodes, io, &block)
+      end
+      
+      def title(title)
+        escape_html(title)
+      end
+      
+      def titles(titles)
+        titles << "(nameless)" if titles.empty?
+        escape_html titles.join(', ')
+      end
+      
+      def content(str)
+        textile text(str)
+      end
+      
+      def author(author)
+        return nil if author.nil?
+        "#{escape_html(author.name)} (<a href=\"#{url('timeline')}?#{build_query(:author => author.email)}\">#{escape_html author.email}</a>)"
+      end
+      
+      def date(date)
+        return nil if date.nil?
+        "<abbr title=\"#{date.iso8601}\">#{date.strftime('%Y/%m/%d %H:%M %p')}</abbr>"
+      end
+      
+      def at(at)
+        at.nil? || at.empty? ? '(none)' : sha_a(at)
+      end
+      
+      def origin(origin)
+        sha(origin)
+      end
+
+      def tags(tags)
+        tags << '(unclassified)' if tags.empty?
+        escape_html tags.join(', ')
+      end
+      
+      def graph(graph)
+        graph.each do |sha, slot, index, current_slots, transitions|
+          next unless sha
+          yield(sha, "#{slot}:#{index}:#{current_slots.join(',')}:#{transitions.join(',')}")
+        end
+      end
+      
+      #
+      # repo
+      #
+      
+      def path(path)
+        escape_html(path)
+      end
+      
+      def branch(branch)
+        escape_html(branch)
+      end
+      
+      def each_diff_a(status)
+        status.keys.sort.each do |path|
+          change, a, b = status[path]
+          a_mode, a_sha = a
+          b_mode, b_sha = b
+          
+          yield "<a class=\"#{change}\" href=\"#{url('obj', b_sha.to_s)}\" title=\"#{a_sha || '-'} to #{b_sha || '-'}\">#{path}</a>"
+        end
+      end
+    end
+  end
+end

data/lib/gitgo/helper/html.rb

@@ -0,0 +1,19 @@
+module Gitgo
+  module Helper
+    module Html
+      module_function
+      
+      def check(true_or_false)
+        true_or_false ? ' checked="checked"' : nil
+      end
+
+      def select(true_or_false)
+        true_or_false ? ' selected="selected"' : nil
+      end
+      
+      def disable(true_or_false)
+        true_or_false ? ' disabled="disabled"' : nil
+      end
+    end
+  end
+end

data/lib/gitgo/helper/utils.rb

@@ -0,0 +1,85 @@
+module Gitgo
+  module Helper
+    module Utils
+      module_function
+      
+      # Flattens a hash of (parent, [children]) pairs.  For example:
+      #
+      #   tree = {
+      #     "a" => ["b"],
+      #     "b" => ["c", "d"],
+      #     "c" => [],
+      #     "d" => ["e"],
+      #     "e" => []
+      #   }
+      #
+      #   flatten(tree) 
+      #   # => {
+      #   # "a" => ["a", ["b", ["c"], ["d", ["e"]]]],
+      #   # "b" => ["b", ["c"], ["d", ["e"]]],
+      #   # "c" => ["c"],
+      #   # "d" => ["d", ["e"]],
+      #   # "e" => ["e"]
+      #   # }
+      #
+      # Note that the flattened hash re-uses the array values, such that
+      # modifiying the "b" value will propagate to the "a" value.
+      def flatten(tree)
+        tree.each_pair do |parent, children|
+          next unless children
+
+          children.collect! {|child| tree[child] }
+          children.unshift(parent)
+        end
+        tree
+      end
+
+      # Collapses an nested array hierarchy such that nesting is only
+      # preserved for existing, and not just potential, branches:
+      #
+      #   collapse(["a", ["b", ["c"]]])               # => ["a", "b", "c"]
+      #   collapse(["a", ["b", ["c"], ["d", ["e"]]]]) # => ["a", "b", ["c"], ["d", "e"]]
+      #
+      def collapse(array, result=[])
+        result << array.at(0)
+
+        if (length = array.length) == 2
+          collapse(array.at(1), result)
+        else
+          1.upto(length-1) do |i|
+            result << collapse(array.at(i))
+          end
+        end
+
+        result
+      end
+      
+      def render(nodes, io=[], list_open='<ul>', list_close='</ul>', item_open='<li>', item_close='</li>', indent='', newline="\n", &block)
+        io << indent
+        io << list_open
+        io << newline
+
+        nodes.each do |node|
+          io << indent
+          io << item_open
+          
+          if node.kind_of?(Array)
+            io << newline
+            render(node, io, list_open, list_close, item_open, item_close, indent + '  ', newline, &block)
+            io << newline
+            io << indent
+          else
+            io << (block_given? ? yield(node) : node)
+          end
+          
+          io << item_close
+          io << newline
+        end
+
+        io << indent
+        io << list_close
+        io
+      end
+    end
+  end
+end

data/lib/gitgo/index.rb

@@ -0,0 +1,421 @@
+require 'enumerator'
+require 'gitgo/index/idx_file'
+require 'gitgo/index/sha_file'
+
+module Gitgo
+  
+  # Index provides an index of documents used to expedite searches.  Index
+  # structures it's data into a branch-specific directory structure:
+  #
+  #   .git/gitgo/refs/[branch]/index
+  #   |- filter
+  #   |  `- key
+  #   |     `- value
+  #   |
+  #   |- head
+  #   |- list
+  #   `- graph_map
+  #
+  # The files contain the following data (in conceptual order):
+  #
+  #   head      The user commit sha at which the last reindex occured.
+  #   list      A list of H* packed shas representing all of the documents
+  #             accessible by the gitgo branch. The index (idx) of the sha in
+  #             list serves as an identifier for the sha in map and filters.
+  #   map       A list of L* packed idx pairs mapping a document to its graph
+  #             head.
+  #   [value]   A list of L* packed idx that match the key-value pair. These
+  #             lists act as filters in searches.
+  #
+  # The packing format for each of the index files was chosen for performance;
+  # both to minimize the footprint of the file and optimize the usage of the
+  # file data.
+  #--
+  # Index also maintains a cache of temporary files that auto-expire after a
+  # certain period of time.  The temporary files contain H* packed shas and
+  # represent the results of various queries, such as rev-lists.
+  #++
+  # == Usage
+  #
+  # Index files are used primarily to select documents based on various
+  # filters. For example, to select the shas for all comments tagged as
+  # 'important' you would do this:
+  #
+  #   index = Index.new('path')
+  #
+  #   comment   = index['type']['comment']
+  #   important = index['tag']['important']
+  #   selected  = comment & important
+  #
+  #   heads = selected.collect {|id| idx.map[id] }
+  #   shas  = heads.collect {|id| idx.list[id] }.uniq
+  #
+  # The array operations are very quick because the filters are composed of
+  # integers, as is the map.  The final step resolves the integers to shas,
+  # but this too is simply an array lookup.  The select method encapsulates
+  # this logic:
+  #
+  #   shas = index.select(
+  #     :all => {'type' => 'comment', 'tag' => 'important'},
+  #     :map => true,
+  #     :shas => true
+  #   )
+  #
+  # Importantly, any of the index files can contain duplication without
+  # affecting the results of select; this allows new documents to be quickly
+  # added into a filter or appended to list/map. As needed or convenient, the
+  # index can compact itself and remove duplication.
+  #
+  class Index
+    
+    # A file containing the ref at which the last index was performed; used to
+    # determine when a reindex is required relative to some other ref.
+    HEAD = 'head'
+    
+    # An idx file mapping shas to their graph heads
+    MAP = 'map'
+    
+    # A sha file listing indexed shas; the index of the sha is used as an
+    # identifer for the sha in all idx files.
+    LIST = 'list'
+    
+    # The filter directory
+    FILTER = 'filter'
+    
+    # The head file for self
+    attr_reader :head_file
+    
+    # The map file for self
+    attr_reader :map_file
+    
+    # The list file for self
+    attr_reader :list_file
+    
+    # Returns an in-memory, self-filling cache of idx files
+    attr_reader :cache
+    
+    def initialize(path)
+      @path = path
+      @head_file = File.expand_path(HEAD, path)
+      @map_file = File.expand_path(MAP, path)
+      @list_file = File.expand_path(LIST, path)
+      
+      @cache = Hash.new do |key_hash, key|
+        key_hash[key] = Hash.new do |value_hash, value|
+          value_hash[value] = begin
+            index = self.path(FILTER, key, value)
+            File.file?(index) ? IdxFile.read(index) : []
+          end
+        end
+      end
+    end
+    
+    # Returns the sha in the head_file, if it exists, and nil otherwise.
+    def head
+      File.exists?(head_file) ? File.open(head_file) {|io| io.read(40) } : nil
+    end
+    
+    # Returns the contents of map_file, as a hash.
+    def map
+      @map ||= begin
+        entries = File.exists?(map_file) ? IdxFile.read(map_file) : []
+        Hash[*entries]
+      end
+    end
+    
+    # Returns the contents of list_file, as an array.
+    def list
+      @list ||= (File.exists?(list_file) ? ShaFile.read(list_file) : [])
+    end
+    
+    # Returns the segments joined to the path used to initialize self.
+    def path(*segments)
+      File.join(@path, *segments)
+    end
+    
+    # Returns cache[key], a self-filling hash of filter values.  Be careful
+    # not to modify index[k][v] as it is the actual cache storage.
+    def [](key)
+      cache[key]
+    end
+    
+    # Returns the idx for sha, as specified in list.  If the sha is not in
+    # list then it is appended to list.
+    def idx(sha)
+      case
+      when list[-1] == sha
+        list.length - 1
+      when idx = list.index(sha)
+        idx
+      else
+        idx = list.length
+        list << sha
+        idx
+      end
+    end
+    
+    # Return the graph head idx for the specified idx.
+    def graph_head_idx(idx)
+      deconvolute(idx, map)
+    end
+    
+    def assoc(source, target, type)
+      source_idx = idx(source)
+      target_idx = idx(target)
+      map[target_idx] = source_idx
+      tail_filter << source_idx unless type == :create
+      delete_filter << source_idx if type == :delete
+      self
+    end
+    
+    def create(source)
+      source_idx = idx(source)
+
+      head_idx = graph_head_idx(source_idx)
+      unless head_idx.nil? || head_idx == source_idx
+        raise "create graph fail: #{source} (already associated with graph #{list[head_idx]})"
+      end
+
+      map[source_idx] = source_idx
+      self
+    end
+    
+    def link(source, target)
+      associate :link, source, target
+    end
+    
+    def update(source, target)
+      associate :update, source, target
+    end
+    
+    def delete(source)
+      source_idx = idx(source)
+      tail_filter << source_idx
+      delete_filter << source_idx
+      self
+    end
+    
+    # Returns a list of possible index keys.
+    def keys
+      keys = cache.keys
+      
+      Dir.glob(self.path(FILTER, '*')).select do |path|
+        File.directory?(path)
+      end.each do |path|
+        keys << File.basename(path)
+      end
+      
+      keys.uniq!
+      keys
+    end
+    
+    # Returns a list of possible values for the specified index key.
+    def values(key)
+      values = cache[key].keys
+      
+      base  = path(FILTER, key)
+      start = base.length + 1
+      Dir.glob("#{base}/**/*").each do |value_path|
+        values << value_path[start, value_path.length-start]
+      end
+      
+      values.uniq!
+      values
+    end
+    
+    def all(*keys)
+      results = []
+      keys.collect do |key|
+        values(key).each do |value|
+          results.concat(cache[key][value])
+        end
+      end
+      results.uniq!
+      results
+    end
+    
+    def each_idx(key, values)
+      unless values.respond_to?(:each)
+        values = [values]
+      end
+      
+      values.each do |value|
+        cache[key][value].each do |idx|
+          yield idx
+        end
+      end
+    end
+    
+    def each_sha(key, values, filter=delete_filter)
+      each_idx(key, values) do |idx|
+        next if filter.include?(idx)
+        yield list[idx]
+      end
+    end
+    
+    def join(key, *values)
+      values.collect {|value| cache[key][value] }.flatten
+    end
+    
+    def select(options={})
+      basis = options[:basis] || (0..list.length).to_a
+      
+      if all = options[:all]
+        each_pair(all) do |key, value|
+          basis = basis & cache[key][value]
+          break if basis.empty?
+        end
+      end
+      
+      if any = options[:any]
+        matches = []
+        each_pair(any) do |key, value|
+          matches.concat cache[key][value]
+        end
+        basis = basis & matches
+      end
+      
+      if options[:map]
+        basis.collect! {|idx| map[idx] }
+      end
+      
+      if options[:shas]
+        basis.collect! {|idx| list[idx] }
+      end
+      
+      basis.uniq!
+      basis
+    end
+    
+    def compact
+      # reindex shas in list, and create an idx map for updating idxs
+      old_list = {}
+      list.each {|sha| old_list[old_list.length] = sha }
+      
+      list.uniq!
+      
+      new_list = {}
+      list.each {|sha| new_list[sha] = new_list.length}
+      
+      idx_map = {}
+      old_list.each_pair {|idx, sha| idx_map[idx] = new_list[sha]}
+      
+      # update/deconvolute mapped idx values
+      new_map = {}
+      map.each_pair {|idx, head_idx| new_map[idx_map[idx]] = idx_map[head_idx] }
+      new_map.keys.each {|idx| new_map[idx] = deconvolute(idx, new_map) || idx }
+      
+      @map = new_map
+      
+      # update filter values
+      @cache.values.each do |value_hash|
+        value_hash.values.each do |idxs|
+          idxs.collect! {|idx| idx_map[idx] }.uniq!
+        end
+      end
+      
+      self
+    end
+    
+    # Writes cached changes.
+    def write(sha=nil)
+      @cache.each_pair do |key, value_hash|
+        value_hash.each_pair do |value, idx|
+          IdxFile.write(path(FILTER, key, value), idx)
+        end
+      end
+      
+      FileUtils.mkdir_p(path) unless File.exists?(path)
+      File.open(head_file, "w") {|io| io.write(sha) } if sha
+      ShaFile.write(list_file, list.join)
+      IdxFile.write(map_file, map.to_a.flatten)
+      
+      self
+    end
+    
+    # Clears the cache.
+    def reset
+      @list = nil
+      @map = nil
+      @cache.clear
+      self
+    end
+    
+    # Clears all index files, and the cache.
+    def clear
+      if File.exists?(path)
+        FileUtils.rm_r(path)
+      end
+      reset
+    end
+    
+    private
+    
+    # walks up the map to find the graph head for idx.  returns nil if idx is not
+    # associated with a graph
+    def deconvolute(idx, map, visited=nil) # :nodoc:
+      head_idx = map[idx]
+      
+      if visited.nil?
+        if head_idx.nil?
+          return nil
+        else
+          visited = []
+        end
+      end
+      
+      circular = visited.include?(idx)
+      visited << idx
+      
+      if circular
+        raise "cannot deconvolute cyclic graph: #{visited.inspect}"
+      end
+      
+      head_idx == idx ? idx : deconvolute(head_idx, map, visited)
+    end
+    
+    def delete_filter
+      cache['filter']['delete']
+    end
+    
+    def tail_filter
+      cache['filter']['tail']
+    end
+    
+    def associate(type, source, target) # :nodoc:
+      if source == target
+        raise "#{type} fail: #{source} -> #{target} (cannot #{type} with self)"
+      end
+      
+      source_idx = idx(source)
+      target_idx = idx(target)
+
+      source_head_idx = graph_head_idx(source_idx)
+      if source_head_idx.nil?
+        raise "#{type} fail: #{source} -> #{target} (source is not associated with a graph)"
+      end
+
+      target_head_idx = graph_head_idx(target_idx)
+      unless target_head_idx.nil? || target_head_idx == source_head_idx
+        raise "#{type} fail: #{source} -> #{target} (different graph heads #{list[source_head_idx]}/#{list[target_head_idx]})"
+      end
+      
+      map[target_idx] = source_head_idx
+      tail_filter << source_idx
+
+      self
+    end
+    
+    def each_pair(pairs) # :nodoc:
+      pairs.each_pair do |key, values|
+        unless values.kind_of?(Array)
+          values = [values]
+        end
+        
+        values.each do |value|
+          yield(key, value)
+        end
+      end
+    end
+  end
+end