ohloh_scm 2.5.1 → 3.0.1

data/bin/ohlog

@@ -1,152 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../lib/ohloh_scm'
-
-# This is a simple command line tool which parses CVS and Subversion logs.
-# It is not used by the main Ohloh system.
-#
-# I use it primarily to help debug Ohloh behavior. It's a convenient way
-# to turn an enormously long CVS log into something readable.
-module OhlohScm::Parsers
-	class CommandLine
-		attr_accessor :paths, :writer
-
-		def initialize(args=[])
-			args = args.clone # Because shift is destructive
-			set_option(args.shift) while args.first =~ /^-/
-			self.paths = args
-		end
-
-		def help
-			puts <<HELP
-Usage: ohlog [option] [paths]
-
-Ohloh source control log parser
-   http://www.ohloh.net/
-
-[option] can be one of the following:
-
-  --cvs             Parse a CVS rlog
-  --git             Parse a Git log (generated with or without --name-status option)
-  --svn             Parse a Subversion log
-  --svn-xml         Parse a Subversion XML log
-  --hg              Parse a Mercurial log
-  --bzr             Parse a Bazaar log
-  --bzr-xml         Parse a Bazaar XML log
-
-  -h, --human       Output result as a human-readable log (default)
-  -x, --xml         Output result as an XML log
-
-  -?, --help        Display this message
-
-[paths] must be one or more source control log filenames.
-   If no path is given, input will be read from STDIN.
-
-Examples:
-
-   cvsnt -d :pserver:anonymous:@cvs-mirror.mozilla.org:/cvsroot rlog mozilla/browser | ohlog --cvs
-
-   svn log --xml --verbose -r2:3 http://svn.collab.net/repos/svn/trunk | ohlog --svn-xml
-
-   hg log -v | ohloh --hg
-
-   bzr log -v | ohlog --bzr
-
-   bzr xmllog -v | ohlog --bzr
-
-HELP
-		end
-
-		def cvs
-			parse CvsParser
-		end
-
-		def git
-			parse GitParser
-		end
-
-		def svn
-			parse SvnParser
-		end
-
-		def svn_xml
-			parse SvnXmlParser
-		end
-
-		def hg
-			parse HgParser
-		end
-
-		def bzr
-			parse BzrParser
-		end
-
-    def bzr_xml
-      parse BzrXmlParser
-    end
-
-		def parse(parser)
-			self.writer ||= HumanWriter.new(STDOUT)
-
-			if self.paths.any?
-				self.paths.each do |path|
-					parser.parse File.new(path,'r'), :writer => self.writer
-				end
-			else
-				parser.parse STDIN, :writer => self.writer
-			end
-		end
-
-		def subcommand=(s)
-			if @subcommand
-				STDERR.puts "Error: Multiple commands specified."
-				exit 1
-			else
-				@subcommand=s
-			end
-		end
-
-		def subcommand
-			@subcommand
-		end
-
-		def set_option(option)
-			case option
-			when '--cvs'
-				self.subcommand = :cvs
-			when '--git'
-				self.subcommand = :git
-			when '--svn'
-				self.subcommand = :svn
-			when '--svn-xml'
-				self.subcommand = :svn_xml
-			when '--hg'
-				self.subcommand = :hg
-			when '--bzr'
-				self.subcommand = :bzr
-			when '--bzr-xml'
-				self.subcommand = :bzr_xml
-			when '-h', '--human'
-				self.writer = HumanWriter.new(STDOUT)
-			when '-x', '--xml'
-				self.writer = XmlWriter.new(STDOUT)
-			when '-?', '--help'
-				self.subcommand = :help
-			else
-				STDERR.puts "Type 'ohlog -?' for usage."
-				exit 1
-			end
-		end
-
-		def run!
-			self.subcommand ||= :summary
-			if self.respond_to?(self.subcommand)
-				self.send(self.subcommand)
-			else
-				STDERR.puts "Type 'ohlog -?' for usage."
-				exit 1
-			end
-		end
-	end
-
-	CommandLine.new(ARGV).run!
-end

data/lib/ohloh_scm/adapters/abstract/misc.rb

