ohloh_scm 2.5.1 → 3.0.1

data/lib/ohloh_scm/hg/scm.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  module Hg
+    class Scm < OhlohScm::Scm
+      def pull(remote_scm, callback)
+        err_msg = "Cannot pull remote_scm #{remote_scm.inspect}"
+        raise ArgumentError, err_msg unless remote_scm.is_a?(Hg::Scm)
+
+        clone_or_fetch(remote_scm, callback)
+      end
+
+      def branch_name_or_default
+        branch_name || :default
+      end
+
+      def vcs_path
+        "#{url}/.hg"
+      end
+
+      private
+
+      def clone_or_fetch(remote_scm, callback)
+        callback.update(0, 1)
+
+        status.exist? ? revert_and_pull(remote_scm) : clone_repository(remote_scm)
+
+        clean_up_disk
+
+        callback.update(1, 1)
+      end
+
+      def clone_repository(remote_scm)
+        run "rm -rf '#{url}'"
+        run "hg clone '#{remote_scm.url}' '#{url}'"
+      end
+
+      def revert_and_pull(remote_scm)
+        branch_opts = "-r #{remote_scm.branch_name}" if branch_name
+        run "cd '#{url}' && hg revert --all && hg pull #{branch_opts} -u -y '#{remote_scm.url}'"
+      end
+
+      def clean_up_disk
+        return unless FileTest.exist?(url)
+
+        run "cd #{url} && find . -maxdepth 1 -not -name .hg -not -name . -print0"\
+              ' | xargs -0 rm -rf --'
+      end
+    end
+  end
+end

data/lib/ohloh_scm/hg/status.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  module Hg
+    class Status < OhlohScm::Status
+    end
+  end
+end

