skillnad 1.2.2

data/lib/rubygems/comparator/file_list_comparator.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'diffy'
+require 'rubygems/comparator/base'
+require 'rubygems/comparator/dir_utils'
+require 'rubygems/comparator/monitor'
+
+class Gem::Comparator
+
+  ##
+  # Gem::Comparator::FileListComparator can
+  # compare file lists from gem's specs
+  # based on the given Gem::Package objects
+  #
+  # To compare the files it needs to extract
+  # gem packages to +options[:output]+
+
+  class FileListComparator < Gem::Comparator::Base
+
+    def initialize(ignore_group_writable=true)
+      expect(:packages)
+
+      # We need diff
+      begin
+        IO.popen('diff --version')
+      rescue Exception
+        error('Calling `diff` command failed. Do you have it installed?')
+      end
+
+      @ignore_group_writable = ignore_group_writable
+    end
+
+    ##
+    # Compare file lists for gem's Gem::Package objects
+    # in +packages+ and writes the changes to the +report+
+    #
+    # If +options[:param]+ is set, it compares only
+    # that file list
+
+    def compare(packages, report, options = {})
+      info 'Checking file lists...'
+
+      @packages = packages
+
+      # Check file lists from older versions to newer
+      filter_params(SPEC_FILES_PARAMS, options[:param]).each do |param|
+        all_same = true
+
+        packages.each_with_index do |pkg, index|
+          unpacked_gem_dirs[packages[index].spec.version] = extract_gem(pkg, options[:output])
+          next if index == 0
+
+          # File lists as arrays
+          previous = value_from_spec(param, packages[index-1].spec)
+          current = value_from_spec(param, pkg.spec)
+          next unless (previous && current)
+
+          vers = "#{packages[index-1].spec.version}->#{packages[index].spec.version}"
+
+          deleted = previous - current
+          added = current - previous
+          same = current - added
+
+          if options[:brief]
+            deleted, dirs_added = dir_changed(previous, current)
+          end
+
+          report[param].set_header "#{different} #{param}:"
+
+          report[param][vers].section do
+            set_header "#{Rainbow(packages[index-1].spec.version).cyan}->" +
+                       "#{Rainbow(packages[index].spec.version).cyan}:"
+            nest('deleted').section do
+              set_header '* Deleted:'
+              puts deleted unless deleted.empty?
+            end
+
+            nest('added').section do
+              set_header '* Added:'
+              puts dirs_added if options[:brief]
+            end
+          end
+          # Add information about permissions, shebangs etc.
+          report = check_added_files(param, vers, index, added, report, options[:brief], options[:diff])
+
+          report[param][vers]['changed'].set_header '* Changed:'
+          report = check_same_files(param, vers, index, same, report, options[:brief], options[:diff])
+          same_files = report[param][vers]['changed'].messages.empty?
+          all_same = false unless same_files
+
+          if previous == current && same_files && !all_same
+            report[param][vers] << "#{Rainbow(packages[index-1].spec.version).cyan}->" + \
+                                   "#{Rainbow(packages[index].spec.version).cyan}: No change"
+          end
+
+        end
+
+        if all_same && options[:log_all]
+          report[param].set_header "#{same} #{param}:"
+          value = value_from_spec(param, @packages[0].spec)
+          value = '[]' if value.empty?
+          report[param] << value
+        end
+      end
+      report
+    end
+
+    private
+
+      ##
+      # Access @unpacked_gem_dirs hash that stores
+      # paths to the unpacked gem dirs
+      #
+      # Keys of the hash are gem's versions
+
+      def unpacked_gem_dirs
+        @unpacked_gem_dirs ||= {}
+      end
+
+      ##
+      # This returns [deleted, added] directories between
+      # +previous+ and +current+ file lists
+      #
+      # For top level (.) it compares files themselves
+
+      def dir_changed(previous, current)
+        prev_dirs = DirUtils.dirs_of_files(previous)
+        curr_dirs = DirUtils.dirs_of_files(current)
+        deleted = DirUtils.remove_subdirs(prev_dirs - curr_dirs)
+        added = DirUtils.remove_subdirs(curr_dirs - prev_dirs)
+        [deleted, added]
+      end
+
+      def check_added_files(param, vers, index, files, report, brief_mode, diff_mode)
+        files.each do |file|
+          added_file = File.join(unpacked_gem_dirs[@packages[index].spec.version], file)
+
+          line_changes = if diff_mode
+            Monitor.files_diff(nil, added_file)
+          else
+            Monitor.lines_changed(nil, added_file)
+          end
+
+          changes = Monitor.new_file_permissions(added_file, @ignore_group_writable),
+                    Monitor.new_file_executability(added_file),
+                    Monitor.new_file_shebang(added_file)
+
+          if(!changes.join.empty? || (!brief_mode && !line_changes.empty?))
+            if diff_mode
+              report[param][vers]['added'][file].set_header file
+              report[param][vers]['added'][file] << line_changes.split("\n")
+            else
+              report[param][vers]['added'] << "#{file} #{line_changes}"
+            end
+          end
+
+          changes.each do |change|
+            report[param][vers]['added'] << change unless change.empty?
+          end
+        end
+        report
+      end
+
+      def check_same_files(param, vers, index, files, report, brief_mode, diff_mode)
+        files.each do |file|
+          prev_file = File.join(unpacked_gem_dirs[@packages[index-1].spec.version], file)
+          curr_file = File.join(unpacked_gem_dirs[@packages[index].spec.version], file)
+
+          next unless check_files([prev_file, curr_file])
+
+          line_changes = if diff_mode
+            Monitor.files_diff(prev_file, curr_file)
+          else
+            Monitor.lines_changed(prev_file, curr_file)
+          end
+
+          changes = Monitor.files_permissions_changes(prev_file, curr_file, @ignore_group_writable),
+                    Monitor.files_executability_changes(prev_file, curr_file),
+                    Monitor.files_shebang_changes(prev_file, curr_file)
+
+          if(!changes.join.empty? || (!brief_mode && !line_changes.empty?))
+            if diff_mode
+              report[param][vers]['changed'][file].set_header file
+              report[param][vers]['changed'][file] << line_changes.split("\n")
+            else
+              report[param][vers]['changed'] << "#{file} #{line_changes}"
+            end
+          end
+
+          changes.each do |change|
+            report[param][vers]['changed'] << change unless change.empty?
+          end
+        end
+        report
+      end
+
+      ##
+      # Check that files exist
+
+      def check_files(files)
+        files.each do |file|
+          unless File.exist? file
+            warn "#{file} mentioned in spec does not exist " +
+                 "in the gem package, skipping check"
+            return false
+          end
+        end
+        true
+      end
+
+  end
+end