@@ -1,12 +0,0 @@
-module OhlohScm::Adapters
-  class AbstractAdapter
-
-    def is_merge_commit?(commit)
-      false
-    end
-
-    def tags
-      []
-    end
-  end
-end

data/lib/ohloh_scm/adapters/abstract/sha1.rb

@@ -1,48 +0,0 @@
-require 'digest/sha1'
-
-NULL_SHA1 = '0000000000000000000000000000000000000000' unless defined?(NULL_SHA1)
-
-module OhlohScm::Adapters
-	class AbstractAdapter
-
-		# This file provides SHA1 computation helpers for source control systems that
-		# don't have them natively (that is, everyone except Git!).
-		# So GitAdapter doesn't use this code, but others can us it to compute SHA1s
-		# that match those generated natively by Git.
-
-		def compute_sha1(blob)
-			blob.to_s == '' ? NULL_SHA1 : Digest::SHA1.hexdigest("blob #{blob.length}\0#{blob}")
-		end
-
-		# Populates the SHA1 values for each diff in a commit.
-		def populate_commit_sha1s!(commit)
-			if commit.diffs
-				commit.diffs.each do |diff|
-					populate_diff_sha1s!(commit, diff)
-				end
-			end
-			commit
-		end
-
-		# Populates the SHA1 values for a single diff.
-		def populate_diff_sha1s!(commit, diff)
-			diff.sha1 =
-				case diff.action
-				when 'D'
-					NULL_SHA1
-				else
-					compute_sha1(cat_file(commit, diff))
-				end
-
-			diff.parent_sha1 =
-				case diff.action
-				when 'A'
-					NULL_SHA1
-				else
-					compute_sha1(cat_file_parent(commit, diff))
-				end
-
-			diff
-		end
-	end
-end

data/lib/ohloh_scm/adapters/abstract/system.rb

@@ -1,60 +0,0 @@
-module OhlohScm::Adapters
-	require 'logger'
-	class AbstractAdapter
-    include POSIX::Spawn
-
-		def self.logger
-			@@logger ||= Logger.new(STDERR)
-		end
-
-		def self.logger=(val)
-			@@logger = val
-		end
-
-		def logger
-			self.class.logger
-		end
-
-		# Custom implementation of shell execution, does not block when the "pipe is full."
-		# Raises an exception if the shell returns non-zero exit code.
-		def self.run(cmd)
-			logger.debug { cmd }
-			status, out, err = Shellout.execute(cmd)
-			raise RuntimeError.new("#{cmd} failed: #{out}\n#{err}") if status.exitstatus != 0
-			out
-		end
-
-		def run(cmd)
-			AbstractAdapter::run(cmd)
-		end
-
-    def popen(cmd, filename)
-      logger.debug { cmd }
-      file = File.open(filename, 'w')
-      pid, input, out, err = popen4(cmd)
-      while true
-        Timeout.timeout(60 * 15) do
-          buffer = out.readpartial(50000)
-          file.write(buffer)
-        end
-      end
-    rescue EOFError
-    ensure
-      file.close
-      pid, status = Process::waitpid(pid) if pid
-      raise RuntimeError.new("#{cmd} failed: #{out}\n#{err}") if status && status.exitstatus != 0
-    end
-
-		# As above, but does not raise an exception when an error occurs.
-		# Returns three values: stdout, stderr, and process exit code
-		def self.run_with_err(cmd)
-			logger.debug { cmd }
-			status, out, err = Shellout.new.run(cmd)
-			[out, err, status]
-		end
-
-		def run_with_err(cmd)
-			AbstractAdapter::run_with_err(cmd)
-		end
-	end
-end

data/lib/ohloh_scm/adapters/abstract/validation.rb

