ohloh_scm 2.5.1 → 3.0.1

data/lib/ohloh_scm/parsers/bzr_parser.rb

@@ -1,128 +0,0 @@
-module OhlohScm::Parsers
-	# This parser can process the default bzr logs, with or without the --verbose flag.
-	class BzrParser < Parser
-		def self.scm
-			'bzr'
-		end
-
-		def self.internal_parse(buffer, opts)
-			e = nil
-			state = :data
-			action = ''
-			indent = '' # Track the level of indentation as we descend into branches
-			show_id = false # true if this log includes revision and file ids
-
-			buffer.each_line do |l|
-				next_state = state
-
-				case l
-				# A commit message can contain lines of only dashes, which makes parsing difficult.
-				#
-				# This delimiter detector filters most casual cases of using dash lines in commits.
-				# We check that the dashed line is exactly 60 chars long, and is prepended by 4*n spaces.
-				#
-				# Unless the commit message itself includes leading spaces, the commit message will
-				# begin in column 4*n+2, and thus will not match our pattern.
-				when /^((    )*)-{60,60}$/
-					# a new commit begins
-					indent = $1
-					if e && block_given?
-						e.diffs = remove_dupes(e.diffs)
-						yield e
-					end
-					e = OhlohScm::Commit.new
-					e.diffs = []
-					next_state = :data
-				when /^#{indent}revno:\s+(\d+)$/
-					e.token = $1
-					next_state = :data
-				when /^#{indent}revision-id:\s+(\S+)$/
-					e.token = $1
-					show_id = true
-					next_state = :data
-				when /^#{indent}author:\s+(.+?)(\s+<(.+)>)?$/
-					e.author_name = $1
-					e.author_email = $3
-					next_state = :data
-				when /^#{indent}committer:\s+(.+?)(\s+<(.+)>)?$/
-					e.committer_name = $1
-					e.committer_email = $3
-					next_state = :data
-				when /^#{indent}timestamp:\s+(.+)/
-					e.committer_date = Time.parse($1)
-					next_state = :data
-				when /^#{indent}added:$/
-					next_state = :collect_files
-					action = 'A'
-				when /^#{indent}modified:$/
-					next_state = :collect_files
-					action = 'M'
-				when /^#{indent}removed:$/
-					next_state = :collect_files
-					action = 'D'
-				when /^#{indent}renamed:$/
-					next_state = :collect_files
-					action = :rename
-				when /^#{indent}message:$/
-					next_state = :collect_message
-					e.message ||= ''
-				when /^#{indent}  (.*)$/
-					case state
-					when :collect_files
-						line = $1
-						# strip the id from the end of the line if it is present
-						line = $1 if show_id && line =~ /^(.+?)\s+(\S+)$/
-						parse_diffs(action, line).each { |d| e.diffs << d }
-					when :collect_message
-						e.message << $1
-						e.message << "\n"
-					end
-				end
-
-				state = next_state
-			end
-			if e && block_given?
-				e.diffs = remove_dupes(e.diffs)
-				yield e
-			end
-		end
-
-		# Given a line from the log represent a file operation,
-		# return a collection of diffs for that action
-		def self.parse_diffs(action, line)
-			case action
-			when :rename
-				# A rename action requires two diffs: one to remove the old filename,
-				# another to add the new filename.
-				#
-				# Note that is possible to be renamed to the empty string!
-				# This happens when a subdirectory is moved to become the root.
-				before, after = line.scan(/(.+) => ?(.*)/).first
-				[ OhlohScm::Diff.new(:action => 'D', :path => before),
-					OhlohScm::Diff.new(:action => 'A', :path => after || '' )]
-			else
-				[OhlohScm::Diff.new(:action => action, :path => line)]
-			end.each do |d|
-				d.path = strip_trailing_asterisk(d.path)
-			end
-		end
-
-		def self.strip_trailing_asterisk(path)
-			path[-1..-1] == '*' ? path[0..-2] : path
-		end
-
-		def self.remove_dupes(diffs)
-			# Bazaar may report that a file was added and modified in a single commit.
-			# Reduce these cases to a single 'A' action.
-			diffs.delete_if do |d|
-				d.action == 'M' && diffs.select { |x| x.path == d.path && x.action == 'A' }.any?
-			end
-
-			# Bazaar may report that a file was both deleted and added in a single commit.
-			# Reduce these cases to a single 'M' action.
-			diffs.each do |d|
-				d.action = 'M' if diffs.select { |x| x.path == d.path }.size > 1
-			end.uniq
-		end
-	end
-end

