gitgo 0.3.3

data/History

@@ -0,0 +1,44 @@
+== 0.3.3 2010-04-28
+
+Fixed (hopefully) usage in repos with no user name/email set.
+
+== 0.3.2 2010-04-27
+
+Fixed (hopefully) the cause of zero-padded file modes warning.
+
+== 0.3.1 2010-04-26
+
+Improvements to repo lifecycle.
+
+== 0.3.0 2010-04-26
+
+Updated internal data store to (more or less) halve the overhead of each new
+document by storing document information inline with associations. Index now
+assigns shas an integer index for faster comparisons and smaller index files.
+Continued overhaul of internals. General updates to the interface.
+
+== 0.2.0 2010-03-29
+
+This release significantly changes the internals of Gitgo. Old gitgo branches
+will not be compatible. To migrate a gitgo-0.1.* branch to the new storage
+format:
+
+  % git clone git://github.com/bahuvrihi/gitgo.git
+  % cd gitgo
+  % git checkout migrate-0.2.0
+  % ruby script/migrate-0.2.0.rb PATH_TO_REPO SOURCE_BRANCH TARGET_BRANCH
+
+Then rename the target branch as necessary. You will also have to remove the
+old gitgo files:
+
+  % cd <path_to_repo>
+  % rm -rf .git/gitgo
+
+Major changes:
+
+* changed document serialization format to JSON
+* complete overhaul of internal classes
+* implemented a more robust system for calculating
+  (and drawing) a document graph
+* temporary removal of comments
+* improvements to indexing system

data/License.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Pinnacol Assurance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software. Except as contained in this
+notice, the name(s) of the above copyright holders shall not be used in
+advertising or otherwise to promote the sale, use or other dealings in this
+Software without prior written authorization.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README

@@ -0,0 +1,45 @@
+= Gitgo
+
+Gitgo -- git-driven issues, comments, and a wiki... to go.
+
+== Description
+
+Gitgo is an issue tracker that stores issue information in a git repository.
+
+At present gitgo is in a developmental state. While the backend and data model
+both work and appear to be robust, the front-end is highly lacking. Usage will
+be difficult without insider knowledge.
+
+== Usage
+
+In the working directory for a git repository:
+
+  % gitgo
+
+Then visit http://localhost:8080 in a web browser. 
+
+== Installation
+
+Gitgo is not available as a gem yet.  To clone the project and build your own:
+
+  % git clone git://github.com/pinnacol/gitgo.git
+  % cd gitgo
+  % rake gem
+  % gem install pkg/gitgo-...
+
+== Development 
+
+Gitgo is open-source and welcomes help from the community!  To get started:
+
+  % git clone git://github.com/pinnacol/gitgo.git
+  % cd gitgo
+  % rake test
+
+To see bugs tracked in the gitgo repo:
+
+  % bin/gitgo
+
+== Info 
+
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com]
+License:: {MIT-Style}[link:files/License_txt.html]

data/bin/gitgo

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'gitgo'
+Gitgo::Server.start

data/lib/gitgo.rb

@@ -0,0 +1 @@
+require 'gitgo/server'

data/lib/gitgo/app.rb

@@ -0,0 +1,63 @@
+require 'gitgo/controller'
+require 'gitgo/controllers/code'
+require 'gitgo/controllers/issue'
+require 'gitgo/controllers/repo'
+require 'gitgo/controllers/wiki'
+
+module Gitgo
+  class App < Controller
+    set :views, File.expand_path("views/app", ROOT)
+    set :static, true
+    
+    get('/')         { repo.head ? index : welcome }
+    get('/timeline') { timeline }
+    
+    use Controllers::Code
+    use Controllers::Issue
+    use Controllers::Wiki
+    use Controllers::Repo
+    
+    def index
+      erb :index
+    end
+    
+    def welcome
+      erb :welcome, :locals => {
+        :branch => repo.branch,
+        :remotes => repo.refs
+      }
+    end
+    
+    def timeline
+      Document.update_index
+      
+      page = (request[:page] || 0).to_i
+      per_page = (request[:per_page] || 5).to_i
+      
+      author = request[:author]
+      author = '' if author == 'unknown'
+      
+      docs = repo.timeline(:n => per_page, :offset => page * per_page) do |sha|
+        author.nil? || repo[sha]['author'].include?("<#{author}>")
+      end.collect do |sha|
+        Document.cast(repo[sha], sha)
+      end.sort_by do |doc|
+        doc.date
+      end
+      
+      erb :timeline, :locals => {
+        :page => page,
+        :per_page => per_page,
+        :docs => docs,
+        :author => author,
+        :authors => repo.index.values('email'),
+        :active_sha => session_head
+      }
+    end
+    
+    def build_query(params)
+      params.delete_if {|key, value| value.nil? }
+      super(params)
+    end
+  end
+end

