ohloh_scm 2.5.1 → 3.0.1

data/lib/ohloh_scm/parser/git_parser.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  # This parser processes Git whatchanged generated using a custom style.
+  # This custom style provides additional information required by OpenHub.
+  class GitParser < Parser
+    class << self
+      def whatchanged
+        "git whatchanged --root -m --abbrev=40 --max-count=1 --always --pretty=#{format}"
+      end
+
+      def 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)
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def internal_parse(io, _)
+        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.
+          state = :key_values if state == :diffs && line =~ /^Commit: ([a-z0-9]+)$/
+
+          if state == :key_values
+            if line =~ /^Commit: ([a-z0-9]+)$/
+              sha1 = Regexp.last_match(1)
+              yield e if e
+              e = build_commit(sha1)
+            elsif line =~ /^Author: (.+)$/
+              e.author_name = Regexp.last_match(1)
+            elsif line =~ /^Date: (.*)$/
+              # MUST be RFC2822 format to parse properly, else defaults to epoch time
+              e.author_date = parse_date(Regexp.last_match(1))
+            elsif line == '__BEGIN_COMMENT__'
+              state = :message
+            elsif line =~ /^AuthorEmail: (.+)$/
+              e.author_email = Regexp.last_match(1)
+              # In the rare case that the Git repository does not contain any names,
+              #   we use the email instead (see OpenEmbedded for example).
+              if e.author_name.to_s.empty? || e.author_name == ANONYMOUS
+                e.author_name = Regexp.last_match(1)
+              end
+            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
+            # Ref: https://git-scm.com/docs/git-diff-index#Documentation/git-diff-index.txt-git-diff-filesltpatterngt82308203
+            elsif line =~ /:([0-9]+) ([0-9]+) ([a-z0-9]+) ([a-z0-9]+) ([A-Z])\t"?(.+)"?$/
+              add_generic_diff(e, Regexp.last_match)
+            elsif line =~ /:([0-9]+) ([0-9]+) ([a-z0-9]+) ([a-z0-9]+) (R[0-9]+)\t"?(.+)"?$/
+              add_rename_edit_diff(e, Regexp.last_match)
+            end
+          else
+            raise RuntimeError("Unknown parser state #{state}")
+          end
+        end
+
+        yield e if e
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      private
+
+      def build_commit(sha1)
+        commit = OhlohScm::Commit.new
+        commit.diffs = []
+        commit.token = sha1
+        commit.author_name = ANONYMOUS
+        commit
+      end
+
+      def add_generic_diff(commit, match_data)
+        src_mode, dst_mode, parent_sha1, sha1, action, path = match_data[1..-1]
+
+        return if path == '.gitmodules' # contains submodule path config.
+        # Submodules have a file mode of '160000'(gitlink). We ignore submodules completely.
+        return if src_mode == '160000' || dst_mode == '160000'
+
+        commit.diffs << OhlohScm::Diff.new(action: action, path: path,
+                                           sha1: sha1, parent_sha1: parent_sha1)
+      end
+
+      def add_rename_edit_diff(commit, match_data)
+        src_mode, dst_mode, parent_sha1, sha1, _, path = match_data[1..-1]
+
+        return if src_mode == '160000' || dst_mode == '160000'
+
+        old_path, new_path = path.split("\t")
+        commit.diffs << OhlohScm::Diff.new(action: 'D', path: old_path,
+                                           sha1: null_sha1, parent_sha1: parent_sha1)
+        commit.diffs << OhlohScm::Diff.new(action: 'A', path: new_path,
+                                           sha1: sha1, parent_sha1: null_sha1)
+      end
+
+      def null_sha1
+        OhlohScm::Git::Activity::NULL_SHA1
+      end
+
+      def parse_date(date)
+        Time.rfc2822(date).utc
+      rescue ArgumentError
+        Time.at(0)
+      end
+    end
+  end
+end