data/lib/ohloh_scm/parsers/cvs_parser.rb

@@ -1,182 +0,0 @@
-module OhlohScm::Parsers
-	class CvsParser < Parser
-
-		def self.scm
-			'cvs'
-		end
-
-		# Given an IO to a CVS rlog, returns a list of
-		# commits (developer/date/message).
-		# If a branch_name is specified, only commits along that branch will be returned,
-		# otherwise only commits along the head will be returned.
-		def self.internal_parse(io, opts)
-			commits = {}
-			branch_name = opts[:branch_name]
-			branch_name = nil if branch_name == 'HEAD' or branch_name == ''
-
-			read_files(io, branch_name) do |c|
-				# As commits are yielded by the parser, we sort them into bins.
-				#
-				# The 'bins' are arrays of timestamps. We keep a separate array of
-				# timestamps for each developer/message combination.
-				#
-				# If a commit lies near in time to another commit with the same
-				# developer/message combination, then we merge them and store only
-				# the later of the two timestamps.
-				#
-				# Typically, we end up with only a single timestamp for each developer/message
-				# combination. However, if a developer repeatedly uses the same message
-				# a number of separate times, we may end up with several timestamps for
-				# that combination.
-
-				key = c.committer_name + ":" + c.message
-				if commits.has_key? key
-					# We have already seen this developer/message combination
-					match = false
-					commits[key].each_index do |i|
-						# Does the new commit lie near in time to a known one in our list?
-						if near?(commits[key][i].committer_date, c.committer_date)
-							match = true
-							# Yes. Choose the most recent timestamp, and add the new
-							# directory name to our list.
-							if commits[key][i].committer_date < c.committer_date
-								commits[key][i].committer_date = c.committer_date
-								commits[key][i].token = c.token
-							end
-							commits[key][i].directories << c.directories[0] unless commits[key][i].directories.include? c.directories[0]
-							break
-						end
-					end
-					# This commit lies a long time away from any one we know.
-					# Add it to the list as a new checkin event.
-					commits[key] << c unless match
-				else
-					# We have never seen this developer/message combination. Start a new list.
-					commits[key] = [c]
-				end
-			end
-			# Pull all of the commits out of the hash and return them as a single sorted list.
-			result = commits.values.flatten.sort! { |a,b| a.committer_date <=> b.committer_date }
-
-			# If we have two commits with identical timestamps, arbitrarily choose the first
-			(result.size-1).downto(1) do |i|
-				result.delete_at(i) if result[i].committer_date == result[i-1].committer_date
-			end
-
-			if block_given?
-				result.each { |r| yield r }
-			end
-		end
-
-		# Accepts two dates and determines wether they are close enough together to consider simultaneous.
-		def self.near?(a,b)
-			((a-b).abs < 30*60) # Less than 30 minutes counts as 'near'
-		end
-
-		def self.read_files(io, branch_name, &block)
-			io.each_line do |l|
-				if l =~ /^RCS file: (.*),.$/
-					filename = $1
-					read_file(io, branch_name, filename, &block)
-				end
-			end
-		end
-
-		def self.read_file(io, branch_name, filename, &block)
-			branch_number = nil
-			io.each_line do |l|
-				if l =~ /^head: ([\d\.]+)/
-					unless branch_name
-						branch_number = BranchNumber.new($1)
-					end
-				elsif l =~ /^symbolic names:/
-					if branch_name
-						branch_number = read_symbolic_names(io, branch_name)
-					end
-				elsif l =~ /^----------------------------/
-					read_commits(io, branch_number, filename, &block)
-					return
-				end
-			end
-		end
-
-		def self.read_symbolic_names(io, branch_name)
-			branch_number = nil
-			io.each_line do |l|
-				if l =~ /^\s+([^:]+): ([\d\.]+)/
-					branch_number = BranchNumber.new($2) if $1 == branch_name
-				else
-					return branch_number
-				end
-			end
-		end
-
-		def self.read_commits(io, branch_number, filename, &block)
-			should_yield = nil
-			io.each_line do |l|
-				if l =~ /^\s$/
-					return
-				elsif l =~ /^revision ([\d.]+)/
-					commit_number = $1
-					if branch_number
-						should_yield = branch_number.on_same_line?(BranchNumber.new(commit_number))
-					else
-						should_yield = false
-					end
-					read_commit(io, filename, commit_number, should_yield, &block)
-				end
-			end
-		end
-
-		def self.read_commit(io, filename, commit_number, should_yield)
-			io.each_line do |l|
-				if l =~ /^date: (.*);  author: ([^;]+);  state: (\w+);/
-					committer_date = $1
-					committer_name = $2
-					state = $3
-					# CVS creates a "phantom" dead file at 1.1 on the head if a file
-					#   is created on a branch. Ignore this file.
-					should_yield = false if commit_number == '1.1' and state == 'dead'
-					message = read_message(io)
-					if should_yield
-						commit = OhlohScm::Commit.new
-						commit.token = committer_date[0..18]
-						commit.committer_date = Time.parse(committer_date[0..18] + ' +0000').utc
-						commit.committer_name = committer_name
-						commit.message = message
-						commit.directories = [File.dirname(filename).intern]
-						yield commit
-					end
-					return
-				end
-			end
-		end
-
-		def self.read_message(io)
-			message = ''
-			first_line = true
-			io.each_line do |l|
-				if l =~ /^branches: / and first_line # the first line might be 'branches:', skip it.
-					# do nothing
-				else
-					l.chomp!
-					if l == '=============================================================================' or
-						l == '----------------------------'
-						return message
-					end
-					message += "\n" if message.length != 0
-					message += l
-				end
-				first_line = false
-			end
-			message
-		end
-	end
-
-	if $0 == __FILE__
-		require File.dirname(__FILE__) + '/../../config/environment'
-		LogParser.parse(STDIN).each do |r|
-			r.pretty_print(STDOUT)
-		end
-	end
-end