data/lib/gitgo/controller.rb

@@ -0,0 +1,89 @@
+require 'erb'
+require 'sinatra/base'
+require 'gitgo/helper'
+require 'gitgo/document'
+require 'gitgo/rest'
+
+module Gitgo
+  class Controller < Sinatra::Base
+    ROOT = File.expand_path(File.dirname(__FILE__) + "/../..")
+    HEAD  = 'gitgo.head'
+    MOUNT = 'gitgo.mount'
+    
+    set :root, ROOT
+    set :raise_errors, Proc.new { test? }
+    set :dump_errors, true
+    
+    template(:layout) do 
+      File.read(File.join(ROOT, "views/layout.erb"))
+    end
+    
+    not_found do
+      erb :not_found, :views => path("views")
+    end
+    
+    error Exception do
+      err = env['sinatra.error']
+      resetable = err.kind_of?(Errno::ENOENT) && err.message =~ /No such file or directory - .*idx/
+      
+      erb :error, :views => path("views"), :locals => {:err => err, :resetable => resetable}
+    end
+    
+    def initialize(app=nil, repo=nil)
+      super(app)
+      @repo = repo
+    end
+    
+    # Returns the path expanded relative to the Gitgo::ROOT directory.  Paths
+    # often need to be expanded like this so that they will be correct when
+    # Gitgo is running as a gem.
+    def path(path)
+      File.expand_path(path, ROOT)
+    end
+    
+    def repo
+      @repo ||= Repo.current
+    end
+    
+    def call(env)
+      env[Repo::REPO] ||= @repo
+      Repo.with_env(env) { super(env) }
+    end
+    
+    def session_head
+      # grit.head will be nil if not on a local branch
+      @session_head ||= begin
+        if session.has_key?(HEAD)
+          session[HEAD]
+        else
+          grit = repo.git.grit
+          session[HEAD] = grit.head ? grit.head.name : nil
+        end
+      end
+    end
+    
+    def session_head=(input)
+      @session_head = session[HEAD] = input
+    end
+    
+    def mount_point
+      @mount_point ||= (env[MOUNT] || '/')
+    end
+    
+    def url(paths)
+      File.join(mount_point, *paths)
+    end
+    
+    def format
+      @format ||= Helper::Format.new(self)
+    end
+    
+    def form
+      @form ||= Helper::Form.new(self)
+    end
+    
+    def html
+      Helper::Html
+    end
+  end
+end

data/lib/gitgo/controllers/code.rb