@@ -1,77 +0,0 @@
-module OhlohScm::Adapters
-	class AbstractAdapter
-		# The full regex that permits all possible URLs supported by the source control system.
-		def self.url_regex
-			/.+/
-		end
-
-		# A limited regex that permits only URLs that are publicly addressable on the web.
-		# This regex should refuse access to local disk files.
-		def self.public_url_regex
-			/.+/
-		end
-
-		def validate
-			@errors = []
-			@errors << validate_url
-			@errors << validate_branch_name
-			@errors << validate_username
-			@errors << validate_password
-			@errors.compact!
-		end
-
-		def validate_url
-			return [:url, "The URL can't be blank."] unless @url and @url.length > 0
-			return [:url, "The URL must not be longer than 120 characters."] unless @url.length <= 120
-
-			regex = @public_urls_only ? self.class.public_url_regex : self.class.url_regex
-			return [:url, "The URL does not appear to be a valid server connection string."] unless @url =~ regex
-		end
-
-		def validate_branch_name
-			return nil if @branch_name.to_s == ''
-			return [:branch_name, "The branch name must not be longer than 80 characters."] unless @branch_name.length <= 80
-			return [:branch_name, "The branch name may contain only letters, numbers, spaces, and the special characters '_', '-', '+', '/', '^', and '.'"] unless @branch_name =~ /^[A-Za-z0-9_^\-\+\.\/\ ]+$/
-		end
-
-		def validate_username
-			return nil unless @username
-			return [:username, "The username must not be longer than 32 characters."] unless @username.length <= 32
-			return [:username, "The username may contain only A-Z, a-z, 0-9, and underscore (_)"] unless @username =~ /^\w*$/
-		end
-
-		def validate_password
-			return nil unless @password
-			return [:password, "The password must not be longer than 32 characters."] unless @password.length <= 32
-			return [:password, "The password contains illegal characters"] unless @password =~ /^[\w!@\#$%^&*\(\)\{\}\[\]\;\?\|\+\-\=]*$/
-		end
-
-		def valid?
-			validate
-			errors.empty?
-		end
-
-		def exists?
-			exist?
-		end
-
-		# Ping the remote server to ensure it is responding and that the desired branch exists.
-		def validate_server_connection
-		end
-
-		# Give the object a chance to massage/cleanup its input attributes
-		def normalize
-			@url.strip! if @url
-			@branch_name.strip! if @branch_name
-			@username.strip! if @username
-			@password.strip! if @password
-			self
-		end
-
-		# Based on the URL, return the domain name of the forge hosting this code.
-		def guess_forge
-			# This is a very general rule for systems using HTTP-style URLs.
-			url =~ /:\/\/([^\/]+)\// ? $1 : nil
-		end
-	end
-end

data/lib/ohloh_scm/adapters/abstract_adapter.rb

@@ -1,32 +0,0 @@
-module OhlohScm::Adapters
-	class AbstractAdapter
-		attr_accessor :url, :branch_name, :username, :password, :errors, :public_urls_only
-    attr_writer :temp_folder
-
-		def initialize(params={})
-			params.each { |k,v| send(k.to_s + '=', v) if respond_to?(k.to_s + '=') }
-		end
-
-		# Handy for test overrides
-		def metaclass
-			class << self
-				self
-			end
-		end
-
-    # Returns path to the string_encoder binary.
-    # For use with inline system commands like `run`.
-    def string_encoder
-      File.expand_path('../../../../bin/string_encoder', __FILE__)
-    end
-
-    def temp_folder
-      @temp_folder || '/tmp'
-    end
-	end
-end
-
-require_relative 'abstract/system'
-require_relative 'abstract/validation'
-require_relative 'abstract/sha1'
-require_relative 'abstract/misc'

data/lib/ohloh_scm/adapters/bzr/cat_file.rb

@@ -1,25 +0,0 @@
-module OhlohScm::Adapters
-	class BzrAdapter < AbstractAdapter
-		def cat_file(commit, diff)
-			cat(commit.token, diff.path)
-		end
-
-    def cat_file_parent(commit, diff)
-      first_parent_token = parent_tokens(commit).first
-      cat(first_parent_token, diff.path) if first_parent_token
-    end
-
-		def cat(revision, path)
-			out, err, status = run_with_err("cd '#{url}' && bzr cat --name-from-revision -r #{to_rev_param(revision)} '#{escape(path)}'")
-			return nil if err =~ / is not present in revision /
-			raise RuntimeError.new(err) unless status == 0
-			out
-		end
-
-		# Bzr doesn't like it when the filename includes a colon
-		# Also, fix the case where the filename includes a single quote
-		def escape(path)
-			path.gsub(/[:]/) { |c| '\\' + c }.gsub("'", "''")
-		end
-	end
-end

data/lib/ohloh_scm/adapters/bzr/commits.rb

@@ -1,100 +0,0 @@
-module OhlohScm::Adapters
-	class BzrAdapter < AbstractAdapter
-
-		# Return the number of commits in the repository following +after+.
-		def commit_count(opts={})
-			commit_tokens(opts).size
-		end
-
-		# Return the list of commit tokens following +after+.
-		def commit_tokens(opts={})
-      commits(opts).map(&:token)
-		end
-
-		# Returns a list of shallow commits (i.e., the diffs are not populated).
-		# Not including the diffs is meant to be a memory savings when
-		# we encounter massive repositories.  If you need all commits
-		# including diffs, you should use the each_commit() iterator,
-		# which only holds one commit in memory at a time.
-		def commits(opts={})
-			after = opts[:after]
-			log = run("#{rev_list_command(opts)} | cat")
-			a = OhlohScm::Parsers::BzrXmlParser.parse(log)
-
-      if after && i = a.index { |commit| commit.token == after }
-        a[(i+1)..-1]
-      else
-        a
-      end
-		end
-
-		# Returns a single commit, including its diffs
-		def verbose_commit(token)
-			log = run("cd '#{self.url}' && bzr xmllog --show-id -v --limit 1 -c #{to_rev_param(token)}")
-			OhlohScm::Parsers::BzrXmlParser.parse(log).first
-		end
-
-		# Yields each commit after +after+, including its diffs.
-		# The log is stored in a temporary file.
-		# This is designed to prevent excessive RAM usage when we
-		# encounter a massive repository.  Only a single commit is ever
-		# held in memory at once.
-    def each_commit(opts={})
-      after = opts[:after]
-      skip_commits = !!after # Don't emit any commits until the 'after' resume point passes
-
-      open_log_file(opts) do |io|
-        OhlohScm::Parsers::BzrXmlParser.parse(io) do |commit|
-          yield remove_directories(commit) if block_given? && !skip_commits
-          skip_commits = false if commit.token == after
-        end
-      end
-    end
-
-		# Ohloh tracks only files, not directories. This function removes directories
-		# from the commit diffs.
-		def remove_directories(commit)
-			commit.diffs.delete_if { |d| d.path[-1..-1] == '/' }
-			commit
-		end
-
-
-		# Not used by Ohloh proper, but handy for debugging and testing
-		def log(opts={})
-			run "#{rev_list_command(opts)} -v"
-		end
-
-		# Returns a file handle to the log.
-		# In our standard, the log should include everything AFTER
-		# +after+. However, bzr doesn't work that way; it returns
-		# everything after and INCLUDING +after+. Therefore, consumers
-		# of this file should check for and reject the duplicate commit.
-		def open_log_file(opts={})
-			after = opts[:after]
-			begin
-				if after == head_token # There are no new commits
-					# As a time optimization, just create an empty
-					# file rather than fetch a log we know will be empty.
-          File.open(log_filename, 'w') { |f| f.puts '<?xml version="1.0"?>' }
-				else
-					run "#{rev_list_command(opts)} -v > #{log_filename}"
-				end
-				File.open(log_filename, 'r') { |io| yield io }
-			ensure
-				File.delete(log_filename) if FileTest.exist?(log_filename)
-			end
-		end
-
-		def log_filename
-		  File.join(temp_folder, (self.url).gsub(/\W/,'') + '.log')
-		end
-
-    # Uses xmllog command for output to be used by BzrXmlParser.
-		def rev_list_command(opts={})
-			after = opts[:after]
-			trunk_only = opts[:trunk_only] ? '--levels=1' : '--include-merges'
-			"cd '#{self.url}' && bzr xmllog --show-id --forward #{trunk_only} -r #{to_rev_param(after)}.."
-		end
-	
-  end
-end