ohloh_scm 2.5.1 → 3.0.1

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

@@ -1,77 +0,0 @@
-module OhlohScm::Adapters
-	class CvsAdapter
-		def self.url_regex
-			/^(:(pserver|ext):[\w\-\+\_]*(:[\w\-\+\_]*)?@[A-Za-z0-9_\-\+\.]+:[0-9]*)?\/[A-Za-z0-9_\-\+\.\/]*$/
-		end
-
-		def self.public_url_regex
-			/^:(pserver|ext):[\w\-\+\_]*(:[\w\-\+\_]*)?@[A-Za-z0-9_\-\+\.]+:[0-9]*\/[A-Za-z0-9_\-\+\.\/]*$/
-		end
-
-		def validate
-			super
-			@errors << validate_module_name
-			@errors.compact!
-		end
-
-		def validate_module_name
-			return [:module_name, "The module name can't be blank."] if @module_name.to_s.length == 0
-			return [:module_name, "The module name must not be longer than 120 characters."] unless @module_name.length <= 120
-			return [:module_name, "The module name may contain only letters, numbers, spaces, and the special characters '_', '-', '+', '/', and '.'"] unless @module_name =~ /^[A-Za-z0-9_\-\+\.\/\ ]+$/
-		end
-
-		def normalize
-			super
-			@module_name = @module_name.strip if @module_name
-
-			# Some CVS forges publish an URL which is actually a symlink, which causes CVSNT to crash.
-			# For some forges, we can work around this by using an alternate directory.
-			case guess_forge
-			when 'java.net', 'netbeans.org'
-				@url.gsub!(/:\/cvs\/?$/, ':/shared/data/ccvs/repository')
-			when 'gna.org'
-				@url.gsub!(/:\/cvs\b/, ':/var/cvs')
-			end
-
-			sync_pserver_username_password
-
-			self
-		end
-
-		# This bit of code patches up any inconsistencies that may arise because there
-		# is both a @password attribute and a password embedded in the :pserver: url.
-		# This method guarantees that they are both the same.
-		#
-		# It's assumed that if the user specified a @password attribute, then that is
-		# the preferred value and it should take precedence over any password found
-		# in the :pserver: url.
-		#
-		# If the user did not specify a @password attribute, then the value
-		# found in the :pserver: url is assigned to both.
-		def sync_pserver_username_password
-			# Do nothing unless pserver connection string is well-formed.
-			return unless self.url =~ /:pserver:([\w\-\_]*)(:([\w\-\_]*))?@(.*)$/
-
-			pserver_username = $1
-			pserver_password = $3
-			pserver_remainder = $4
-
-			@username = pserver_username if @username.to_s == ''
-			@password = pserver_password if @password.to_s == ''
-
-			self.url = ":pserver:#{@username}:#{password}@#{pserver_remainder}"
-		end
-
-		def validate_server_connection
-			return unless valid?
-			if ls.nil?
-				@errors << [:failed, "The cvs server did not respond to an 'ls' command. Are the URL and module name correct?"]
-			end
-		end
-
-		# Based on the URL, take a guess about which forge this code is hosted on.
-		def guess_forge
-			@url =~ /.*(pserver|ext).*@(([^\.]+\.)?(cvs|dev)\.)?([^:]+):\//i ? $5.downcase : nil
-		end
-	end
-end

data/lib/ohloh_scm/adapters/cvs_adapter.rb

@@ -1,18 +0,0 @@
-module OhlohScm::Adapters
-	class CvsAdapter < AbstractAdapter
-		attr_accessor :module_name
-
-		def english_name
-			'CVS'
-		end
-
-		def initialize(params={})
-			super
-			@module_name = params[:module_name]
-		end
-	end
-end
-
-require_relative 'cvs/validation'
-require_relative 'cvs/commits'
-require_relative 'cvs/misc'

data/lib/ohloh_scm/adapters/factory.rb