@@ -0,0 +1,198 @@
+require 'gitgo/controller'
+require 'gitgo/documents/comment'
+
+module Gitgo
+  module Controllers
+    class Code < Controller
+      include Rest
+      
+      set :views, File.expand_path("views/code", ROOT)
+      
+      get('/code')            { index }
+      get('/blob')            { blob_grep }
+      get('/tree')            { tree_grep }
+      get('/commit')          { commit_grep }
+
+      get('/blob/:treeish/*')  {|treeish, path| show_blob(treeish, path) }
+      get('/tree/:treeish')    {|treeish| show_tree(treeish, '') }
+      get('/tree/:treeish/*')  {|treeish, path| show_tree(treeish, path) }
+      get('/commit/:treeish')  {|treeish| show_commit(treeish) }
+      get('/commits/:treeish') {|treeish| show_commits(treeish) }
+      get('/obj/:sha')         {|sha| show_object(sha) }
+
+      get('/comment/:sha')     {|sha| read(sha) }
+      post('/comment')         { create }
+      post('/comment/:sha') do |sha|
+        _method = request[:_method]
+        case _method
+        when /\Aupdate\z/i then update(obj)
+        when /\Adelete\z/i then destroy(obj)
+        else raise("unknown post method: #{_method}")
+        end
+      end
+      put('/comment/:sha')     {|sha| update(sha) }
+      delete('/comment/:sha')  {|sha| destroy(sha) }
+      
+      Comment = Documents::Comment
+      
+      def git
+        @git ||= repo.git
+      end
+      
+      def grit
+        @grit ||= git.grit
+      end
+      
+      def model
+        Comment
+      end
+      
+      #
+      # actions
+      #
+      
+      def index
+        erb :index, :locals => {
+          :branches => grit.branches,
+          :tags => grit.tags
+        }
+      end
+      
+      def treeish
+        request['at'] || grit.head.commit
+      end
+      
+      def grep_opts(overrides={})
+        {
+          :ignore_case   => request['ignore_case'] == 'true',
+          :invert_match  => request['invert_match'] == 'true',
+          :fixed_strings => request['fixed_strings'] == 'true',
+        }.merge!(overrides)
+      end
+      
+      def blob_grep
+        options = grep_opts(:e => request['pattern'])
+        
+        selected = []
+        git.grep(options, treeish) do |path, blob|
+          selected << [path, blob.id]
+        end
+
+        erb :grep, :locals => options.merge!(
+          :type => 'blob',
+          :at => treeish,
+          :selected => selected,
+          :refs => grit.refs
+        )
+      end
+
+      def tree_grep
+        options = grep_opts(:e => request['pattern'])
+        
+        selected = []
+        git.tree_grep(options, treeish) do |path, blob|
+          selected << [path, blob.id]
+        end
+        
+        erb :grep, :locals => options.merge!(
+          :type => 'tree',
+          :at => treeish,
+          :selected => selected,
+          :refs => grit.refs
+        )
+      end
+
+      def commit_grep
+        options = grep_opts(
+          :author => request['author'],
+          :committer => request['committer'],
+          :grep => request['grep'],
+          :regexp_ignore_case => request['regexp_ignore_case'] == 'true',
+          :fixed_strings => request['fixed_strings'] == 'true',
+          :all_match => request['all_match'] == 'true',
+          :max_count => request['max_count'] || '10'
+        )
+        
+        selected = []
+        git.commit_grep(options, treeish) {|sha| selected << sha }
+        
+        erb :commit_grep, :locals => options.merge!(
+          :selected => selected
+        )
+      end
+
+      def show_blob(treeish, path)
+        commit = grit.commit(treeish) || not_found
+        blob = commit.tree / path || not_found
+
+        erb :blob, :locals => {
+          :commit => commit, 
+          :treeish => treeish, 
+          :blob => blob, 
+          :path => path
+        }
+      end
+
+      def show_tree(treeish, path)
+        commit = grit.commit(treeish) || not_found
+        tree = path.split("/").inject(commit.tree) do |obj, name|
+          not_found if obj.nil?
+          obj.trees.find {|obj| obj.name == name }
+        end
+
+        erb :tree, :locals => {
+          :commit => commit, 
+          :treeish => treeish, 
+          :tree => tree, 
+          :path => path
+        }
+      end
+      
+      def show_commit(treeish)
+        commit = grit.commit(treeish) || not_found
+        erb :diff, :locals => {
+          :commit => commit, 
+          :treeish => treeish
+        }
+      end
+      
+      def show_commits(treeish)
+        commit = grit.commit(treeish)
+        page = (request[:page] || 0).to_i
+        per_page = (request[:per_page] || 10).to_i
+
+        erb :commits, :locals => {
+          :treeish => treeish,
+          :page => page,
+          :per_page => per_page,
+          :commits => grit.commits(commit.sha, per_page, page * per_page)
+        }
+      end
+      
+      def show_object(sha)
+        sha = git.resolve(sha)
+        
+        case
+        when request['content'] == 'true'
+          response['Content-Type'] = 'text/plain'
+          grit.git.cat_file({:p => true}, sha)
+          
+        when request['download'] == 'true'
+          response['Content-Type'] = 'text/plain'
+          response['Content-Disposition'] = "attachment; filename=#{sha};"
+          raw_object = grit.git.ruby_git.get_raw_object_by_sha1(sha)
+          "%s %d\0" % [raw_object.type, raw_object.content.length] + raw_object.content
+          
+        else
+          type = git.type(sha).to_sym
+          obj = git.get(type, sha) or not_found
+          
+          erb type, :locals => {
+            :sha => sha, 
+            :obj => obj
+          }, :views => path('views/code/obj')
+        end
+      end
+    end
+  end
+end