data/lib/rubygems/comparator/gemfile_comparator.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'gemnasium/parser'
+require 'rubygems/comparator/base'
+
+class Gem::Comparator
+
+  ##
+  # Gem::Comparator::GemfileComparator can
+  # compare dependencies between gem's Gemfiles
+  # based on the given Gem::Package objects
+  #
+  # To compare Gemfiles it needs to extract
+  # gem packages to +options[:output]+
+
+  class GemfileComparator < Gem::Comparator::Base
+
+    def initialize
+      expect(:packages)
+    end
+
+    ##
+    # Compare Gemfiles using gem's +packages+
+    # and write the changes to the +report+
+
+    def compare(packages, report, options = {})
+      info 'Checking Gemfiles for dependencies...'
+      return report if options[:param] && options[:param] != 'gemfiles'
+
+      @packages = packages
+      all_same = true
+
+      # Check Gemfiles from older versions to newer
+      packages.each_with_index do |pkg, index|
+        unpacked_gem_dirs[@packages[index].spec.version] = extract_gem(pkg, options[:output])
+        next if index == 0
+
+        prev_gemfile = File.join(unpacked_gem_dirs[@packages[index-1].spec.version], 'Gemfile')
+        curr_gemfile = File.join(unpacked_gem_dirs[@packages[index].spec.version], 'Gemfile')
+
+        vers = "#{@packages[index-1].spec.version}->#{@packages[index].spec.version}"
+        report['gemfiles'][vers].set_header "#{Rainbow(packages[index-1].spec.version).cyan}->" +
+                                            "#{Rainbow(packages[index].spec.version).cyan}:"
+
+        added, deleted, updated = compare_gemfiles(prev_gemfile, curr_gemfile)
+
+        report['gemfiles'][vers]['added'].section do
+          set_header '* Added:'
+          puts added.map { |x| "#{x.name} #{x.requirements_list} (#{x.type})" } unless added.empty?
+        end
+        report['gemfiles'][vers]['deleted'].section do
+          set_header '* Deleted'
+          puts deleted.map { |x| "#{x.name} #{x.requirements_list} (#{x.type})" } unless deleted.empty?
+        end
+        report['gemfiles'][vers]['updated'].section do
+          set_header '* Updated'
+          puts updated  unless updated.empty?
+        end
+        all_same = false if !added.empty? || !deleted.empty?
+      end
+      if all_same && options[:log_all]
+        report['gemfiles'].set_header "#{same} Gemfiles:"
+        gemfile = File.join(unpacked_gem_dirs[@packages[1].spec.version], 'Gemfile')
+        if File.exist? gemfile
+          deps = gemfile_deps(gemfile)
+          deps = '[]' if deps.empty?
+          report['gemfiles'] << deps
+        else
+          report['gemfiles'] << 'No Gemfiles'
+        end
+      elsif !all_same
+        report['gemfiles'].set_header "#{different} Gemfile dependencies"
+      end
+
+      report
+    end
+
+    private
+
+      ##
+      # Access @unpacked_gem_dirs hash that stores
+      # paths to the unpacked gem dirs
+      #
+      # Keys of the hash are gem's versions
+
+      def unpacked_gem_dirs
+        @unpacked_gem_dirs ||= {}
+      end
+
+      ##
+      # Compare two Gemfiles for dependencies
+      #
+      # Return [added, deleted, updated] deps
+
+      def compare_gemfiles(prev_gemfile, curr_gemfile)
+        prev_deps = gemfile_deps(prev_gemfile)
+        curr_deps = gemfile_deps(curr_gemfile)
+        added = curr_deps - prev_deps
+        deleted = prev_deps - curr_deps
+
+        split_dependencies(added, deleted)
+      end
+
+      ##
+      # Get the Gemfile dependencies from +gemfile+
+
+      def gemfile_deps(gemfile)
+        if File.exist?(gemfile)
+          parse_gemfile(gemfile).dependencies
+        else
+          []
+        end
+      end
+
+      ##
+      # Parse +gemfile+ using Gemnasium::Parser
+      #
+      # Return Gemnasium::Parser::Gemfile
+
+      def parse_gemfile(gemfile)
+        Gemnasium::Parser.gemfile File.open(gemfile).read
+      end
+
+      ##
+      # Find updated dependencies between +added+ and
+      # +deleted+ deps and move them out to +updated+.
+      #
+      # Return [added, deleted, updated] deps
+
+      def split_dependencies(added, deleted)
+        updated = []
+        added.dup.each do |ad|
+          deleted.dup.each do |dd|
+            if ad.name == dd.name && ad.type == dd.type
+              unless ad.requirements_list == dd.requirements_list
+                updated << "#{ad.name} " +
+                           "from: #{dd.requirements_list} " +
+                           "to: #{ad.requirements_list}"
+              end
+              added.delete ad
+              deleted.delete dd
+            end
+          end
+        end
+        [added, deleted, updated]
+      end
+
+  end
+end