@@ -1,38 +0,0 @@
-module OhlohScm::Adapters
-	class Factory
-
-		# Given a local path on disk, try to guess what kind of repository it is,
-		# and return an appropriate adapter.
-		def self.from_path(path)
-
-			if FileTest.exist?(File.join(path, '.git'))
-				GitAdapter.new(:url => File.expand_path(path)).normalize
-
-			elsif FileTest.exist?(File.join(path, '.hg'))
-				HgAdapter.new(:url => File.expand_path(path)).normalize
-
-			elsif FileTest.exist?(File.join(path, '.bzr'))
-				BzrAdapter.new(:url => File.expand_path(path)).normalize
-
-			elsif FileTest.exist?(File.join(path, 'db'))
-				SvnAdapter.new(:url => File.expand_path(path)).normalize
-
-			elsif FileTest.exist?(File.join(path, '.svn'))
-				# It's a local checkout. Use the secret info stashed by Subversion to find the server URL.
-				info = `cd #{path} && svn info`
-				if info =~ /^URL: (.+)$/
-					svn = SvnAdapter.new(:url => $1).normalize
-					svn.recalc_branch_name
-					svn
-				end
-
-			elsif FileTest.exist?(File.join(path, 'CVS', 'Root'))
-				# It's a local CVS checkout. Use the secret info to find the server URL.
-				root = File.read(File.join(path, 'CVS', 'Root')).strip
-				repo = File.read(File.join(path, 'CVS', 'Repository')).strip
-				CvsAdapter.new(:url => root, :repository => repo).normalize
-			end
-
-		end
-	end
-end

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

@@ -1,16 +0,0 @@
-module OhlohScm::Adapters
-	class GitAdapter < AbstractAdapter
-		def cat_file(commit, diff)
-			cat(diff.sha1)
-		end
-
-		def cat_file_parent(commit, diff)
-			cat(diff.parent_sha1)
-		end
-
-		def cat(sha1)
-			return '' if sha1 == NULL_SHA1
-			run "cd '#{url}' && git cat-file -p #{sha1}"
-		end
-	end
-end

data/lib/ohloh_scm/adapters/git/commit_all.rb

