gitgo 0.3.3

data/lib/gitgo/git/tree.rb

@@ -0,0 +1,315 @@
+module Gitgo
+  class Git
+    
+    # Tree represents an in-memory working tree for git. Trees are initialized
+    # with a Grit::Tree.  In general tree contents are represented as (path,
+    # [:mode,sha]) pairs, but subtrees can be expanded into (path, Tree)
+    # pairs.
+    #
+    # See Git for an example of Tree usage in practice.
+    #
+    # === Efficiency
+    #
+    # Modes are symbolized in the internal [:mode,sha] entries because they
+    # are rarely needed as strings and are typically very redundant. 
+    # Symbolizing shas makes less sense because they are frequently used as
+    # strings. However it does make sense to use the same string instance to
+    # represent a sha in multiple places.  As a result trees have an internal
+    # string_table that functions like a symbol table, ie it maps the same
+    # string content to a single shared instance.  The string table is managed
+    # at the class level through the string_table method.
+    #
+    # Trees only expand as needed.  This saves memory and cycles because it is
+    # expensive to read, parse, and maintain the git tree data.  In general
+    # trees will stay fairly compact unless certain expensive operations are
+    # performed.  These are:
+    #
+    # * each_pair (with expand == true)
+    # * each_tree (with expand == true)
+    # * flatten
+    # * to_hash   (with expand == true)
+    #
+    # Avoid these methods if possible, or ensure they are rarely executed.
+    class Tree
+      class << self
+        
+        # Returns the string table for shas.  Specify clear to reset the
+        # string table.
+        def string_table(clear=false)
+          @string_table.clear if clear
+          @string_table ||= Hash.new {|hash, key| hash[key] = key.freeze }
+        end
+      end
+      include Enumerable
+      
+      # The tree mode.
+      attr_reader :mode
+      
+      # Initializes a new Tree.  The input tree should be a Grit::Tree or nil.
+      def initialize(tree=nil)
+        @index = nil
+        @tree = tree
+        
+        if tree
+          self.mode = tree.mode
+          self.sha  = tree.id
+        else
+          @mode = nil
+          @sha = nil
+        end
+      end
+      
+      # Sets mode, symbolizing if necessary.  Mode may be set to nil in which
+      # case the git.default_tree_mode is adopted when the tree is written.
+      def mode=(mode)
+        @mode = mode ? mode.to_sym : nil
+      end
+      
+      # Sets the sha for self.  Sha may be set to nil, in which case it will
+      # be calculated when a repo is committed.
+      def sha=(sha)
+        @sha = sha ? string(sha) : nil
+      end
+      
+      # Returns the sha representing the contents for self.  If check is true,
+      # sha will check that neither self nor any subtree is modified before
+      # returning the sha.  If modified, the sha is set to nil to flag a repo
+      # to recalculate the sha on commit.
+      #
+      # Note that check does not validate the sha correctly represents the
+      # contents of self.
+      def sha(check=true)
+        if @sha && check
+          index.each_value do |value|
+            if value.kind_of?(Tree) && value.sha.nil?
+              @sha = nil
+              break
+            end
+          end
+        end
+      
+        @sha
+      end
+      
+      # Returns the keys (ie paths) for all entries in self.  Keys are
+      # returned as strings
+      def keys
+        index.keys.collect {|keys| keys.to_s }
+      end
+      
+      # Returns the entry for the specified path, either a [:mode,sha] pair
+      # for a blob or a Tree for a subtree.
+      def [](path)
+        case
+        when entry = index[path]
+          entry
+        when tree = index.delete(path.to_sym)
+          index[string(path)] = Tree.new(tree)
+        else
+          nil
+        end
+      end
+      
+      # Sets the entry for the specified path.  The entry should be a
+      # [:mode,sha] array, or a Tree.  A nil entry indicates removal.
+      def []=(path, entry)
+        # ensure an unexpanded tree is removed
+        index.delete(path.to_sym)
+        
+        path = string(path)
+        case entry
+        when Array
+          mode, sha = entry
+          index[path] = [mode.to_sym, string(sha)]
+        when Tree
+          index[path] = entry
+        when nil
+          index.delete(path)
+        else
+          raise "invalid entry: #{entry.inspect}"
+        end
+        
+        # add/remove content modifies self so
+        # the sha can and should be invalidated
+        @sha = nil
+      end
+      
+      def merge!(another)
+        another.each_pair do |path, entry|
+          self[path] = entry
+        end
+        self
+      end
+      
+      # Yields each (path, entry) pair to the block, as an array, ordered by
+      # path. Implemented to get access to the enumerable methods.
+      def each
+        each_pair do |key, value|
+          yield [key, value]
+        end
+        self
+      end
+      
+      # Yields each (path, entry) pair to the block, ordered by path.  Entries
+      # can be [:mode,sha] arrays or Trees.  If expand is true then subtrees
+      # will be expanded, but strongly consider whether or not expansion is
+      # necessary because it is computationally expensive.
+      def each_pair(expand=false)
+        
+        # sorting the keys is important when writing the tree;
+        # unsorted keys cause warnings in git fsck
+        keys = index.keys.sort_by {|key| key.to_s }
+        store = expand ? self : index
+        
+        keys.each {|key| yield(key, store[key]) }
+      end
+      
+      # Yields the (path, [:mode, sha]) pairs for each blob to the block.
+      def each_blob
+        each_pair do |key, value|
+          next unless value.kind_of?(Array)
+          yield(key, value)
+        end
+      end
+      
+      # Yields the (path, entry) pairs for each tree to the block.  Subtrees
+      # are expanded if specified, in which case all entries will be Trees.
+      # Without expansion, entries may be [:mode,sha] arrays or Trees.
+      def each_tree(expand=false)
+        each_pair(expand) do |key, value|
+          next unless value.kind_of?(Tree)
+          yield(key, value)
+        end
+      end
+      
+      # Returns the subtree indicated by the specified segments (an array of
+      # paths), or nil if no such subtree exists.  If force is true then
+      # missing subtrees will be created.
+      def subtree(segments, force=false)
+        return self if segments.empty?
+        
+        key = segments.shift
+        tree = self[key]
+
+        if !tree.kind_of?(Tree)
+          return nil unless force
+          self[key] = tree = Tree.new(nil)
+        end
+        
+        tree.subtree(segments, force)
+      end
+      
+      # Flattens all paths under self into a single array.
+      def flatten(prefix=nil, target={})
+        keys.each do |key|
+          next unless entry = self[key]
+
+          key = key.to_s
+          key = File.join(prefix, key) if prefix
+
+          if entry.kind_of?(Tree)
+            entry.flatten(key, target)
+          else
+            target[key] = entry
+          end
+        end
+
+        target
+      end
+      
+      # Returns self as a hash, expanding if specified.
+      def to_hash(expand=false)
+        hash = {}
+        each_pair(expand) do |key, value|
+          hash[key] = case value
+          when Tree  then value.to_hash
+          when Array then value
+          else to_entry(value)
+          end
+        end
+        hash
+      end
+      
+      # Returns true if the to_hash results of self and another are equal.
+      def eql?(another)
+        self.to_hash == another.to_hash
+      end
+      
+      # Returns true if the to_hash results of self and another are equal.
+      def ==(another)
+        self.to_hash == another.to_hash
+      end
+      
+      # Writes self to the git instance.  All subtrees will likewise be
+      # written.  Returns a [mode, sha] entry.
+      #
+      # Tree format:
+      #
+      #   mode name\0[packedsha]mode name\0[packedsha]...
+      #
+      # Note there are no newlines separating tree entries.
+      def write_to(git)
+        self.mode ||= git.default_tree_mode
+        self.sha  ||= begin
+          lines = []
+          each_pair(false) do |key, entry|
+            mode, sha = case entry
+            when Tree  then entry.write_to(git)
+            when Array then entry
+            else [entry.mode, entry.id]
+            end
+            
+            # modes should not begin with zeros (although it is not fatal
+            # if they do), otherwise fsck will print warnings like this:
+            #
+            # warning in tree 980127...: contains zero-padded file modes
+            lines << zero_strip("#{mode} #{key}\0#{[sha].pack("H*")}")
+          end
+
+          git.set(:tree, lines.join)
+        end
+
+        [mode, sha]
+      end
+      
+      protected
+      
+      # returns or initializes the internal working tree (index)
+      def index # :nodoc:
+        @index ||= begin
+          index = {}
+          
+          @tree.contents.each do |obj|
+            key = obj.name
+            if obj.respond_to?(:contents)
+              index[key.to_sym] = obj
+            else
+              index[string(key)] = to_entry(obj)
+            end
+          end if @tree
+          @tree = nil
+          
+          index
+        end
+      end
+      
+      # helper to lookup the string table entry for key
+      def string(key) # :nodoc:
+        Tree.string_table[key.to_s]
+      end
+      
+      # converts obj into a [:mode, sha] entry
+      def to_entry(obj) # :nodoc:
+        [obj.mode.to_sym, string(obj.id)]
+      end
+      
+      def zero_strip(str) # :nodoc:
+        return str unless str[0] == ?0
+        
+        index = 1
+        index += 1 while str[index] == ?0
+        str[index, str.length - index]
+      end
+    end
+  end
+end

