ohloh_scm 2.5.1 → 3.0.1

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

@@ -1,19 +0,0 @@
-module OhlohScm::Adapters
-	class BzrAdapter < AbstractAdapter
-		def head_token
-			run("bzr log --limit 1 --show-id #{url} 2> /dev/null | grep ^revision-id | cut -f2 -d' '").strip
-		end
-
-		def head
-			verbose_commit(head_token)
-		end
-
-		def parent_tokens(commit)
-			run("cd '#{url}' && bzr log --long --show-id --limit 1 -c #{to_rev_param(commit.token)} | grep ^parent | cut -f2 -d' '").split("\n")
-		end
-
-		def parents(commit)
-			parent_tokens(commit).collect { |token| verbose_commit(token) }
-		end
-	end
-end

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

@@ -1,61 +0,0 @@
-module OhlohScm::Adapters
-	class BzrAdapter < AbstractAdapter
-		def exist?
-			begin
-				head_token.to_s.length > 0
-			rescue
-				logger.debug { $! }
-				false
-			end
-		end
-
-		def ls_tree(token)
-      run("cd #{path} && bzr ls -V -r #{to_rev_param(token)}").split("\n")
-		end
-
-		def to_rev_param(r=nil)
-			case r
-			when nil
-				1
-			when Fixnum
-				r.to_s
-			when /^\d+$/
-				r
-			else
-        "'revid:#{r.to_s}'"
-			end
-		end
-
-		def is_merge_commit?(commit)
-			parent_tokens(commit).size > 1
-		end
-
-    def export_tag(dest_dir, tag_name)
-      run "cd '#{path}' && bzr export -r #{tag_name} #{dest_dir}"
-    end
-
-		def export(dest_dir, token=head_token)
-			# Unlike other SCMs, Bzr doesn't simply place the contents into dest_dir.
-			# It actually *creates* dest_dir. Since it should already exist at this point,
-			# first we have to delete it.
-			Dir.delete(dest_dir) if File.exist?(dest_dir)
-
-			run "cd '#{url}' && bzr export --format=dir -r #{to_rev_param(token)} '#{dest_dir}'"
-		end
-
-    def tags
-      tag_strings = run("cd '#{url}' && bzr tags").split(/\n/)
-      tag_strings.map do |tag_string|
-        parse_tag_names_and_revision = tag_string.split(/\s+/)
-        if parse_tag_names_and_revision.size > 1
-          tag_name, rev = parse_tag_names_and_revision[0..-2].join(' '), parse_tag_names_and_revision.last
-        else
-          tag_name, rev = parse_tag_names_and_revision.first, nil
-        end
-        next if rev == '?' || tag_name == '....'
-        time_string = run("cd '#{ url }' && bzr log -r #{ rev } | grep 'timestamp:' | sed 's/timestamp://'")
-        [tag_name, rev, Time.parse(time_string)]
-      end.compact
-    end
-	end
-end

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

@@ -1,22 +0,0 @@
-module OhlohScm::Adapters
-	class BzrAdapter < AbstractAdapter
-
-		def pull(from, &block)
-			raise ArgumentError.new("Cannot pull from #{from.inspect}") unless from.is_a?(BzrAdapter)
-			logger.info { "Pulling #{from.url}" }
-
-			yield(0,1) if block_given? # Progress bar callback
-
-			unless self.exist?
-				run "mkdir -p '#{self.url}'"
-				run "rm -rf '#{self.url}'"
-				run "bzr branch '#{from.url}' '#{self.url}'"
-			else
-				run "cd '#{self.url}' && bzr revert && bzr pull --overwrite '#{from.url}'"
-			end
-
-			yield(1,1) if block_given? # Progress bar callback
-		end
-
-	end
-end

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

