ginatra 3.0.1 → 4.0.0

data/lib/ginatra/repo.rb

@@ -1,113 +1,103 @@
-require "grit"
-
-module Grit
-  class Commit
-    # this lets us add a link between commits and refs directly
-    attr_accessor :refs
-
-    def ==(other_commit)
-      id == other_commit.id
-    end
-  end
-end
+require 'rugged'
 
 module Ginatra
-
-  # A thin wrapper to the Grit::repo class so that we can add a name and a url-sanitised-name
-  # to a repo, and also intercept and add refs to the commit objects.
   class Repo
-
     attr_reader :name, :param, :description
 
     # Create a new repository, and sort out clever stuff including assigning
     # the param, the name and the description.
     #
-    # @todo cleanup!
-    #
     # @param [String] path a path to the repository you want created
     # @return [Ginatra::Repo] a repository instance
     def initialize(path)
-      @repo = Grit::Repo.new(path)
+      @repo = Rugged::Repository.new(path)
       @param = File.split(path).last
       @name = @param
-      @description = @repo.description
-      @description = "Please edit the #{@repo.path}/description file for this repository and set the description for it." if /^Unnamed repository;/.match(@description)
+      @description = File.read("#{@repo.path}description").strip
+      @description = '' if @description.match(/\AUnnamed repository;/)
     end
 
-    def ==(other_repo)
-      # uses method_missing
-      path == other_repo.path
+    # Return a commit corresponding to sha in the repo.
+    #
+    # @param [String] sha the commit id or tag name
+    # @return [Rugged::Commit] the commit object
+    def commit(sha)
+      @repo.lookup(sha)
     end
 
-    # Return a commit corresponding to the commit to the repo,
-    # but with the refs already attached.
-    #
-    # @see Ginatra::Repo#add_refs
-    #
-    # @raise [Ginatra::InvalidCommit] if the commit doesn't exist.
-    #
-    # @param [String] id the commit id
-    # @return [Grit::Commit] the commit object.
-    def commit(id)
-      @commit = @repo.commit(id)
-      raise(Ginatra::InvalidCommit.new(id)) if @commit.nil?
-      add_refs(@commit,{})
-      @commit
+    # Return a commit corresponding to tag in the repo.
+    def commit_by_tag(name)
+      target = @repo.ref("refs/tags/#{name}").target
+
+      if target.is_a? Rugged::Tag::Annotation
+        target = target.target
+      end
+
+      target
     end
 
-    # Return a list of commits to a certain branch, including pagination options and all the refs.
+    # Return a list of commits in a certain branch, including pagination options and all the refs.
     #
     # @param [String] start the branch to look for commits in
     # @param [Integer] max_count the maximum count of commits
     # @param [Integer] skip the number of commits in the branch to skip before taking the count.
     #
-    # @raise [Ginatra::Error] if max_count is less than 0. silly billy!
-    #
-    # @return [Array<Grit::Commit>] the array of commits.
-    def commits(start = 'master', max_count = 10, skip = 0)
-      raise(Ginatra::Error.new("max_count cannot be less than 0")) if max_count < 0
-      refs_cache = {}
-      @repo.commits(start, max_count, skip).each do |commit|
-        add_refs(commit,refs_cache)
-      end
+    # @return [Array<Rugged::Commit>] the array of commits.
+    def commits(branch='master', max_count=10, skip=0)
+      raise Ginatra::InvalidRef unless branch_exists?(branch)
+
+      walker = Rugged::Walker.new(@repo)
+      walker.sorting(Rugged::SORT_TOPO)
+      walker.push(@repo.ref("refs/heads/#{branch}").target)
+
+      commits = walker.collect {|commit| commit }
+      commits[skip, max_count]
     end
 