data/lib/ohloh_scm/hg/validation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  module Hg
+    class Validation < OhlohScm::Validation
+      private
+
+      def validate_server_connection
+        msg = "The server did not respond to the 'hg id' command. Is the URL correct?"
+        @errors << [:failed, msg] unless status.exist?
+      end
+
+      def public_url_regex
+        %r{^(http|https)://(\w+@)?[\w\-\.]+(:\d+)?/[\w\-\./\~\+]*$}
+      end
+    end
+  end
+end

data/lib/ohloh_scm/parser.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'parser/array_writer'
+require_relative 'parser/branch_number'
+
+module OhlohScm
+  class Parser
+    class << self
+      def parse(buffer = '', opts = {})
+        buffer = StringIO.new(buffer) if buffer.is_a?(String)
+        writer = ArrayWriter.new unless block_given?
+
+        internal_parse(buffer, opts) do |commit|
+          if commit
+            yield commit if block_given?
+            writer&.write_commit(commit)
+          end
+        end
+
+        writer&.buffer
+      end
+
+      def internal_parse; end
+    end
+  end
+end
+
+require_relative 'parser/git_parser'
+require_relative 'parser/cvs_parser'
+require_relative 'parser/svn_parser'

data/lib/ohloh_scm/parser/array_writer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  class ArrayWriter
+    attr_accessor :buffer
+
+    def initialize(buffer = [])
+      @buffer = buffer
+    end
+
+    def write_commit(commit)
+      @buffer << commit
+    end
+  end
+end

data/lib/ohloh_scm/parser/branch_number.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  class BranchNumber
+    def initialize(branch_number)
+      @num = branch_number.split('.').collect(&:to_i)
+      # Accomodate CVS magic branch numbers by swapping the magic zero
+      # That is, 1.1.0.2 => 1.1.2.0
+      @num[-1], @num[-2] = @num[-2], @num[-1] if (@num.size > 2) && @num[-2].zero?
+    end
+
+    # Returns true if <branch_number> is an ancestor of this object,
+    # or if this object follows <branch_number> on the same line.
+    def on_same_line?(branch_number)
+      b = branch_number.to_a
+
+      # b has been branched more times than this object.
+      return false if b.size > @num.size
+      if b.size == @num.size
+        # b and a have the same number of branch events.
+        # If either one inherits from the other then they
+        # are on the same line.
+        return (inherits_from?(branch_number) || branch_number.inherits_from?(self))
+      end
+      # b has not been branched as often as this object.
+      # That's OK if b is an ancestor of this object.
+      return inherits_from?(branch_number) if b.size < @num.size
+    end
+
+    def to_a
+      @num
+    end
+
+    protected
+
+    # Returns true if <branch_number> is an ancestor of this object.
+    # Also returns true if <branch_number> is the same as this object.
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    def inherits_from?(branch_number)
+      b = branch_number.to_a
+
+      return false if b.size > @num.size
+
+      return false if b.size == 2 && descendant?(b)
+
+      unless b.size == 2
+        0.upto(b.size - 2) do |i|
+          return false if b[i] != @num[i]
+        end
+        return false if b[-1] > @num[b.size - 1]
+      end
+      true
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+    private
+
+    def descendant?(branch_number)
+      return true if branch_number[0] > @num[0] ||
+                     ((branch_number[0] == @num[0]) && (branch_number[1] > @num[1]))
+    end
+  end
+end

data/lib/ohloh_scm/{parsers → parser}/bzr_xml_parser.rb

@@ -1,25 +1,28 @@
+# frozen_string_literal: true
+
 require 'rexml/document'
 require 'rexml/streamlistener'
+require 'time'
 
-module OhlohScm::Parsers
-	class BazaarListener
-		include REXML::StreamListener
-		attr_accessor :callback
+module OhlohScm
+  class BazaarListener
+    include REXML::StreamListener
+    attr_accessor :callback, :commit, :diff
+    attr_writer :text
 
-		def initialize(callback)
-			@callback = callback
+    def initialize(callback)
+      @callback = callback
       @merge_commit = []
       @state = :none
       @authors = []
-		end
-
-		attr_accessor :text, :commit, :diff
+    end
 
-		def tag_start(name, attrs)
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    def tag_start(name, attrs)
       case name
       when 'log'
-				@commit = OhlohScm::Commit.new
-				@commit.diffs = []
+        @commit = OhlohScm::Commit.new
+        @commit.diffs = []
       when 'affected-files'
         @diffs = []
       when 'added', 'modified', 'removed', 'renamed'
@@ -33,54 +36,59 @@ module OhlohScm::Parsers
       when 'authors'
         @state = :collect_authors
         @authors = []
-			end
-		end
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-		def tag_end(name)
-			case name
-			when 'log'
-				@callback.call(@commit)
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+    def tag_end(name)
+      case name
+      when 'log'
+        @callback.call(@commit)
       when 'revisionid'
         @commit.token = @text
       when 'message'
         @commit.message = @cdata
-			when 'committer'
+      when 'committer'
         committer = BzrXmlParser.capture_name(@text)
-				@commit.committer_name = committer[0]
-				@commit.committer_email = committer[1]
-			when 'author'
+        @commit.committer_name = committer[0]
+        @commit.committer_email = committer[1]
+      when 'author'
         author = BzrXmlParser.capture_name(@text)
-				@authors << {:author_name => author[0], :author_email => author[1]}
-			when 'timestamp'
-				@commit.committer_date = Time.parse(@text)
+        @authors << { author_name: author[0], author_email: author[1] }
+      when 'timestamp'
+        @commit.committer_date = Time.parse(@text)
       when 'file'
-        if @state == :collect_files
-          @diffs.concat(parse_diff(@action, @text, @before_path))
-        end
+        @diffs.concat(parse_diff(@action, @text, @before_path)) if @state == :collect_files
         @before_path = nil
         @text = nil
       when 'added', 'modified', 'removed', 'renamed'
         @state = :none
       when 'affected-files'
-			  @commit.diffs = remove_dupes(@diffs)
+        @commit.diffs = remove_dupes(@diffs)
       when 'merge'
         @commit = @merge_commit.pop
       when 'authors'
         @commit.author_name = @authors[0][:author_name]
         @commit.author_email = @authors[0][:author_email]
         @authors.clear
-			end
-		end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
 
+    # rubocop:disable Style/TrivialAccessors # Cannot use attr_writer; we need cdata not cdata=.
     def cdata(data)
       @cdata = data
     end
 
-		def text(text)
-			@text = text
-		end
+    def text(text)
+      @text = text
+    end
+    # rubocop:enable Style/TrivialAccessors
 
     private
+
+    # rubocop:disable Metrics/MethodLength
     # Parse one single diff
     def parse_diff(action, path, before_path)
       diffs = []
@@ -91,20 +99,21 @@ module OhlohScm::Parsers
         # Note that is possible to be renamed to the empty string!
         # This happens when a subdirectory is moved to become the root.
       when 'renamed'
-        diffs = [ OhlohScm::Diff.new(:action => 'D', :path => before_path),
-                  OhlohScm::Diff.new(:action => 'A', :path => path || '')]
+        diffs = [OhlohScm::Diff.new(action: 'D', path: before_path),
+                 OhlohScm::Diff.new(action: 'A', path: path || '')]
       when 'added'
-        diffs = [OhlohScm::Diff.new(:action => 'A', :path => path)]
+        diffs = [OhlohScm::Diff.new(action: 'A', path: path)]
       when 'modified'
-        diffs = [OhlohScm::Diff.new(:action => 'M', :path => path)]
+        diffs = [OhlohScm::Diff.new(action: 'M', path: path)]
       when 'removed'
-        diffs = [OhlohScm::Diff.new(:action => 'D', :path => path)]
+        diffs = [OhlohScm::Diff.new(action: 'D', path: path)]
       end
       diffs.each do |d|
         d.path = strip_trailing_asterisk(d.path)
       end
       diffs
     end
+    # rubocop:enable Metrics/MethodLength
 
     def strip_trailing_asterisk(path)
       path[-1..-1] == '*' ? path[0..-2] : path
@@ -113,23 +122,23 @@ module OhlohScm::Parsers
     def remove_dupes(diffs)
       BzrXmlParser.remove_dupes(diffs)
     end
+  end
+
+  class BzrXmlParser < Parser
+    NAME_REGEX = /^(.+?)(\s+<(.+)>\s*)?$/.freeze
+    def self.internal_parse(buffer, _)
+      buffer = '<?xml?>' if buffer.is_a?(StringIO) && buffer.length < 2
+      REXML::Document.parse_stream(buffer,
+                                   BazaarListener.new(proc { |c| yield c if block_given? }))
+    rescue EOFError => e
+      puts e.message
+    end
 
-	end
-
-	class BzrXmlParser < Parser
-    NAME_REGEX = /^(.+?)(\s+<(.+)>\s*)?$/
-		def self.internal_parse(buffer, opts)
-			buffer = '<?xml?>' if buffer.is_a?(StringIO) and buffer.length < 2
-			begin
-				REXML::Document.parse_stream(buffer, BazaarListener.new(Proc.new { |c| yield c if block_given? }))
-			rescue EOFError
-			end
-		end
-
-		def self.scm
-			'bzr'
-		end
+    def self.scm
+      'bzr'
+    end
 
+    # rubocop:disable Metrics/AbcSize
     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.
@@ -143,6 +152,7 @@ module OhlohScm::Parsers
         d.action = 'M' if diffs.select { |x| x.path == d.path }.size > 1
       end.uniq
     end
+    # rubocop:enable Metrics/AbcSize
 
     # Bazaar expects committer/author to be specified in this format
     # Name <email>, or John Doe <jdoe@example.com>
@@ -154,5 +164,5 @@ module OhlohScm::Parsers
       email = parts[3]
       [name, email]
     end
-	end
+  end
 end

data/lib/ohloh_scm/parser/cvs_parser.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength
+module OhlohScm
+  class CvsParser < Parser
+    class << self
+      # Given an IO to a CVS rlog, returns a list of
+      # commits (developer/date/message).
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def internal_parse(io, _opts)
+        commits = {}
+
+        read_files(io) 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.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?
+              next unless 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
+              unless commits[key][i].directories.include? c.directories[0]
+                commits[key][i].directories << c.directories[0]
+              end
+              break
+            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
+
+        result.each { |r| yield r } if block_given?
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      private
+
+      # Accepts two dates and
+      # determines wether they are close enough together to consider simultaneous.
+      def near?(date1, date2)
+        ((date1 - date2).abs < 30 * 60) # Less than 30 minutes counts as 'near'
+      end
+
+      def read_files(io, &block)
+        io.each_line do |l|
+          if l =~ /^RCS file: (.*),.$/
+            filename = Regexp.last_match(1)
+            read_file(io, filename, &block)
+          end
+        end
+      end
+
+      def read_file(io, filename, &block)
+        branch_number = nil
+        io.each_line do |l|
+          if l =~ /^head: ([\d\.]+)/
+            branch_number = BranchNumber.new(Regexp.last_match(1))
+          elsif /^----------------------------/.match?(l)
+            read_commits(io, branch_number, filename, &block)
+          end
+        end
+      end
+
+      def read_commits(io, branch_number, filename, &block)
+        should_yield = nil
+        io.each_line do |l|
+          break if /^\s$/.match?(l)
+
+          l =~ /^revision ([\d.]+)/
+          commit_number = Regexp.last_match(1)
+          should_yield = branch_number&.on_same_line?(BranchNumber.new(commit_number))
+          read_commit(io, filename, commit_number, should_yield, &block)
+        end
+      end
+
+      def read_commit(io, filename, commit_number, should_yield)
+        io.each_line do |l|
+          next unless l =~ /^date: (.*);  author: ([^;]+);  state: (\w+);/
+
+          state = Regexp.last_match(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') && (state == 'dead')
+          message = read_message(io)
+          if should_yield
+            yield build_commit(Regexp.last_match(1), Regexp.last_match(2), message, filename)
+          end
+          break
+        end
+      end
+
+      def build_commit(committer_date, committer_name, message, filename)
+        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]
+        commit
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def read_message(io)
+        message = ''
+        first_line = true
+        io.each_line do |l|
+          unless l =~ /^branches: / && first_line # the first line might be 'branches:', skip it.
+            l.chomp!
+            return message if separator?(l)
+
+            message += "\n" unless message.empty?
+            message += l
+          end
+          first_line = false
+        end
+        message
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def separator?(line)
+        %w[=============================================================================
+           ----------------------------].include?(line)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength