tetra 2.0.7 → 2.0.8

data/lib/tetra/ui/subcommand.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 module Tetra
   # implements common options and utility methods
@@ -24,12 +24,12 @@ module Tetra
     end
 
     # maps verbosity options to log level
-    def configure_log_level(v, vv, vvv)
-      if vvv
+    def configure_log_level(verbose, very_verbose, very_very_verbose)
+      if very_very_verbose
         log.level = ::Logger::DEBUG
-      elsif vv
+      elsif very_verbose
         log.level = ::Logger::INFO
-      elsif v
+      elsif verbose
         log.level = ::Logger::WARN
       else
         log.level = ::Logger::ERROR
@@ -52,56 +52,62 @@ module Tetra
       dry_running = project.dry_running?
       has_finished = !project.version.nil?
 
-      if (state == :is_in_progress && dry_running) ||
-         (state == :is_not_in_progress && !dry_running) ||
-         (state == :has_finished && !dry_running && has_finished)
+      condition_met = case state
+                      when :is_in_progress
+                        dry_running
+                      when :is_not_in_progress
+                        !dry_running
+                      when :has_finished
+                        !dry_running && has_finished
+                      end
+
+      if condition_met
         yield
       else
-        if (state == :is_in_progress) ||
-           (state == :has_finished && !dry_running && !has_finished)
-          puts "Please start a dry-run first, use \"tetra dry-run\""
-        elsif (state == :is_not_in_progress) ||
-              (state == :has_finished && dry_running)
-          puts "There is a dry-run in progress, please finish it (^D) or abort it (^C^D)"
-        end
+        handle_dry_run_error(state, dry_running, has_finished)
       end
     end
 
     # outputs output of a file generation
     def print_generation_result(project, result_path, conflict_count = 0)
       puts "#{format_path(result_path, project)} generated"
-      puts "Warning: #{conflict_count} unresolved conflicts, please review and commit" if conflict_count > 0
+      puts "Warning: #{conflict_count} unresolved conflicts, please review and commit" if conflict_count.positive?
     end
 
     # generates a version of path relative to the current directory
     def format_path(path, project)
-      full_path = (
-        if Pathname.new(path).relative?
-          File.join(project.full_path, path)
-        else
-          path
-        end
-      )
+      path_obj = Pathname.new(path)
+      full_path = if path_obj.relative?
+                    File.join(project.full_path, path)
+                  else
+                    path
+                  end
       Pathname.new(full_path).relative_path_from(Pathname.new(Dir.pwd))
     end
 
     # handles most fatal exceptions
     def checking_exceptions
       yield
-    rescue Errno::EACCES => e
-      $stderr.puts e
-    rescue Errno::ENOENT => e
+    rescue Errno::EACCES, Errno::ENOENT, Errno::EEXIST => e
       $stderr.puts e
-    rescue Errno::EEXIST => e
-      $stderr.puts e
-    rescue NoProjectDirectoryError => e
+    rescue Tetra::NoProjectDirectoryError => e
       $stderr.puts "#{e.directory} is not a tetra project directory, see \"tetra init\""
-    rescue GitAlreadyInitedError
+    rescue Tetra::GitAlreadyInitedError
       $stderr.puts "This directory is already a tetra project"
-    rescue ExecutionFailed => e
+    rescue Tetra::ExecutionFailed => e
       $stderr.puts "Failed to run `#{e.commandline}` (exit status #{e.status})"
     rescue Interrupt
       $stderr.puts "Execution interrupted by the user"
     end
+
+    private
+
+    def handle_dry_run_error(state, dry_running, has_finished)
+      if (state == :is_in_progress) || (state == :has_finished && !dry_running && !has_finished)
+        puts "Please start a dry-run first, use \"tetra dry-run\""
+      elsif (state == :is_not_in_progress) || (state == :has_finished && dry_running)
+        puts "There is a dry-run in progress, please finish it (^D) or abort it (^C^D)"
+      end
+    end
   end
 end

data/lib/tetra/version.rb

@@ -1,6 +1,5 @@
-# encoding: UTF-8
-
+# frozen_string_literal: true
 # base module for tetra
 module Tetra
-  VERSION = "2.0.7"
+  VERSION = "2.0.8"
 end

data/lib/tetra/version_matcher.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 module Tetra
   # heuristically matches version strings
@@ -10,62 +10,68 @@ module Tetra
     # by a ., -, _, ~ or space
     # returns a [name, version] pair
     def split_version(full_name)
-      matches = full_name.match(/(.*?)(?:[\.\-\_ ~,]?([0-9].*))?$/)
-      if !matches.nil? && matches.length > 1
-        [matches[1], matches[2]]
+      # 1. Match from the start (\A)
+      # 2. Capture everything that is NOT a digit (ZERO or more times) -> *?
+      # 3. Handle the optional separator
+      # 4. Capture the version (MUST start with a digit)
+      matches = full_name.match(/\A(?<name>[^0-9]*?)(?:[.\-_ ~,]?(?<version>[0-9].*))\z/)
+
+      if matches
+        [matches[:name], matches[:version]]
       else
-        [full_string, nil]
+        [full_name, nil]
       end
     end
 
     # returns the "best match" between a version number and a set of available version numbers
-    # using a heuristic criterion. Idea:
-    #  - split the version number in chunks divided by ., - etc.
-    #  - every chunk with same index is "compared", differences make up a score
-    #  - "comparison" is a subtraction if the chunk is an integer, a string distance measure otherwise
-    #  - score weighs differently on chunk index (first chunks are most important)
-    #  - lowest score wins
+    # using a heuristic criterion.
     def best_match(my_version, their_versions)