data/lib/gitgo/git/utils.rb

@@ -0,0 +1,59 @@
+module Gitgo
+  class Git
+    
+    # A set of utility functions split out for ease of testing.
+    module Utils
+      module_function
+      
+      # Executes the block having set the env variables.  All ENV variables
+      # that start with GIT_ will be removed regardless of whether they are
+      # specified in env or not.
+      def with_env(env={})
+        overrides = {}
+        begin
+          ENV.keys.each do |key|
+            if key =~ /^GIT_/
+              overrides[key] = ENV.delete(key)
+            end
+          end
+
+          env.each_pair do |key, value|
+            overrides[key] ||= nil
+            ENV[key] = value
+          end
+
+          yield
+        ensure
+          overrides.each_pair do |key, value|
+            if value
+              ENV[key] = value
+            else
+              ENV.delete(key)
+            end
+          end
+        end
+      end
+      
+      # Splits a path along slashes into an array, stripping empty strings
+      # from each end. An array may be provided in place of path; it will be
+      # duplicated before being stripped of nil/empty entries.
+      def split(path)
+        array = path.kind_of?(String) ? path.split("/") : path.dup
+        array.shift if nil_or_empty_string?(array[0])
+        array.pop   if nil_or_empty_string?(array[-1])
+        array
+      end
+      
+      # Returns true if the object is nil, or empty, and assumes the object is
+      # a string (ie that it responds to empty?).
+      def nil_or_empty_string?(obj)
+        obj.nil? || obj.empty?
+      end
+      
+      # Returns true if the object is nil, or responds to empty and is empty.
+      def nil_or_empty?(obj)
+        obj.nil? || (obj.respond_to?(:empty?) && obj.empty?)
+      end
+    end
+  end
+end