data/lib/ohloh_scm/parsers/git_parser.rb

@@ -1,67 +0,0 @@
-module OhlohScm::Parsers
-	class GitParser < Parser
-		def self.scm
-			'git'
-		end
-
-		ANONYMOUS = "(no author)" unless defined?(ANONYMOUS)
-
-		def self.internal_parse(io, opts)
-			e = nil
-			state = :key_values
-
-			io.each do |line|
-				line.chomp!
-
-				# Kind of a hack: the diffs section is not always present.
-				# Also, we don't know when the next commit is going to begin,
-				# so we may need to make an unexpected state change.
-				if line =~ /^commit ([a-z0-9]{40,40})$/
-					state = :key_values
-				elsif state == :message and line =~ /^[ADM]\s+(.+)$/
-					state = :diffs
-				end
-
-				if state == :key_values
-					case line
-					when /^commit ([a-z0-9]{40,40})$/
-						sha1 = $1
-						yield e if e
-						e = OhlohScm::Commit.new
-						e.diffs = []
-						e.token = sha1
-						e.author_name = ANONYMOUS
-					when /^Author: (.+) <(.*)>$/
-						# In the rare case that the Git repository does not contain any names (see OpenEmbedded for example)
-						# we use the email instead.
-						e.author_name = $1 || $2
-						e.author_email = $2
-					when /^Date: (.*)$/
-						e.author_date = Time.parse($1).utc # Note strongly: MUST be RFC2822 format to parse properly
-						state = :message
-					end
-
-				elsif state == :message
-					case line
-					when /    (.*)/
-						if e.message
-							e.message << "\n" << $1
-						else
-							e.message = $1
-						end
-					end
-
-				elsif state == :diffs
-					if line =~ /^([ADM])\t(.+)$/
-						e.diffs << OhlohScm::Diff.new( :action => $1, :path => $2)
-					end
-
-				else
-					raise RuntimeError("Unknown parser state #{state.to_s}")
-				end
-			end
-
-			yield e if e
-		end
-	end
-end