@@ -1,141 +0,0 @@
-module OhlohScm::Adapters
-	class GitAdapter < AbstractAdapter
-
-		#---------------------------------------------------------------------------
-		# COMMIT-RELATED CODE
-		#-------------------------------------------------------------------------
-
-		# Commit all changes in the working directory, using metadata from the passed commit.
-		def commit_all(commit=Commit.new)
-			init_db
-			ensure_gitignore
-			write_token(commit.token)
-
-			# Establish the author, email, message, etc. for the git-commit.
-			message_filename = set_commit_metadata(commit)
-
-			run "cd '#{self.url}' && git add ."
-			if anything_to_commit?
-				run "cd '#{self.url}' && git commit -a -F #{message_filename}"
-			else
-				logger.info { "nothing to commit" }
-			end
-		end
-
-		# Store all of the commit metadata in the GIT environment variables
-		# where they will be picked up by the git-commit command.
-		#
-		# Commit info is required.
-		# Author info is optional, and defaults to committer info.
-		def set_commit_metadata(commit)
-
-			ENV['GIT_COMMITTER_NAME'] = commit.committer_name || '[anonymous]'
-			ENV['GIT_AUTHOR_NAME'] = commit.author_name || ENV['GIT_COMMITTER_NAME']
-
-			ENV['GIT_COMMITTER_EMAIL'] = commit.committer_email || ENV['GIT_COMMITTER_NAME']
-			ENV['GIT_AUTHOR_EMAIL'] = commit.author_email || ENV['GIT_AUTHOR_NAME']
-
-			ENV['GIT_COMMITTER_DATE'] = commit.committer_date.to_s
-			ENV['GIT_AUTHOR_DATE'] = (commit.author_date || commit.committer_date).to_s
-
-			# This is a one-off fix for DrJava, which includes some escape characters
-			# in one of its Subversion messages. This might lead to a more generalized
-			# cleanup of message text, but for now...
-			commit.message.gsub!(/\\027/,'') if commit.message
-
-			# Git requires a non-empty message
-			if commit.message.nil? || commit.message =~ /\A\s*\z/
-				commit.message = '[no message]'
-			end
-
-			# We need to store the message in a file in case it contains crazy characters
-			#    that would corrupt a bash command line.
-			File.open(message_filename, 'w') do |f|
-				f.write commit.message
-			end
-			message_filename
-		end
-
-		# By hiding the message file inside the .git directory, we
-		#    avoid it being found by the commit-all.
-		def message_filename
-			File.expand_path(File.join(git_path, 'ohloh_message'))
-		end
-
-		# True if there are pending changes to commit.
-		def anything_to_commit?
-			run("cd '#{self.url}' && git status | tail -1") =~ /nothing to commit/ ? false : true
-		end
-
-		# Ensures that the repository directory exists, and that the git database has been initialized.
-		def init_db
-			unless FileTest.exist? url
-				run "mkdir -p '#{url}'"
-			end
-			unless FileTest.exist? git_path
-				run "cd '#{url}' && git init-db"
-			end
-		end
-
-
-		#-------------------------------------------------------------------------
-		# GIT IGNORE CODE
-		# Ensures that we do not waste storage space on non-source code files
-		#-------------------------------------------------------------------------
-
-		unless defined?(IGNORE)
-			IGNORE = [
-				".svn",
-				"CVS",
-				"*.jar",
-				"*.tar",
-				"*.gz",
-				"*.tgz",
-				"*.zip",
-				"*.gif",
-				"*.jpg",
-				"*.jpeg",
-				"*.bmp",
-				"*.png",
-				"*.tif",
-				"*.tiff",
-				"*.ogg",
-				"*.aiff",
-				"*.wav",
-				"*.mp3",
-				"*.au",
-				"*.ra",
-				"*.m4a",
-				"*.pdf",
-				"*.mpg",
-				"*.mov",
-				"*.qt",
-				"*.avi",
-				"*.xbm"
-			]
-		end
-
-		# The .gitignore file will be created if it does not exist.
-		# If our desired filespec is not found in .gitignore, it will be appended
-		# to the end of .gitignore.
-		def ensure_gitignore
-			IGNORE.each do |ignore|
-				gitignore_filename = File.join(self.url, '.gitignore')
-				found = false
-				File.open(gitignore_filename, File::CREAT | File::RDONLY) do |io|
-					io.readlines.each do |l|
-						if l.chomp == ignore
-							found = true
-							break
-						end
-					end
-				end
-				unless found
-					File.open(gitignore_filename, File::APPEND | File::WRONLY) do |io|
-						io.puts ignore
-					end
-				end
-			end
-		end
-	end
-end

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