-    # Return a list of commits like --all, including pagination options and all the refs.
-    #
-    # @param [Integer] max_count the maximum count of commits
-    # @param [Integer] skip the number of commits in the branch to skip before taking the count.
-    #
-    # @raise [Ginatra::Error] if max_count is less than 0. silly billy!
-    #
-    # @return [Array<GraphCommit>] the array of commits.
-    def all_commits(max_count = 10, skip = 0)
-      raise(Ginatra::Error.new("max_count cannot be less than 0")) if max_count < 0
-      commits = Grit::Commit.find_all(@repo, nil, {:max_count => max_count, :skip => skip})
-      ref_cache = {}
-      commits.collect do |commit|
-        add_refs(commit, ref_cache)
-        GraphCommit.new(commit)
+    # Returns list of branches sorted by name alphabetically
+    def branches
+      @repo.branches.each(:local).sort_by {|b| b.name }
+    end
+
+    # Returns list of branches containing the commit
+    def branches_with(commit)
+      b = []
+      branches.each do |branch|
+        walker = Rugged::Walker.new(@repo)
+        walker.sorting(Rugged::SORT_TOPO)
+        walker.push(@repo.ref("refs/heads/#{branch.name}").target)
+        walker.collect { |c| b << branch if c.oid == commit }
       end
+      b
     end
-    # Adds the refs corresponding to Grit::Commit objects to the respective Commit objects.
-    #
-    # @todo Perhaps move into commit class.
-    #
-    # @param [Grit::Commit] commit the commit you want refs added to
-    # @param [Hash] empty hash with scope out of loop to speed things up
-    # @return [Array] the array of refs added to the commit. they are also on the commit object.
-    def add_refs(commit, ref_cache)
-      if ref_cache.empty?
-         @repo.refs.each {|ref| ref_cache[ref.commit.id] ||= [];ref_cache[ref.commit.id] << ref}
+
+    # Checks existence of branch by name
+    def branch_exists?(branch_name)
+      @repo.branches.exists?(branch_name)
+    end
+
+    # Find blob by oid
+    def find_blob(oid)
+      Rugged::Blob.new @repo, oid
+    end
+
+    # Find tree by tree oid or branch name
+    def find_tree(oid)
+      if branch_exists?(oid)
+        last_commit_sha = @repo.ref("refs/heads/#{oid}").target.oid
+        lookup(last_commit_sha).tree
+      else
+        lookup(oid)
       end
-      commit.refs = ref_cache[commit.id] if ref_cache.include? commit.id
-      commit.refs ||= []
+    end
+
+    # Returns Rugged::Repository instance
+    def to_rugged
+      @repo
     end
 
     # Catch all
     #
-    # Warning! contains: Magic
-    #
     # @todo update respond_to? method
     def method_missing(sym, *args, &block)
       if @repo.respond_to?(sym)
@@ -121,10 +111,5 @@ module Ginatra
     def respond_to?(sym)
       @repo.respond_to?(sym) || super
     end
-
-    # not sure why we need this but whatever.
-    def to_s
-      @name.to_s
-    end
   end
 end

data/lib/ginatra/repo_list.rb

@@ -1,13 +1,13 @@
 require 'singleton'
 
 module Ginatra
-  # A singleton class that lets us make and use a constantly updating 
+  # A singleton class that lets us make and use a constantly updating
   # list of repositories.
   class RepoList
     include Singleton
     attr_accessor :list
-    
-    # This creates the list, then does the first refresh to 
+
+    # This creates the list, then does the first refresh to
     # populate it.
     #
     # It returns what refresh returns.
@@ -15,9 +15,9 @@ module Ginatra
       self.list = []
       self.refresh
     end
-    
-    # The preferred way to access the list publicly. 
-    # 
+
+    # The preferred way to access the list publicly.
+    #
     # @return [Array<Ginatra::Repo>] a list of ginatra repos.
     def self.list
       self.instance.refresh
@@ -28,9 +28,16 @@ module Ginatra
     # and adds them if they're not already there.
     def refresh
       list.clear
-      Ginatra::Config.git_dirs.map do |git_dir|
-        files = Dir.glob(git_dir)
-        files.each { |e| add(e) unless Ginatra::Config.ignored_files.include?(File.split(e).last) }
+      Ginatra.config.git_dirs.map do |git_dir|
+
+        if Dir.exist?(git_dir.chop)
+          files = Dir.glob(git_dir).sort
+        else
+          dir = File.expand_path("../../../#{git_dir}", __FILE__)
+          files = Dir.glob(dir).sort
+        end
+
+        files.each { |e| add(e) unless Ginatra.config.ignored_files.include?(File.split(e).last) }
       end
       list
     end