data/lib/rubygems/comparator/monitor.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'diffy'
+require 'rubygems/comparator/base'
+require 'rubygems/comparator/dir_utils'
+
+class Gem::Comparator
+  module Monitor
+
+    def self.lines_changed(prev_file, curr_file)
+      line = compact_files_diff(prev_file, curr_file)
+      return '' if line.empty?
+      plus = "+#{line.count('+')}"
+      minus = "-#{line.count('-')}"
+      "#{Rainbow(plus).green}/#{Rainbow(minus).red}"
+    end
+
+    def self.compact_files_diff(prev_file, curr_file)
+      prev_file = prev_file.nil? ? Tempfile.new.path : prev_file
+      changes = +''
+      Diffy::Diff.new(
+        prev_file, curr_file, :source => 'files', :context => 0
+      ).each do |line|
+        case line
+        when /^\+/ then changes << Rainbow('+').green
+        when /^-/ then changes << Rainbow('-').red
+        end
+      end
+      changes
+    end
+
+    def self.files_diff(prev_file, curr_file)
+      prev_file = prev_file.nil? ? Tempfile.new.path : prev_file
+      changes = +''
+      Diffy::Diff.new(
+        prev_file, curr_file, :source => 'files', :context => 0, :include_diff_info => true
+      ).each do |line|
+        case line
+        when /^\+/ then changes << Rainbow(line).green
+        when /^-/ then changes << Rainbow(line).red
+        else changes << line
+        end
+      end
+      changes
+    end
+
+    def self.files_permissions_changes(prev_file, curr_file, ignore_group_writable=false)
+      prev_permissions = File.stat(prev_file).mode
+      curr_permissions = File.stat(curr_file).mode
+
+      diff = prev_permissions ^ curr_permissions
+      diff ^= 020 if diff != 0 && ignore_group_writable
+
+      if diff != 0
+        "  (!) New permissions: " +
+        "#{format_permissions(prev_permissions)} -> #{format_permissions(curr_permissions)}"
+      else
+        ''
+      end
+    end
+
+    def self.new_file_permissions(file, ignore_group_writable=false)
+      file_permissions = File.stat(file).mode
+
+      expected_permissions = if DirUtils.gem_bin_file?(file)
+        0100755
+      else
+        0100644
+      end
+
+      permissions_to_compare = if ignore_group_writable && file_permissions != expected_permissions
+        file_permissions ^ 020
+      else
+        file_permissions
+      end
+
+      unless permissions_to_compare == expected_permissions
+        return "  (!) Unexpected permissions: #{format_permissions(file_permissions)}"
+      end
+      ''
+    end
+
+    def self.files_executability_changes(prev_file, curr_file)
+      prev_executable = File.stat(prev_file).executable?
+      curr_executable = File.stat(curr_file).executable?
+
+      if !prev_executable && curr_executable
+        "  (!) File is now executable!"
+      elsif prev_executable && !curr_executable
+        "  (!) File is no longer executable!"
+      else
+        ''
+      end
+    end
+
+    def self.new_file_executability(file)
+      file_executable = File.stat(file).executable?
+
+      if file_executable && !DirUtils.gem_bin_file?(file)
+        "  (!) File is executable"
+      elsif !file_executable && DirUtils.gem_bin_file?(file)
+        "  (!) File is not executable"
+      else
+        ''
+      end
+    end
+
+    def self.files_shebang_changes(prev_file, curr_file)
+      return '' if DirUtils.files_same_first_line?(prev_file, curr_file)
+
+      prev_has_shebang = DirUtils.file_has_shebang? prev_file
+      curr_has_shebang = DirUtils.file_has_shebang? curr_file
+
+      if prev_has_shebang && !curr_has_shebang
+          "  (!) Shebang probably lost: #{DirUtils.file_first_line(prev_file)}"
+      elsif !prev_has_shebang && curr_has_shebang
+          "  (!) Shebang probably added: #{DirUtils.file_first_line(curr_file)}"
+      elsif prev_has_shebang && curr_has_shebang
+          "  (!) Shebang probably changed: " +
+          "#{first_lines[prev_file]} -> #{DirUtils.file_first_line(curr_file)}"
+      else
+          ''
+      end
+    end
+
+    def self.new_file_shebang(file)
+      file_has_shebang = DirUtils.file_has_shebang? file
+
+      if file_has_shebang
+        "  (!) Shebang found: #{DirUtils.file_first_line(file)}"
+      else
+        ''
+      end
+    end
+
+    def self.format_permissions(permissions)
+      sprintf("%o", permissions)
+    end
+  end
+end

