ohloh_scm 2.5.1 → 3.0.1

data/lib/ohloh_scm/core.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+using OhlohScm::StringExtensions
+
+module OhlohScm
+  class Core
+    extend Forwardable
+    def_delegators :validation, :validate, :errors
+    attr_reader :scm, :activity, :status, :validation
+
+    def initialize(scm_type, url, branch_name, username, password)
+      scm_opts = { core: self, url: url, branch_name: branch_name,
+                   username: username, password: password }
+      scm_class_name = scm_type.to_s.camelize
+
+      @scm = OhlohScm.const_get(scm_class_name)::Scm.new(scm_opts)
+      @activity = OhlohScm.const_get(scm_class_name)::Activity.new(self)
+      @status = OhlohScm.const_get(scm_class_name)::Status.new(self)
+      @validation = OhlohScm.const_get(scm_class_name)::Validation.new(self)
+    end
+  end
+end

data/lib/ohloh_scm/cvs.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'cvs/scm'
+require_relative 'cvs/status'
+require_relative 'cvs/activity'
+require_relative 'cvs/validation'
+
+module OhlohScm
+  module Cvs
+  end
+end

data/lib/ohloh_scm/cvs/activity.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  module Cvs
+    class Activity < OhlohScm::Activity
+      def tags
+        cmd = "cvs -Q -d #{url} rlog -h #{scm.branch_name} | awk -F\"[.:]\" '/^\\t/&&$(NF-1)!=0'"
+        tag_strings = run(cmd).split(/\n/)
+        tag_strings.map do |tag_string|
+          tag_name, version = tag_string.split(':')
+          [tag_name.delete("\t"), version.strip]
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def commits(opts = {})
+        after = opts[:after]
+        result = []
+
+        open_log_file(opts) do |io|
+          result = OhlohScm::CvsParser.parse(io)
+        end
+
+        # Git converter needs a backpointer to the scm for each commit
+        result.each { |c| c.scm = scm }
+
+        return result if result.empty? # 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.
+        # 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|
+          next unless result[i].token&.match?(re) # We found the match for after
+          return [] if i == result.size - 1 # There aren't any new commits.
+
+          return result[i + 1..-1]
+        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 "token '#{after}' not found in rlog."
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def export_tag(dest_dir, tag_name = 'HEAD')
+        run "cvsnt -d #{url} export -d'#{dest_dir}' -r #{tag_name} '#{scm.branch_name}'"
+      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
+        return if protocol != :ext
+
+        ensure_key_file = File.dirname(__FILE__) + '/../../../../bin/ensure_key'
+        cmd = "#{ensure_key_file} '#{host}'"
+        run_with_err(cmd)
+      end
+
+      private
+
+      # 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.
+      # rubocop:disable Metrics/AbcSize
+      def open_log_file(opts = {})
+        ensure_host_key
+        status.lock?
+        run "cvsnt -d #{url} rlog #{opt_branch} #{opt_time(opts[:after])} '#{scm.branch_name}'"\
+              " | #{string_encoder_path} > #{rlog_filename}"
+        File.open(rlog_filename, 'r') { |file| yield file }
+      ensure
+        File.delete(rlog_filename) if File.exist?(rlog_filename)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def opt_time(after = nil)
+        return '' unless after
+
+        most_recent_time = parse_time(after) - 10
+        # rubocop:disable Metrics/LineLength
+        " -d '#{most_recent_time.strftime('%Y-%m-%d %H:%M:%S')}Z<#{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')}Z' "
+        # rubocop:enable Metrics/LineLength
+      end
+
+      def rlog_filename
+        File.join(temp_folder, (url + scm.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(Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i,
+                  Regexp.last_match(4).to_i, Regexp.last_match(5).to_i, Regexp.last_match(6).to_i)
+        end
+      end
+
+      # returns the host this adapter is connecting to
+      def host
+        @host ||= begin
+                    url =~ /@([^:]*):/
+                    Regexp.last_match(1)
+                  end
+      end
+
+      # returns the protocol this adapter connects with
+      def protocol
+        @protocol ||= case url
+                      when /^:pserver/ then :pserver
+                      when /^:ext/ then :ext
+                      end
+      end
+
+      def opt_branch
+        '-b -r1:'
+      end
+    end
+  end
+end

data/lib/ohloh_scm/cvs/scm.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  module Cvs
+    class Scm < OhlohScm::Scm
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
+      def checkout(rev, local_directory)
+        opt_d = rev.token ? "-D'#{rev.token}Z'" : ''
+
+        activity.ensure_host_key
+        if File.exist?(local_directory + '/CVS/Root')
+          # We already have a local enlistment, so do a quick update.
+          if !rev.directories.empty?
+            build_ordered_directory_list(rev.directories).each do |d|
+              if d.empty?
+                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 #{rev.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 File.exist?(parent_path)
+          run "cd #{parent_path} &&
+          cvsnt -d #{url} checkout #{opt_d} -A -d'#{checkout_dir}' '#{branch_name}'"
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def normalize
+        # 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
+
+      private
+
+      # 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.
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      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 url =~ /^\//
+
+        list = []
+        directories = directories.collect { |a| trim_directory(a.to_s).to_s }
+        directories.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 = Regexp.last_match(1)
+            d = d[0..-2] if !d.empty? && (d[-1, 1] == '/')
+          end
+
+          next if 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('/')&.positive?
+            d = File.dirname(d)
+            break if list.include? d
+
+            list << d
+          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
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def trim_directory(dir)
+        # 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 not remote, just leave the directory name as-is
+        root ? dir[root.length..-1] : dir
+      end
+
+      def root
+        return unless url =~ /^:(pserver|ext):.*@[^:]+:(\d+)?(\/.*)$/
+
+        "#{Regexp.last_match(3)}/#{branch_name}/"
+      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 url =~ /:pserver:([\w\-\_]*)(:([\w\-\_]*))?@(.*)$/
+
+        pserver_username = Regexp.last_match(1)
+        pserver_password = Regexp.last_match(3)
+        pserver_remainder = Regexp.last_match(4)
+
+        @username = pserver_username if @username.to_s.empty?
+        @password = pserver_password if @password.to_s.empty?
+
+        @url = ":pserver:#{@username}:#{password}@#{pserver_remainder}"
+      end
+
+      # Based on the URL, take a guess about which forge this code is hosted on.
+      def guess_forge
+        return unless url =~ /.*(pserver|ext).*@(([^\.]+\.)?(cvs|dev)\.)?([^:]+):\//i
+
+        Regexp.last_match(5).downcase
+      end
+    end
+  end
+end

data/lib/ohloh_scm/cvs/status.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  module Cvs
+    class Status < OhlohScm::Status
+      def lock?
+        run "timeout 2m cvsnt -q -d #{scm.url} rlog '#{scm.branch_name}'"
+        false
+      rescue StandardError => e
+        raise 'CVS lock has been found' if e.message =~ /waiting for.*lock in/
+      end
+    end
+  end
+end

data/lib/ohloh_scm/cvs/validation.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module OhlohScm
+  module Cvs
+    class Validation < OhlohScm::Validation
+      include OhlohScm::System
+
+      private
+
+      def validate_server_connection
+        return if ls
+
+        @errors << [:failed, "The cvs server did not respond to an 'ls' command.
+                  Are the URL and branch name correct?"]
+      end
+
+      def branch_name_errors
+        if scm.branch_name.to_s.empty?
+          [:branch_name, "The branch name can't be blank."]
+        elsif scm.branch_name.length > 120
+          [:branch_name, 'The branch name must not be longer than 120 characters.']
+        elsif !scm.branch_name.match?(/^[\w\-\+\.\/\ ]+$/)
+          [:branch_name, "The branch name may contain only letters,
+          numbers, spaces, and the special characters '_', '-', '+', '/', and '.'"]
+        end
+      end
+
+      def public_url_regex
+        /^:(pserver|ext):[\w\-\+\_]*(:[\w\-\+\_]*)?@[\w\-\+\.]+:[0-9]*\/[\w\-\+\.\/]*$/
+      end
+
+      # 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(scm.branch_name, path.to_s)
+
+        cmd = "cvsnt -q -d #{scm.url} ls -e '#{path}'"
+
+        activity.ensure_host_key
+
+        stdout, stderr = run_with_err(cmd)
+        files = get_filenames(stdout)
+
+        error_handled = handle_error(stderr, files, path, cmd)
+        return unless error_handled
+
+        files.sort
+      end
+
+      def get_filenames(output)
+        files = []
+        output.each_line do |s|
+          s.strip!
+          s = Regexp.last_match(1) + '/' if s =~ /^D\/(.*)\/\/\/\/$/
+          s = Regexp.last_match(1) if s =~ /^\/(.*)\/.*\/.*\/.*\/$/
+          next if s == 'CVSROOT/'
+
+          files << s if s && !s.empty?
+        end
+        files
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def handle_error(stderr, files, path, cmd)
+        # 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 |error|
+          error.strip!
+          error_handled = error.empty?
+
+          if error =~ /cvs server: New directory `(#{Regexp.escape(path.to_s)}\/)?(.*)' -- ignored/
+            files << "#{Regexp.last_match(2)}/"
+            error_handled = true
+          end
+
+          ignored_error_handled(error, path)
+          logger.warn { "'#{cmd}' resulted in unhandled error '#{error}'" } unless error_handled
+          break unless error_handled
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def ignored_error_handled(error, path)
+        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/
+        ]
+        ignored_error_messages.any? { |msg| error.match?(msg) }
+      end
+    end
+  end
+end