data/lib/gitgo/helper.rb

@@ -0,0 +1,3 @@
+require 'gitgo/helper/format'
+require 'gitgo/helper/form'
+require 'gitgo/helper/html'

data/lib/gitgo/helper/doc.rb

@@ -0,0 +1,28 @@
+module Gitgo
+  module Helper
+    class Doc
+      
+      attr_reader :controller
+      
+      def initialize(controller)
+        @controller = controller
+      end
+      
+      def url(*paths)
+        controller.url(*paths)
+      end
+      
+      def at
+        controller.user_ref
+      end
+      
+      def active_shas
+        @active_shas ||= repo.rev_list(at)
+      end
+      
+      def active?(sha)
+        at && active_shas.include?(sha)
+      end
+    end
+  end
+end

data/lib/gitgo/helper/form.rb

@@ -0,0 +1,88 @@
+require 'rack/utils'
+
+module Gitgo
+  module Helper
+    class Form
+      include Rack::Utils
+      
+      DEFAULT_STATES = %w{open closed}
+      
+      attr_reader :controller
+      
+      def initialize(controller)
+        @controller = controller
+      end
+      
+      def url(*paths)
+        controller.url(paths)
+      end
+      
+      #
+      #
+      #
+      
+      def value(str)
+        str
+      end
+      
+      #
+      # documents
+      #
+      
+      def at(sha)
+        return '(unknown)' unless sha
+        
+        refs = refs.select {|ref| ref.commit.sha == sha }
+        refs.collect! {|ref| escape_html ref.name }
+        
+        ref_names = refs.empty? ? nil : " (#{refs.join(', ')})"
+        "#{sha_a(sha)}#{ref_names}"
+      end
+      
+      def author_value(author)
+        escape_html(author)
+      end
+      
+      def title_value(title)
+        escape_html(title)
+      end
+      
+      def tags_value(tags)
+        tags ? tags.join(', ') : ''
+      end
+      
+      def content_value(content)
+        content
+      end
+      
+      def each_tag(tags, *selected) # :yields: value, select_or_check, content
+        tags.sort.each do |tag|
+          yield escape_html(tag), selected.include?(tag), escape_html(tag)
+        end
+      end
+      
+      def each_ref(refs, selected_name) # :yields: value, select_or_check, content
+        refs.each do |ref|
+          yield escape_html(ref.commit), selected_name == ref.name, escape_html(ref.name)
+        end
+      end
+      
+      def each_ref_name(refs, selected_name) # :yields: value, select_or_check, content
+        found_selected_name = false
+        
+        refs.each do |ref|
+          select_or_check = selected_name == ref.name
+          found_selected_name = true if select_or_check
+          
+          yield escape_html(ref.name), select_or_check, escape_html(ref.name)
+        end
+        
+        if found_selected_name
+          yield("", false, "(none)")
+        else
+          yield(selected_name, true, selected_name.to_s.empty? ? "(none)" : selected_name)
+        end
+      end
+    end
+  end
+end