+      return nil if their_versions.nil? || their_versions.empty?
+
       log.debug("version comparison: #{my_version} vs #{their_versions.join(', ')}")
 
-      my_chunks = my_version.split(/[\.\-\_ ~,]/)
-      their_chunks_hash = Hash[
-                          their_versions.map do |their_version|
-                            their_chunks_for_version = (
-                              if !their_version.nil?
-                                their_version.split(/[\.\-\_ ~,]/)
-                              else
-                                []
-                              end
-                            )
-                            chunks_count = [my_chunks.length - their_chunks_for_version.length, 0].max
-                            their_chunks_for_version += [nil] * chunks_count
-                            [their_version, their_chunks_for_version]
-                          end
-      ]
-
-      max_chunks_length = ([my_chunks.length] + their_chunks_hash.values.map(&:length)).max
-
-      scoreboard = []
-      their_versions.each do |their_version|
-        their_chunks = their_chunks_hash[their_version]
+      my_chunks = my_version.split(Tetra::CHUNK_SEPARATOR_VERSION_MATCHER)
+
+      # Use to_h (Ruby 2.6+) instead of Hash[]
+      # Pre-calculate chunks for all versions to avoid re-splitting in the loop
+      their_chunks_map = their_versions.to_h do |their_version|
+        chunks = their_version ? their_version.split(Tetra::CHUNK_SEPARATOR_VERSION_MATCHER) : []
+
+        # Pad with nil to match my_chunks length if shorter
+        padding_needed = [my_chunks.length - chunks.length, 0].max
+        chunks.fill(nil, chunks.length, padding_needed)
+
+        [their_version, chunks]
+      end
+
+      # Calculate max length across all candidates (including myself)
+      max_chunks_length = ([my_chunks.length] + their_chunks_map.values.map(&:length)).max
+
+      # Calculate scores
+      scoreboard = their_versions.map do |their_version|
+        their_chunks = their_chunks_map[their_version]
         score = 0
+
         their_chunks.each_with_index do |their_chunk, i|
+          # Weighting: Earlier chunks are vastly more important
           score_multiplier = 100**(max_chunks_length - i - 1)
           my_chunk = my_chunks[i]
+
           score += chunk_distance(my_chunk, their_chunk) * score_multiplier
         end
-        scoreboard << { version: their_version, score: score }
+
+        { version: their_version, score: score }
       end
 
-      scoreboard = scoreboard.sort_by { |element| element[:score] }
+      # Sort by lowest score (best match)
+      sorted_scoreboard = scoreboard.sort_by { |entry| entry[:score] }
 
       log.debug("scoreboard: ")
-      scoreboard.each_with_index do |element, i|
-        log.debug("  #{i + 1}. #{element[:version]} (score: #{element[:score]})")
+      sorted_scoreboard.each_with_index do |entry, i|
+        log.debug("  #{i + 1}. #{entry[:version]} (score: #{entry[:score]})")
       end
 
-      return scoreboard.first[:version] unless scoreboard.first.nil?
+      sorted_scoreboard.first[:version]
     end
 
     # returns a score representing the distance between two version chunks
@@ -73,19 +79,31 @@ module Tetra
     # for strings, the score is the Levenshtein distance
     # in any case score is normalized between 0 (identical) and 99 (very different/uncomparable)
     def chunk_distance(my_chunk, their_chunk)
-      my_chunk = "0" if my_chunk.nil?
-      their_chunk = "0" if their_chunk.nil?
+      # Normalize nils to "0"
+      my_chunk ||= "0"
+      their_chunk ||= "0"
+
+      # If exact match, distance is 0
+      return 0 if my_chunk == their_chunk
 
-      if i?(my_chunk) && i?(their_chunk)
-        return [(my_chunk.to_i - their_chunk.to_i).abs, 99].min
+      if integer?(my_chunk) && integer?(their_chunk)
+        diff = (my_chunk.to_i - their_chunk.to_i).abs
+        [diff, 99].min
       else
-        return [Text::Levenshtein.distance(my_chunk.upcase, their_chunk.upcase), 99].min
+        dist = Text::Levenshtein.distance(my_chunk.upcase, their_chunk.upcase)
+        [dist, 99].min
       end
     end
 
+    private
+
     # true for integer strings
-    def i?(string)
-      string =~ /^[0-9]+$/
+    def integer?(string)
+      # Faster than regex for simple digit checks
+      Integer(string, 10)
+      true
+    rescue ArgumentError, TypeError
+      false
     end
   end
 end

data/lib/tetra.rb

@@ -1,23 +1,26 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 # ruby standard library
 require "digest/sha1"
 require "English"
 require "erb"
-require "find"
 require "forwardable"
+require "json"
 require "logger"
+require "net/http"
+require "open3"
 require "open-uri"
 require "pathname"
-require "singleton"
 require "rexml/document"
-require "net/http"
+require "singleton"
+require "stringio"
+require "tempfile"
+require "uri"
 
 # third party libraries
 require "clamp"
-require "json"
-require "open4"
 require "text"
+require "yaml"
 require "zip"
 
 # base components
@@ -46,6 +49,7 @@ require "tetra/maven_website"
 require "tetra/pom_getter"
 
 # package building
+require "tetra/license_mapper"
 require "tetra/packages/speccable"
 require "tetra/packages/scriptable"
 require "tetra/packages/kit_package"