@@ -1,51 +0,0 @@
-module OhlohScm::Adapters
-	class BzrAdapter < AbstractAdapter
-
-		def push(to, &block)
-			raise ArgumentError.new("Cannot push to #{to.inspect}") unless to.is_a?(BzrAdapter)
-			logger.info { "Pushing to #{to.url}" }
-
-			yield(0,1) if block_given? # Progress bar callback
-
-			unless to.exist?
-				if to.local?
-					# Create a new repo on the same local machine. Just use existing pull code in reverse.
-					to.pull(self)
-				else
-					run "ssh #{to.hostname} 'mkdir -p #{to.path}'"
-					run "scp -rpqB #{bzr_path} #{to.hostname}:#{to.path}"
-				end
-			else
-				run "cd '#{self.url}' && bzr revert && bzr push '#{to.url}'"
-			end
-
-			yield(1,1) if block_given? # Progress bar callback
-		end
-
-		def local?
-			return true if hostname == Socket.gethostname
-			return true if url =~ /^file:\/\//
-			return true if url !~ /:/
-			false
-		end
-
-		def hostname
-			$1 if url =~ /^bzr\+ssh:\/\/([^\/]+)/
-		end
-
-		def path
-			case url
-			when /^file:\/\/(.+)$/
-				$1
-			when /^bzr\+ssh:\/\/[^\/]+(\/.+)$/
-				$1
-			when /^[^:]*$/
-				url
-			end
-		end
-
-		def bzr_path
-			path && File.join(path, '.bzr')
-		end
-	end
-end

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

@@ -1,16 +0,0 @@
-module OhlohScm::Adapters
-	class BzrAdapter < AbstractAdapter
-		def self.url_regex
-			/^((((http|https|bzr|bzr\+ssh|file):\/\/((\w+@)?[A-Za-z0-9_\-\.]+(:\d+)?\/)?)|(lp:[A-Za-z0-9_\-\.\~])))?[A-Za-z0-9_@\-\.\/\~\+]*$/
-		end
-
-		def self.public_url_regex
-			/^(((http|https|bzr):\/\/(\w+@)?[A-Za-z0-9_\-\.]+(:\d+)?\/)|(lp:[A-Za-z0-9_\-\.\~]))[A-Za-z0-9_\-\.\/\~\+]*$/
-		end
-
-		def validate_server_connection
-			return unless valid?
-			@errors << [:failed, "The server did not respond to the 'bzr revno' command. Is the URL correct?"] unless self.exist?
-		end
-	end
-end

data/lib/ohloh_scm/adapters/bzr_adapter.rb

@@ -1,15 +0,0 @@
-module OhlohScm::Adapters
-	class BzrAdapter < AbstractAdapter
-		def english_name
-			"Bazaar"
-		end
-	end
-end
-
-require_relative 'bzr/validation'
-require_relative 'bzr/commits'
-require_relative 'bzr/head'
-require_relative 'bzr/cat_file'
-require_relative 'bzr/misc'
-require_relative 'bzr/pull'
-require_relative 'bzr/push'

data/lib/ohloh_scm/adapters/bzrlib/bzrlib_pipe_client.rb

@@ -1,71 +0,0 @@
-require 'rubygems'
-require 'posix/spawn'
-
-class BzrPipeClient
-  def initialize(repository_url)
-    @repository_url = repository_url
-    @py_script = File.dirname(__FILE__) + '/bzrlib_pipe_server.py'
-  end
-
-  def start
-    @pid, @stdin, @stdout, @stderr = POSIX::Spawn::popen4 "python #{@py_script}"
-    open_repository
-  end
-
-  def open_repository
-    send_command("REPO_OPEN|#{@repository_url}")
-  end
-  def cat_file(revision, file)
-    send_command("CAT_FILE|#{revision}|#{file}")
-  end
-
-  def parent_tokens(revision)
-    send_command("PARENT_TOKENS|#{revision}").split('|')
-  end
-
-  def send_command(cmd)
-    # send the command
-    @stdin.puts cmd
-    @stdin.flush
-    return if cmd == "QUIT"
-
-    # get status on stderr, first letter indicates state,
-    # remaing value indicates length of the file content
-    status = @stderr.read(10)
-    flag = status[0,1]
-    size = status[1,9].to_i
-    if flag == 'F'
-      return nil
-    elsif flag == 'E'
-      error = @stdout.read(size)
-      raise RuntimeError.new("Exception in server process\n#{error}")
-    end
-
-    # read content from stdout
-    return @stdout.read(size)
-  end
-
-  def shutdown
-    send_command("QUIT")
-    [@stdout, @stdin, @stderr].each { |io| io.close unless io.closed? }
-    Process.waitpid(@pid, Process::WNOHANG)
-  end
-end
-
-def cat_all_files(client, datafile)
-  count = 0
-  bytes = 0
-  File.open(datafile).each do |line|
-    parts = line.split('|')
-    count = count + 1
-    bytes = bytes + client.cat_file(parts[0], parts[1]).size
-    puts "file=#{count}, bytes=#{bytes}"
-  end
-end
-
-def all_parent_tokens(client, datafile)
-  File.open(datafile).each do |line|
-    parts = line.split('|')
-    puts client.parent_tokens(parts[0])
-  end
-end

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