@@ -1,122 +0,0 @@
-module OhlohScm::Adapters
-	class GitAdapter < AbstractAdapter
-
-		# Returns the number of commits in the repository following the commit with SHA1 'after'.
-		def commit_count(opts={})
-			run("#{rev_list_command(opts)} | wc -l").to_i
-		end
-
-		# Returns the SHA1 hash for every commit in the repository following the commit with SHA1 'after'.
-		def commit_tokens(opts={})
-			run(rev_list_command(opts)).split("\n")
-		end
-
-		# Yields each commit following the commit with SHA1 'after'.
-		# Officially, this method isn't required to provide diffs with these commits,
-    # and the Subversion equivalent of this method does not,
-		# so if you really require the diffs you should be using each_commit() instead.
-		def commits(opts={})
-			result = []
-			each_commit(opts) { |c| result << c }
-			result
-		end
-
-		# Yields each commit in the repository following the commit with SHA1 'after'.
-		# These commits are populated with diffs.
-		def each_commit(opts={})
-
-			# Bug fix (hack) follows.
-			#
-			# git-whatchanged emits a merge commit multiple times, once for each parent, giving the
-			# delta to each parent in turn.
-			#
-			# This causes us to emit too many commits, with repeated merge commits.
-			#
-			# To fix this, we track the previous commit, and emit a new commit only if it is distinct
-			# from the previous.
-			#
-			# This means that the diffs for a merge commit yielded by this method will be the diffs
-			# vs. the first parent only, and diffs vs. other parents are lost. For Ohloh, this is fine
-			# because Ohloh ignores merge diffs anyway.
-
-			previous = nil
-      open_log_file(opts) do |io|
-			  OhlohScm::Parsers::GitStyledParser.parse(io) do |e|
-				  yield fixup_null_merge(e) unless previous && previous.token == e.token
-				  previous = e
-			  end
-      end
-		end
-
-		# Returns a single commit, including its diffs
-		def verbose_commit(token)
-			c = OhlohScm::Parsers::GitStyledParser.parse(run("cd '#{url}' && #{OhlohScm::Parsers::GitStyledParser.whatchanged} #{token} | #{ string_encoder }")).first
-      fixup_null_merge(c)
-		end
-
-    # For a merge commit, we ask `git whatchanged` to output the changes relative to each parent.
-    # It is possible, through developer hackery, to create a merge commit which does not change the tree.
-    # When this happens, `git whatchanged` will suppress its output relative to the first parent,
-    # and jump immediately to the second (branch) parent. Our code mistakenly interprets this output
-    # as the missing changes relative to the first parent.
-    #
-    # To avoid this calamity, we must compare the tree hash of this commit with its first parent's.
-    # If they are the same, then the diff should be empty, regardless of what `git whatchanged` says.
-    #
-    # Yes, this is a convoluted, time-wasting hack to address a very rare circumstance. Ultimatley
-    # we should stop parsing `git whatchanged` to extract commit data.
-    def fixup_null_merge(c)
-      first_parent_token = parent_tokens(c).first
-      if first_parent_token && get_commit_tree(first_parent_token) == get_commit_tree(c.token)
-        c.diffs = []
-      end
-      c
-    end
-
-		# Retrieves the git log in the format expected by GitStyledParser.
-		# We get the log forward chronological order (oldest first)
-		def log(opts={})
-			if has_branch?
-				if opts[:after] && opts[:after]==self.head_token
-					'' # Nothing new.
-				else
-					run "#{rev_list_command(opts)} | xargs -n 1 #{OhlohScm::Parsers::GitStyledParser.whatchanged} | #{ string_encoder }"
-				end
-			else
-				''
-			end
-		end
-
-
-		# Same as log() method above, except that it writes the log to 
-    # a file.
-		def open_log_file(opts={})
-			if has_branch?
-				if opts[:after] && opts[:after]==self.head_token
-					'' # Nothing new.
-				else
-          begin
-					  run "#{rev_list_command(opts)} | xargs -n 1 #{OhlohScm::Parsers::GitStyledParser.whatchanged} | #{ string_encoder } > #{log_filename}"
-            File.open(log_filename, 'r') { |io| yield io } 
-          ensure
-            File.delete(log_filename) if FileTest.exist?(log_filename)
-          end
-				end
-			else
-				''
-			end
-		end
-
-    def log_filename
-      File.join(temp_folder, (self.url).gsub(/\W/,'') + '.log')
-    end 
-
-		def rev_list_command(opts={})
-      up_to = opts[:up_to] || "heads/#{branch_name}"
-			range = opts[:after] ? "#{opts[:after]}..#{up_to}" : up_to
-
-      trunk_only = opts[:trunk_only] ? "--first-parent" : ""
-			"cd '#{url}' && git rev-list --topo-order --reverse #{trunk_only} #{range}"
-		end
-	end
-end

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

@@ -1,21 +0,0 @@
-module OhlohScm::Adapters
-	class GitAdapter < AbstractAdapter
-
-		def head_token
-			run("git ls-remote --heads '#{url}' #{branch_name}") =~ /^(^[a-z0-9]{40})\s+\S+$/
-			$1
-		end
-
-		def head
-			verbose_commit(head_token)
-		end
-
-		def parent_tokens(commit)
-			run("cd '#{url}' && git cat-file commit #{commit.token} | grep ^parent | cut -f 2 -d ' '").split("\n") || []
-		end
-
-		def parents(commit)
-			parent_tokens(commit).collect { |token| verbose_commit(token) }
-		end
-	end
-end

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