data/lib/ohloh_scm/parser/hg_parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  # This parser processes Mercurial logs which have been generated using a custom style.
+  # This custom style provides additional information required by Ohloh.
+  class HgParser < Parser
+    class << self
+      # Use when you want to include diffs
+      def verbose_style_path
+        File.expand_path("#{__dir__}/hg_verbose_style")
+      end
+
+      # Use when you do not want to include diffs
+      def style_path
+        File.expand_path("#{__dir__}/hg_style")
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def internal_parse(buffer, _)
+        e = nil
+        state = :data
+
+        buffer.each_line do |line|
+          next_state = state
+          if state == :data
+            case line
+            when /^changeset:\s+([0-9a-f]+)/
+              e = build_commit(Regexp.last_match(1))
+            when /^user:\s+(.+?)(\s+<(.+)>)?$/
+              e.committer_name = Regexp.last_match(1)
+              e.committer_email = Regexp.last_match(3)
+            when /^date:\s+([\d\.]+)/
+              time = Regexp.last_match(1)
+              e.committer_date = Time.at(time.to_f).utc
+            when "__BEGIN_FILES__\n"
+              next_state = :files
+            when "__BEGIN_COMMENT__\n"
+              next_state = :long_comment
+            when "__END_COMMIT__\n"
+              yield e if block_given?
+              e = nil
+            end
+
+          elsif state == :files
+            if line == "__END_FILES__\n"
+              next_state = :data
+            elsif line =~ /^([MAD]) (.+)$/
+              e.diffs << OhlohScm::Diff.new(action: Regexp.last_match(1),
+                                            path: Regexp.last_match(2))
+            end
+
+          elsif state == :long_comment
+            if line == "__END_COMMENT__\n"
+              next_state = :data
+            elsif e.message
+              e.message << line
+            else
+              e.message = line
+            end
+          end
+          state = next_state
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      private
+
+      def build_commit(token)
+        OhlohScm::Commit.new.tap do |commit|
+          commit.diffs = []
+          commit.token = token
+        end
+      end
+    end
+  end
+end

data/lib/ohloh_scm/parser/svn_parser.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  class SvnParser < Parser
+    class << self
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def internal_parse(buffer, _opts)
+        e = nil
+        state = :data
+        previous_state = nil
+        previous_line = nil
+
+        buffer.each_line do |l|
+          l.chomp!
+          next_state = state
+          if state == :data
+            if l =~ /^r(\d+) \| (.*) \| (\d+-\d+-\d+ .*) \(.*\) \| .*/
+              yield e if e && block_given?
+
+              e = OhlohScm::Commit.new
+              e.token = Regexp.last_match(1).to_i
+              e.committer_name = Regexp.last_match(2)
+              e.committer_date = Time.parse(Regexp.last_match(3)).utc
+            elsif l == 'Changed paths:'
+              next_state = :diffs
+            elsif l.empty?
+              next_state = :comment
+            elsif previous_state == :comment
+              next_state = :comment
+              e.message ||= ''
+              e.message << "\n"
+              e.message << previous_line
+              e.message << "\n"
+              e.message << l
+            end
+
+          elsif state == :diffs
+            if l =~ /^   (\w) ([^\(\)]+)( \(from (.+):(\d+)\))?$/
+              e.diffs ||= []
+              e.diffs << OhlohScm::Diff.new(action: Regexp.last_match(1),
+                                            path: Regexp.last_match(2),
+                                            from_path: Regexp.last_match(4),
+                                            from_revision: Regexp.last_match(5).to_i)
+            else
+              next_state = :comment
+            end
+
+          # The :log_embedded_within_comment state is special-case code to fix the Wireshark
+          # project, which includes fragments of svn logs within its comment blocks, which really
+          # confuses the parser. I am not sure whether only Wireshark does this, but I suspect it
+          # happens because there is a tool out there somewhere to generate
+          # these embedded log comments.
+          elsif state == :log_embedded_within_comment
+            e.message << "\n"
+            e.message << l
+            next_state = :comment if l =~ /============================ .* log end =+/
+
+          elsif state == :comment
+            if /------------------------------------------------------------------------/.match?(l)
+              next_state = :data
+            elsif /============================ .* log start =+/.match?(l)
+              e.message << "\n"
+              e.message << l
+              next_state = :log_embedded_within_comment
+            elsif e.message
+              e.message << "\n"
+              e.message << l
+            else
+              e.message = l
+            end
+          end
+          previous_state = state
+          state = next_state
+          previous_line = l
+        end
+        yield e if block_given?
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/ohloh_scm/py_bridge.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'py_bridge/hg_client'
+require_relative 'py_bridge/bzr_client'
+
+module OhlohScm
+  module PyBridge
+  end
+end