data/lib/ohloh_scm/parsers/git_styled_parser.rb

@@ -1,95 +0,0 @@
-module OhlohScm::Parsers
-	# This parser processes Git whatchanged generated using a custom style.
-	# This custom style provides additional information required by Ohloh.
-	class GitStyledParser < Parser
-		def self.scm
-			'git'
-		end
-
-		def self.whatchanged
-			"git whatchanged --root -m --abbrev=40 --max-count=1 --always --pretty=#{format}"
-		end
-
-		def self.format
-		  "format:'__BEGIN_COMMIT__%nCommit: %H%nAuthor: %an%nAuthorEmail: %ae%nDate: %aD%n__BEGIN_COMMENT__%n%s%n%b%n__END_COMMENT__%n'"
-		end
-
-		ANONYMOUS = "(no author)" unless defined?(ANONYMOUS)
-
-		def self.internal_parse(io, opts)
-			e = nil
-			state = :key_values
-
-			io.each do |line|
-				line.chomp!
-
-				# Kind of a hack: the diffs section is not always present.
-				# If we are expecting a line of diffs, but instead find a line
-				# starting with "Commit: ", that means the diffs section
-				# is missing for this commit,  and we need to fix up our state.
-				if state == :diffs and line =~ /^Commit: ([a-z0-9]+)$/
-					state = :key_values
-				end
-
-				if state == :key_values
-					if line =~ /^Commit: ([a-z0-9]+)$/
-						sha1 = $1
-						yield e if e
-						e = OhlohScm::Commit.new
-						e.diffs = []
-						e.token = sha1
-						e.author_name = ANONYMOUS
-					elsif line =~ /^Author: (.+)$/
-						e.author_name = $1
-					elsif line =~ /^Date: (.*)$/
-            # MUST be RFC2822 format to parse properly, else defaults to epoch time
-            e.author_date = parse_date($1)
-					elsif line == "__BEGIN_COMMENT__"
-						state = :message
-					elsif line =~ /^AuthorEmail: (.+)$/
-						e.author_email = $1
-						# In the rare case that the Git repository does not contain any names (see OpenEmbedded for example)
-						# we use the email instead.
-						e.author_name = $1 if e.author_name.to_s.empty? || e.author_name == ANONYMOUS
-					end
-
-				elsif state == :message
-					if line == "__END_COMMENT__"
-						state = :diffs
-					elsif line != "<unknown>"
-						if e.message
-							e.message << "\n" << line
-						else
-							e.message = line
-						end
-					end
-
-				elsif state == :diffs
-					if line == "__BEGIN_COMMIT__"
-						state = :key_values
-					elsif line =~ /:([0-9]+) ([0-9]+) ([a-z0-9]+) ([a-z0-9]+) ([A-Z])\t"?(.+[^"])"?$/
-						# Submodules have a file mode of '160000', which indicates a "gitlink"
-						# We ignore submodules completely.
-						e.diffs << OhlohScm::Diff.new( :action => $5, :path => $6, :sha1 => $4, :parent_sha1 => $3 ) unless $1=='160000' || $2=='160000'
-					elsif line =~ /:([0-9]+) ([0-9]+) ([a-z0-9]+) ([a-z0-9]+) (R[0-9]+)\t"?(.+[^"])"?$/
-                                                old_path, new_path = $6.split("\t")
-						unless $1=='160000' || $2=='160000'
-						  e.diffs << OhlohScm::Diff.new( :action => 'D', :path => old_path, :sha1 => NULL_SHA1, :parent_sha1 => $3 )
-						  e.diffs << OhlohScm::Diff.new( :action => 'A', :path => new_path, :sha1 => $4, :parent_sha1 => NULL_SHA1 )
-                                                end
-					end
-
-				else
-					raise RuntimeError("Unknown parser state #{state.to_s}")
-				end
-			end
-
-			yield e if e
-		end
-
-    def self.parse_date(date)
-      t = Time.rfc2822(date) rescue Time.at(0)
-      t.utc
-    end
-	end
-end