@@ -1,107 +0,0 @@
-module OhlohScm::Adapters
-	class GitAdapter < AbstractAdapter
-		def git_path
-			File.join(self.url, '/.git')
-		end
-
-		def exist?
-			begin
-				!!(head_token)
-			rescue
-				logger.debug { $! }
-				false
-			end
-		end
-
-		def export(dest_dir, commit_id = 'HEAD')
-			run "cd #{url} && git archive #{commit_id} | tar -C #{ dest_dir } -x"
-		end
-
-		def ls_tree(token='HEAD')
-			run("cd #{url} && git ls-tree -r #{token} | cut -f 2 -d '\t'").split("\n")
-		end
-
-    # For a given commit ID, returns the SHA1 hash of its tree
-    def get_commit_tree(token='HEAD')
-      run("cd #{url} && git cat-file commit #{token} | grep '^tree' | cut -d ' ' -f 2").strip
-    end
-
-		# Moves us the correct branch and checks out the most recent files.
-		#
-		# Anything not tracked by Git is deleted.
-		#
-		# This method may not seem like the most efficient way to accomplish this,
-		# but we need very high reliability and this sequence gets the job done every time.
-		def checkout
-			if FileTest.exist? git_path
-				run "cd '#{url}' && git clean -f -d -x"
-				if self.has_branch?
-                                  run "cd '#{url}' && git checkout #{self.branch_name} --"
-                                  run "cd '#{url}' && git reset --hard heads/#{self.branch_name} --"
-				end
-			end
-		end
-
-		#---------------------------------------------------------------------------
-		# BRANCH-RELATED CODE
-		#-------------------------------------------------------------------------
-
-		# Returns an array of all branch names
-		def branches
-			run("cd '#{self.url}' && git branch | #{ string_encoder }").split.collect { |b| b =~ /\b(.+)$/ ; $1 }.compact
-		end
-
-		def has_branch?(name=self.branch_name)
-			return false unless FileTest.exist?(self.git_path)
-			self.branches.include?(name)
-		end
-
-		# Create a new local branch to mirror the remote one
-		# If a branch of this name already exist, nothing happens.
-		def create_tracking_branch(name)
-			return if name.to_s == ''
-
-			unless self.branches.include? name
-				run "cd '#{self.url}' && git branch -f #{name} origin/#{name}"
-			end
-		end
-
-		def is_merge_commit?(commit)
-			parent_tokens(commit).size > 1
-		end
-
-    def no_tags?
-      run("cd #{ url } && git tag | head -1").empty?
-    end
-
-    def tags
-      return [] if no_tags?
-      tag_strings = run("cd #{url} && git tag --format='%(creatordate:iso-strict) %(objectname) %(refname)' | sed 's/refs\\/tags\\///'").split(/\n/)
-      tag_strings.map do |tag_string|
-        timestamp_string, commit_hash, tag_name = tag_string.split(/\s/)
-        [tag_name, dereferenced_sha(tag_name) || commit_hash, time_object(timestamp_string)]
-      end
-    end
-
-    private
-
-    def dereferenced_sha(tag_name)
-      dtag_sha_and_name = dtag_sha_and_names.find { |sha_and_name| sha_and_name.last == tag_name }
-      dtag_sha_and_name.first if dtag_sha_and_name
-    end
-
-    def dtag_sha_and_names
-      @dtag_sha_and_names ||= dereferenced_tag_strings.map(&:split)
-    end
-
-    def dereferenced_tag_strings
-      # Pattern: b6e9220c3cabe53a4ed7f32952aeaeb8a822603d refs/tags/v1.0.0^{}
-      run("cd #{url} && git show-ref --tags -d | grep '\\^{}' | sed 's/\\^{}//' | sed 's/refs\\/tags\\///'").split(/\n/)
-    end
-
-    def time_object(timestamp_string)
-      timestamp_string = '1970-01-01' if timestamp_string.strip.empty?
-      timestamp = Time.parse(timestamp_string)
-    end
-  end
-end