data/lib/ohloh_scm/py_bridge/bzr_client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'py_client'
+
+module OhlohScm
+  module PyBridge
+    class BzrClient < PyClient
+      def initialize(repository_url)
+        @repository_url = repository_url
+        @py_script = "#{__dir__}/bzr_server.py"
+      end
+
+      def cat_file(revision, file)
+        send_command("CAT_FILE|#{revision}|#{file}")
+      end
+
+      def parent_tokens(revision)
+        send_command("PARENT_TOKENS|#{revision}").split('|')
+      end
+
+      private
+
+      def open_repository
+        send_command("REPO_OPEN|#{@repository_url}")
+      end
+    end
+  end
+end

data/lib/ohloh_scm/{adapters/bzrlib/bzrlib_pipe_server.py → py_bridge/bzr_server.py}

@@ -2,7 +2,7 @@ from bzrlib.branch import Branch
 from bzrlib.revisionspec import RevisionSpec
 import os
 import sys
-import time 
+import time
 import traceback
 import logging
 

data/lib/ohloh_scm/py_bridge/hg_client.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'py_client'
+
+module OhlohScm
+  module PyBridge
+    class HgClient < PyClient
+      def initialize(repository_url)
+        @repository_url = repository_url
+        @py_script = "#{__dir__}/hg_server.py"
+      end
+
+      def cat_file(revision, file)
+        send_command("CAT_FILE\t#{revision}\t#{file}")
+      rescue RuntimeError => e
+        raise unless e.message =~ /not found in manifest/ # File does not exist.
+      end
+
+      def parent_tokens(revision)
+        send_command("PARENT_TOKENS\t#{revision}").split("\t")
+      end
+
+      private
+
+      def open_repository
+        send_command("REPO_OPEN\t#{@repository_url}")
+      end
+    end
+  end
+end

data/lib/ohloh_scm/py_bridge/py_client.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  class PyClient
+    def start
+      @stdin, @stdout, @stderr, wait_thr = Open3.popen3 "python #{@py_script}"
+      @pid = wait_thr[:pid]
+      open_repository
+    end
+
+    def shutdown
+      send_command('QUIT')
+      [@stdin, @stdout, @stderr].reject(&:closed?).each(&:close)
+      Process.waitpid(@pid, Process::WNOHANG)
+    end
+
+    private
+
+    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
+      return if flag == 'F'
+
+      raise_subprocess_error(flag)
+
+      # read content from stdout
+      @stdout.read(size)
+    end
+
+    def raise_subprocess_error(flag)
+      return unless flag == 'E'
+
+      error = @stdout.read(size)
+      raise "Exception in server process\n#{error}"
+    end
+  end
+end

data/lib/ohloh_scm/scm.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  class Scm
+    include OhlohScm::System
+    extend Forwardable
+    def_delegators :@core, :status, :activity
+    attr_reader :url, :username, :password
+    attr_accessor :branch_name
+
+    def initialize(core:, url:, branch_name: nil, username: nil, password: nil)
+      @core = core
+      @url = url.strip if url
+      @branch_name = branch_name&.strip
+      @branch_name = nil if branch_name&.empty?
+      @username = username&.strip
+      @password = password&.strip
+    end
+
+    def normalize; end
+
+    def pull(_, _); end
+
+    def vcs_path; end
+  end
+end