@@ -1,9 +0,0 @@
-module OhlohScm::Adapters
-	class BzrlibAdapter < BzrAdapter
-
-		def cat(revision, path)
-      content = bzr_client.cat_file(revision, path)
-		end
-
-	end
-end

data/lib/ohloh_scm/adapters/bzrlib/head.rb

@@ -1,9 +0,0 @@
-module OhlohScm::Adapters
-	class BzrlibAdapter < BzrAdapter
-
-		def parent_tokens(commit)
-      bzr_client.parent_tokens(commit.token)
-		end
-
-	end
-end

data/lib/ohloh_scm/adapters/bzrlib_adapter.rb

@@ -1,25 +0,0 @@
-require 'rubygems'
-
-require_relative 'bzrlib/bzrlib_pipe_client'
-module OhlohScm::Adapters
-	class BzrlibAdapter < BzrAdapter
-
-    def setup
-      bzr_client = BzrPipeClient.new(url)
-      bzr_client.start
-      bzr_client
-    end
-
-    def bzr_client
-      @bzr_client ||= setup
-    end
-
-    def cleanup
-      @bzr_client.shutdown
-    end
-
-	end
-end
-
-require_relative 'bzrlib/head'
-require_relative 'bzrlib/cat_file'

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

@@ -1,97 +0,0 @@
-module OhlohScm::Adapters
-	class CvsAdapter
-		def commits(opts={})
-			after = opts[:after]
-			result = []
-
-			open_log_file(opts) do |io|
-				result = OhlohScm::Parsers::CvsParser.parse(io, :branch_name => branch_name)
-			end
-
-			# Git converter needs a backpointer to the scm for each commit
-			result.each { |c| c.scm = self }
-
-			return result if result.size == 0 # Nothing found; we're done here.
-			return result if after.to_s == '' # We requested everything, so just return everything.
-
-			# We must now remove any duplicates caused by timestamp fudge factors,
-			# and only return commits with timestamp > after.
-
-			# If the first commit is newer than after, then the whole list is new and we can simply return.
-			return result if parse_time(result.first.token) > parse_time(after)
-
-			# Walk the list of commits to find the first new one, throwing away all of the old ones.
-
-			# I want to string-compare timestamps without converting to dates objects (I think it's faster).
-			# Some CVS servers print dates as 2006/01/02 03:04:05, others as 2006-01-02 03:04:05.
-			# To work around this, we'll build a regex that matches either date format.
-			re = Regexp.new(after.gsub(/[\/-]/, '.'))
-
-			result.each_index do |i|
-				if result[i].token =~ re # We found the match for after
-					if i == result.size-1
-						return [] # There aren't any new commits.
-					else
-						return result[i+1..-1]
-					end
-				end
-			end
-
-			# Something bad is going on: 'after' does not match any timestamp in the rlog.
-			# This is very rare, but it can happen.
-			#
-			# Often this means that the *last* time we ran commits(), there was some kind of
-			# undetected problem (CVS was in an intermediate state?) so the list of timestamps we
-			# calculated last time does not match the list of timestamps we calculated this time.
-			#
-			# There's no work around for this condition here in the code, but there are some things
-			# you can try manually to fix the problem. Typically, you can try throwing way the
-			# commit associated with 'after' and fetching it again (git reset --hard HEAD^).
-			raise RuntimeError.new("token '#{after}' not found in rlog.")
-		end
-
-		# Gets the rlog of the repository and saves it in a temporary file.
-		# If you pass a timestamp token, then only commits after the timestamp will be returned.
-		#
-		# Warning!
-		#
-		# CVS servers are apparently unreliable when you truncate the log by timestamp -- perhaps round-off error?
-		# In any case, to be sure not to miss any commits, this method subtracts 10 seconds from the provided timestamp.
-		# This means that the returned log might actually contain a few revisions that predate the requested time.
-		# That's better than missing revisions completely! Just be sure to check for duplicates.
-		def open_log_file(opts={})
-			after = opts[:after]
-			begin
-        ensure_host_key
-        has_lock!
-        run("cvsnt -d #{self.url} rlog #{opt_branch} #{opt_time(after)} '#{self.module_name}' | #{ string_encoder } > #{ rlog_filename }")
-				File.open(rlog_filename, 'r') do |file|
-					yield file
-				end
-			ensure
-				File.delete rlog_filename if FileTest.exists?(rlog_filename)
-			end
-		end
-
-		def opt_time(after=nil)
-			if after
-				most_recent_time = parse_time(after) - 10
-				" -d '#{most_recent_time.strftime('%Y-%m-%d %H:%M:%S')}Z<#{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')}Z' "
-			else
-				""
-			end
-		end
-
-		def rlog_filename
-		  File.join(temp_folder, (self.url + self.module_name.to_s + self.branch_name.to_s).gsub(/\W/,'') + '.rlog')
-		end
-
-		# Converts a CVS time string to a Ruby Time object
-		def parse_time(token)
-			case token
-			when /(\d\d\d\d).(\d\d).(\d\d) (\d\d):(\d\d):(\d\d)/
-				Time.gm( $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i )
-			end
-		end
-	end
-end

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