@@ -39,23 +46,23 @@ module Ginatra
     # globs. Checks to see that it's not there first
     #
     # @param [String] path the path of the git repo
-    # @param [String] param the param of the repo if it differs, 
+    # @param [String] param the param of the repo if it differs,
     #   for looking to see if it's already on the list
-    def add(path, param = File.split(path).last)
+    def add(path, param=File.split(path).last)
       unless self.has_repo?(param)
         begin
           list << Repo.new(path)
-        rescue Grit::InvalidGitRepositoryError
+        rescue Rugged::RepositoryError
           # If the path is not a git repository, then this error is raised
           # and causes an error page to result.
           # Is it preferable to just log that the error happened and not show the error page?
-          Ginatra::Config.logger.info "Invalid git repository at #{path}.  Did you create the directory and forget to run 'git init' inside that directory?"
+          raise Ginatra::Error, "Invalid git repository at #{path}.  Did you create the directory and forget to run 'git init' inside that directory?"
         end
       end
       list
     end
 
-    # checks to see if the list contains a repo with a param 
+    # checks to see if the list contains a repo with a param
     # matching the one passed in.
     #
     # @param [String] local_param param to check.
@@ -65,7 +72,7 @@ module Ginatra
       !list.find { |r| r.param == local_param }.nil?
     end
 
-    # quick way to look up if there is a repo with a given param in the list. 
+    # quick way to look up if there is a repo with a given param in the list.
     # If not, it refreshes the list and tries again.
     #
     # @param [String] local_param the param to lookup
@@ -76,7 +83,9 @@ module Ginatra
         repo
       else
         refresh
-        list.find { |r| r.param == local_param }
+        repo = list.find { |r| r.param == local_param }
+        raise Ginatra::RepoNotFound if repo.nil?
+        repo
       end
     end
 
@@ -88,8 +97,6 @@ module Ginatra
     end
 
     # allows missing methods to cascade to the instance,
-    #
-    # Caution! contains: Magic
     def self.method_missing(sym, *args, &block)
       instance.send(sym, *args, &block)
     end

data/lib/ginatra/repo_stats.rb

@@ -0,0 +1,93 @@
+module Ginatra
+  class RepoStats
+    # @param [Ginatra::Repo] repo Ginatra::Repo instance
+    # @param [String] branch_name Branch name of repository
+    # @return [Ginatra::RepoStats]
+    def initialize(repo, branch_name)
+      @repo = repo
+      @branch = branch_name
+    end
+
+    # Contributors to repository
+    #
+    # @return [Array] Information about contributors sorted by commits count
+    def contributors
+      contributors = {}
+      ref = @repo.ref("refs/heads/#{@branch}")
+      walker = Rugged::Walker.new(@repo.to_rugged)
+      walker.push(ref.target)
+
+      walker.each do |commit|
+        author = commit.author
+        email = author[:email]
+
+        if contributors[email]
+          contributors[email] = {
+            author: author[:name],
+            commits_count: contributors[email][:commits_count] + 1
+          }
+        else
+          contributors[email] = {
+            author: author[:name],
+            commits_count: 1
+          }
+        end
+      end
+
+      contributors.sort_by {|c| c.last[:commits_count] }.reverse
+    end
+
+    # Detect common OSS licenses
+    #
+    # @return [String] License name
+    def license
+      last_commit = @repo.ref("refs/heads/#{@branch}").target
+      license = @repo.blob_at(last_commit.oid, 'LICENSE') || @repo.blob_at(last_commit.oid, 'LICENSE.txt')
+
+      if license.nil?
+        'N/A'
+      else
+        license_text = license.text
+
+        case license_text
+        when /Apache License/
+          'Apache'
+        when /GNU GENERAL PUBLIC LICENSE/
+          'GPL'
+        when /GNU LESSER GENERAL PUBLIC LICENSE/
+          'LGPL'
+        when /Permission is hereby granted, free of charge,/
+          'MIT'
+        when /Redistribution and use in source and binary forms/
+          'BSD'
+        else
+          'N/A'
+        end
+      end
+    end
+
+    # Repository created at time
+    #
+    # @return [Time] Date of first commit to repository
+    def created_at
+      ref = @repo.ref("refs/heads/#{@branch}")
+
+      walker = Rugged::Walker.new(@repo.to_rugged)
+      walker.sorting(Rugged::SORT_TOPO)
+      walker.push(ref.target)
+      commit = walker.to_a.last
+      Time.at(commit.time)
+    end
+
+    # Commits count in defined branch
+    #
+    # @return [Integer] Commits count
+    def commits_count
+      ref = @repo.ref("refs/heads/#{@branch}")
+
+      walker = Rugged::Walker.new(@repo.to_rugged)
+      walker.push(ref.target)
+      walker.count
+    end
+  end
+end