data/lib/rubygems/comparator/report/entry.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Gem::Comparator
+  class Report
+    class Entry
+      include Gem::UserInteraction
+
+      attr_accessor :data, :indent
+
+      def initialize(data = '', indent = '')
+        @data = data
+        @indent = indent
+      end
+
+      def set_indent!(indent)
+        @indent = indent
+        self
+      end
+
+      def empty?
+        case @data
+        when String, Array
+          @data.empty?
+        end
+      end
+
+      def print
+        printed = case @data
+                  when String
+                    "#{@indent}#{@data}"
+                  when Array
+                    @indent + @data.join("\n#{@indent}")
+                  else
+                    "#{@indent}#{@data}"
+                  end
+        say printed
+      end
+    end
+  end
+end

data/lib/rubygems/comparator/report.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'rubygems/comparator/report/entry'
+
+class Gem::Comparator
+
+  ##
+  # Gem::Comparator::Report can nest sections and print only those that
+  # contain some messages.
+  #
+  # Usage:
+  #   report = Gem::Comparator::Report.new
+  #   report['section1'] << "Message 1"
+  #   report['section1']['subsection1'].set_header 'Message 2 Header'
+  #   report['section1']['subsection1'] << "Message 2" if false
+  #   report['section1'].section
+  #     nest('subsection2').section
+  #       puts "Message 3"
+  #     end
+  #   end
+  #   report.print
+  #
+  # This won't print Message 2 nor its header saving a lot of if/else.
+
+  class Report
+
+    module Signs
+      def same
+        Rainbow('SAME').green.bright
+      end
+
+      def different
+        Rainbow('DIFFERENT').red.bright
+      end
+    end
+
+    def self.new(name = 'main')
+      Gem::Comparator::Report::NestedSection.new(name)
+    end
+
+    class NestedSection
+      include Report::Signs
+      include Gem::UserInteraction
+
+      DEFAULT_INDENT = '  '
+
+      attr_reader :header, :messages, :parent_section, :level
+      attr_accessor :name, :sections
+
+      def initialize(name, parent_section = nil)
+        @name = name
+        @header = Entry.new
+        @messages = []
+        @sections = []
+        @level = 0
+
+        set_parent parent_section if parent_section
+      end
+
+      def section(&block)
+        instance_eval(&block)
+      end
+
+      def set_header(message)
+        @header = Entry.new(message)
+      end
+
+      def puts(message)
+        case message
+        when String, Array
+          @messages << Entry.new(message) unless message.empty?
+        else
+          @messages << Entry.new(message) unless message
+        end
+      end
+      alias_method :<<, :puts
+
+      def nest(name)
+        @sections.each do |s|
+          return s if s.name == name
+        end
+        NestedSection.new(name, self)
+      end
+      alias_method :[], :nest
+
+      def print
+        all_messages.each { |m| m.print }
+      end
+
+      def all_messages
+        indent = DEFAULT_INDENT*@level
+
+        if @header.empty?
+          @messages.map do |m|
+            m.set_indent!(indent)
+          end + nested_messages
+        else
+          nested = @messages.map do |m|
+            m.set_indent!(indent * 2)
+          end + nested_messages
+          return [] if nested.empty?
+
+          @header.set_indent!(indent)
+          nested.unshift(@header)
+        end
+      end
+
+      def lines(line_num)
+        all_messages[line_num]&.data
+      end
+
+      def nested_messages
+        nested_messages = []
+        @sections.each do |section|
+          section.all_messages.each do |m|
+            nested_messages << m
+          end
+        end
+        nested_messages
+      end
+
+      private
+
+        def set_parent(parent)
+          parent.sections << self
+          @level = parent.level + 1
+        end
+
+    end
+  end
+end