@@ -1,212 +0,0 @@
-module OhlohScm::Adapters
-	class CvsAdapter
-		# Returns an array of file and directory names from the remote server.
-		# Directory names will end with a trailing '/' character.
-		#
-		# Directories named "CVSROOT" are always ignored, and thus never returned.
-		#
-		# An empty array means that the call succeeded, but the remote directory is empty.
-		# A nil result means that the call failed and the remote server could not be queried.
-		def ls(path=nil)
-			path = File.join(@module_name, path.to_s)
-
-			cmd = "cvsnt -q -d #{url} ls -e '#{path}'"
-
-      ensure_host_key
-
-			stdout, stderr = run_with_err(cmd)
-
-			files = []
-			stdout.each_line do |s|
-				s.strip!
-				s = $1 + '/' if s =~ /^D\/(.*)\/\/\/\/$/
-				s = $1 if s =~ /^\/(.*)\/.*\/.*\/.*\/$/
-				next if s == "CVSROOT/"
-				files << s if s and s.length > 0
-			end
-
-			# Some of the cvs 'errors' are just harmless problems with some directories.
-			# If we recognize all the error messages, then nothing is really wrong.
-			# If some error messages go unhandled, then there really is an error.
-			stderr.each_line do |s|
-				s.strip!
-				error_handled = false
-
-				ignored_error_messages = [
-					/Listing modules on server/,
-					/Listing module: #{Regexp.escape(path.to_s)}/,
-					/-m wrapper option is not supported remotely; ignored/,
-					/cannot open directory .* No such file or directory/,
-					/ignoring module/,
-          /skipping directory/,
-          /existing repository .* does not match/,
-          /nothing known about/,
-
-          # The signal 11 error should not really be ignored, but many CVS servers
-          # including dev.eclipse.org return it at the end of every ls.
-          /Terminated with fatal signal 11/
-				]
-
-				if s.length == 0
-					error_handled = true
-				elsif s =~ /cvs server: New directory `(#{Regexp.escape(path.to_s)}\/)?(.*)' -- ignored/
-					files << "#{$2}/"
-					error_handled = true
-				end
-
-				ignored_error_messages.each do |m|
-					error_handled = true if s =~ m
-				end
-
-				logger.warn {	"'#{cmd}' resulted in unhandled error '#{s}'"	} unless error_handled
-				return nil unless error_handled
-			end
-
-			files.sort
-		end
-
-		def log(most_recent_token=nil)
-      ensure_host_key
-			run "cvsnt -d #{self.url} rlog #{opt_branch} #{opt_time(most_recent_token)} '#{self.module_name}' | #{ string_encoder }"
-		end
-
-    def export_tag(dest_dir, tag_name = 'HEAD')
-      run "cvsnt -d #{self.url} export -d'#{dest_dir}' -r #{tag_name} '#{self.module_name}'"
-    end
-
-		def checkout(r, local_directory)
-			opt_D = r.token ? "-D'#{r.token}Z'" : ""
-
-      ensure_host_key
-			if FileTest.exists?(local_directory + '/CVS/Root')
-				# We already have a local enlistment, so do a quick update.
-				if r.directories.size > 0
-					build_ordered_directory_list(r.directories).each do |d|
-						if d.length == 0
-							run "cd #{local_directory} && cvsnt update -d -l -C #{opt_D} ."
-						else
-							run "cd #{local_directory} && cvsnt update -d -l -C #{opt_D} '#{d}'"
-						end
-					end
-				else
-					# Brute force: get all updates
-					logger.warn("Revision #{r.token} did not contain any directories. Using brute force update of entire module.")
-					run "cd #{local_directory} && cvsnt update -d -R -C #{opt_D}"
-				end
-			else
-				# We do not have a local enlistment, so do a slow checkout to create one.
-				# Silly cvsnt won't accept an absolute path. We'll have to play some games and cd to the parent directory.
-				parent_path, checkout_dir = File.split(local_directory)
-				FileUtils.mkdir_p(parent_path) unless FileTest.exist?(parent_path)
-				run "cd #{parent_path} && cvsnt -d #{self.url} checkout #{opt_D} -A -d'#{checkout_dir}' '#{self.module_name}'"
-			end
-		end
-
-		# A revision can contain an arbitrary collection of directories.
-		# We need to ensure that for every directory we want to fetch, we also have its parent directories.
-		def build_ordered_directory_list(directories)
-			# Integration Test Limitation
-			# cvsnt has problems with absolute path names, so we are stuck with
-			# using cvs modules that are only a single directory deep when testing.
-			# We'll check if the url begins with '/' to detect an integration test,
-			# then return an empty string (ie, the default root directory) if so.
-			return [''] if self.url =~ /^\//
-
-				list = []
-			directories.collect{ |a| trim_directory(a.to_s).to_s }.each do |d|
-				# We always ignore Attic directories, which just contain deleted files
-				# Update the parent directory of the Attic instead.
-				if d =~ /^(.*)Attic$/
-					d = $1
-					d = d[0..-2] if d.length > 0 and d[-1,1]=='/'
-				end
-
-				unless list.include? d
-					list << d
-					# We also need to include every parent directory of the directory
-					# we are interested in, all the way up to the root.
-					while d.rindex('/') and d.rindex('/') > 0 do
-						d = d[0..(d.rindex('/')-1)]
-						if list.include? d
-							break
-						else
-							list << d
-						end
-					end
-				end
-			end
-			# Sort the list by length because we need to update parent directories before children
-			list.sort! { |a,b| a.length <=> b.length }
-		end
-
-		def trim_directory(d)
-			# If we are connecting to a remote server (basically anytime we are not
-			# running the integration test) then we need to create a relative path
-			# by trimming the prefix from the directory.
-			# The prefix can be determined by examining the url and the module name.
-			# For example, if url = ':pserver:anonymous:@moodle.cvs.sourceforge.net:/cvsroot/moodle'
-			# and module = 'contrib', then the directory prefix = '/cvsroot/moodle/contrib/'
-			if root
-				d[root.length..-1]
-			else
-				d # If not remote, just leave the directory name as-is
-			end
-		end
-
-		def root
-			"#{$3}/#{self.module_name}/" if self.url =~ /^:(pserver|ext):.*@[^:]+:(\d+)?(\/.*)$/
-		end
-
-		def opt_branch
-			if branch_name != nil and branch_name.length > 0 and branch_name != 'HEAD'
-		"-r'#{branch_name}'"
-			else
-		"-b -r1:"
-			end
-		end
-
-    # returns the host this adapter is connecting to
-    def host
-      @host ||= begin
-        self.url =~ /@([^:]*):/
-        $1
-      end
-    end
-
-    # returns the protocol this adapter connects with
-    def protocol
-      @protocol ||= case self.url
-                    when /^:pserver/ then :pserver
-                    when /^:ext/ then :ext
-                    end
-    end
-
-    # using :ext (ssh) protocol might trigger ssh to confirm accepting the host's
-    # ssh key. This causes the UI to hang asking for manual confirmation. To avoid
-    # this we pre-populate the ~/.ssh/known_hosts file with the host's key.
-    def ensure_host_key
-      if self.protocol == :ext
-        ensure_key_file = File.dirname(__FILE__) + "/../../../../bin/ensure_key"
-        cmd = "#{ensure_key_file} '#{ self.host }'"
-			  stdout, stderr = run_with_err(cmd)
-      end
-    end
-
-    def has_lock!
-      begin
-        run "timeout 2m cvsnt -q -d #{self.url} rlog '#{self.module_name}'"
-        false
-      rescue => e
-        raise RuntimeError.new('CVS lock has been found') if e.message.match(/waiting for.*lock in/)
-      end
-    end
-
-    def tags
-      tag_strings = run("cvs -Q -d #{ url } rlog -h #{ module_name } | awk -F\"[.:]\" '/^\\t/&&$(NF-1)!=0'").split(/\n/)
-      tag_strings.map do |tag_string|
-        tag_name, version = tag_string.split(':')
-        [tag_name.gsub(/\t/, ''), version.strip]
-      end
-    end
-	end
-end