data/lib/ginatra/version.rb

@@ -0,0 +1,4 @@
+module Ginatra
+  VERSION = "4.0.0"
+  RELEASE_NAME = "Aurora"
+end

data/lib/git/webby.rb

@@ -0,0 +1,292 @@
+# Standard requirements
+require 'json'
+require 'yaml'
+
+# 3rd part requirements
+require 'sinatra/base'
+
+# Internal requirements
+require 'git/webby/extensions'
+
+# See <b>Git::Webby</b> for documentation.
+module Git
+
+  # The main goal of the <b>Git::Webby</b> is implement the following useful
+  # features.
+  #
+  # - Smart-HTTP, based on _git-http-backend_.
+  # - Authentication flexible based on database or configuration file like <tt>.htpasswd</tt>.
+  # - API to get information about repository.
+  #
+  # This class configure the needed variables used by application. See
+  # Config::DEFAULTS for the values will be initialized by default.
+  #
+  # Basically, the +default+ attribute set the values that will be necessary
+  # by all applications.
+  #
+  # The HTTP-Backend application is configured by +http_backend+ attribute
+  # to set the Git RCP CLI. More details about this feature, see the
+  # {git-http-backend official
+  # page}[http://www.kernel.org/pub/software/scm/git/docs/git-http-backend.html]
+  #
+  # [*default*]
+  #   Default configuration. All attributes will be used by all modular
+  #   applications.
+  #
+  #   *project_root* ::
+  #     Sets the root directory where repositories have been
+  #     placed.
+  #   *git_path* ::
+  #     Path to the git command line.
+  #
+  # [*http_backend*]
+  #   HTTP-Backend configuration.
+  #
+  #   *authenticate* ::
+  #     Sets if authentication is required.
+  #
+  #   *get_any_file* ::
+  #     Like +http.getanyfile+.
+  #
+  #   *upload_pack*  ::
+  #     Like +http.uploadpack+.
+  #
+  #   *receive_pack* ::
+  #     Like +http.receivepack+.
+  module Webby
+
+    class ProjectHandler #:nodoc:
+
+      # Path to git command
+      attr_reader :path
+
+      attr_reader :project_root
+
+      attr_reader :repository
+
+      def initialize(project_root, path = "/usr/bin/git")
+        @repository   = nil
+        @path         = check_path(File.expand_path(path))
+        @project_root = check_path(File.expand_path(project_root))
+      end
+
+      def path_to(*args)
+        File.join(@repository || @project_root, *(args.compact.map(&:to_s)))
+      end
+
+      def repository=(name)
+        @repository = check_path(path_to(name))
+      end
+
+      def cli(command, *args)
+        %Q[#{@path} #{args.unshift(command.to_s.gsub("_","-")).compact.join(" ")}]
+      end
+
+      def run(command, *args)
+        chdir{ %x[#{cli command, *args}] }
+      end
+
+      def read_file(*file)
+        File.read(path_to(*file))
+      end
+
+      def loose_object_path(*hash)
+        path_to(:objects, *hash)
+      end
+
+      def pack_idx_path(pack)
+        path_to(:objects, :pack, pack)
+      end
+
+      def info_packs_path
+        path_to(:objects, :info, :packs)
+      end
+
+      private
+
+      def repository_path(name)
+        bare = name =~ /\w\.git/ ? name : %W[#{name} .git]
+        check_path(path_to(*bare))
+      end
+
+      def check_path(path)
+        path && !path.empty? && File.ftype(path) && path
+      end
+
+      def chdir(&block)
+        Dir.chdir(@repository || @project_root, &block)
+      end
+
+      def ftype
+        { "120" => "l", "100" => "-", "040" => "d" }
+      end
+    end
+
+    class Htpasswd #:nodoc:
+
+      def initialize(file)
+        require 'webrick/httpauth/htpasswd'
+        @handler = WEBrick::HTTPAuth::Htpasswd.new(file)
+        yield self if block_given?
+      end
+
+      def find(username) #:yield: password, salt
+        password = @handler.get_passwd(nil, username, false)
+        if block_given?
+          yield password ? [password, password[0,2]] : [nil, nil]
+        else
+          password
+        end
+      end
+
+      def authenticated?(username, password)
+        self.find username do |crypted, salt|
+          crypted && salt && crypted == password.crypt(salt)
+        end
+      end
+
+      def create(username, password)
+        @handler.set_passwd(nil, username, password)
+      end
+      alias update create
+
+      def destroy(username)
+        @handler.delete_passwd(nil, username)
+      end
+
+      def include?(username)
+        users.include? username
+      end
+
+      def size
+        users.size
+      end
+
+      def write!
+        @handler.flush
+      end
+
+      private
+
+      def users
+        @handler.each{|username, password| username }
+      end
+    end
+
+    module GitHelpers #:nodoc:
+
+      def git
+        @git ||= ProjectHandler.new(settings.project_root, settings.git_path)
+      end
+
+      def repository
+        git.repository ||= (params[:repository] || params[:captures].first)
+        git
+      end
+
+      def content_type_for_git(name, *suffixes)
+        content_type("application/x-git-#{name}-#{suffixes.compact.join("-")}")
+      end
+
+    end
+
+    module AuthenticationHelpers #:nodoc:
+
+      def htpasswd
+        @htpasswd ||= Htpasswd.new(git.path_to("htpasswd"))
+      end
+
+      def authentication
+        @authentication ||= Rack::Auth::Basic::Request.new request.env
+      end
+
+      def authenticated?
+        request.env["REMOTE_USER"] && request.env["git.webby.authenticated"]
+      end
+
+      def authenticate(username, password)
+        checked   = [ username, password ] == authentication.credentials
+        validated = authentication.provided? && authentication.basic?
+        granted   = htpasswd.authenticated? username, password
+        if checked and validated and granted
+          request.env["git.webby.authenticated"] = true
+          request.env["REMOTE_USER"] = authentication.username
+        else
+          nil
+        end
+      end
+
+      def unauthorized!(realm = Git::Webby::info)
+        headers "WWW-Authenticate" => %(Basic realm="#{realm}")
+        throw :halt, [ 401, "Authorization Required" ]
+      end
+
+      def bad_request!
+        throw :halt, [ 400, "Bad Request" ]
+      end
+
+      def authenticate!
+        return if authenticated?
+        unauthorized! unless authentication.provided?
+        bad_request!  unless authentication.basic?
+        unauthorized! unless authenticate(*authentication.credentials)
+        request.env["REMOTE_USER"] = authentication.username
+      end
+
+      def access_granted?(username, password)
+        authenticated? || authenticate(username, password)
+      end
+
+    end # AuthenticationHelpers
+
+    # Servers
+    autoload :HttpBackend, "git/webby/http_backend"
+
+    class << self
+
+      def config
+        @config ||= {
+          :default => {
+            :project_root => "/home/git",
+            :git_path     => "/usr/bin/git"
+          },
+          :http_backend => {
+            :authenticate => true,
+            :get_any_file => true,
+            :upload_pack  => true,
+            :receive_pack => false
+          }
+        }.to_struct
+      end
+
+      # Configure Git::Webby modules using keys. See Config for options.
+      def configure(&block)
+        yield config
+        config
+      end
+
+      def load_config_file(file)
+        YAML.load_file(file).to_struct.each_pair do |app, options|
+          options.each_pair do |option, value|
+            config[app][option] = value
+          end
+        end
+        config
+      rescue IndexError
+        abort "configuration option not found"
+      end
+
+    end
+
+    class Application < Sinatra::Base #:nodoc:
+
+      set :project_root, lambda { Git::Webby.config.default.project_root }
+      set :git_path,     lambda { Git::Webby.config.default.git_path }
+
+      mime_type :json, "application/json"
+
+    end
+
+  end
+
+end