gem-compare 0.0.1 → 0.0.2

data/lib/rubygems/comparator/base.rb

@@ -0,0 +1,88 @@
+require 'rainbow'
+
+class Gem::Comparator
+  module Base
+    include Gem::UserInteraction
+
+    class DiffCommandMissing < StandardError; end
+
+    SPACE = ' '
+    DEFAULT_INDENT = SPACE*7
+    OPERATORS = ['=', '!=', '>', '<', '>=', '<=', '~>']
+    VERSION_REGEX = /\A(\d+\.){0,}\d+(\.[a-zA-Z]+\d{0,1}){0,1}\z/
+    SHEBANG_REGEX = /\A#!.*/
+    SPEC_PARAMS = %w[ author authors name platform require_paths rubygems_version summary
+                      license licenses  bindir cert_chain description email executables
+                      extensions homepage metadata post_install_message rdoc_options
+                      required_ruby_version required_rubygems_version requirements
+                      signing_key has_rdoc date version ].sort
+    SPEC_FILES_PARAMS = %w[ files test_files extra_rdoc_files ]
+    DEPENDENCY_PARAMS = %w[ runtime_dependency development_dependency ]
+    GEMFILE_PARAMS = %w[ gemfiles ]
+
+    private
+
+      def param_exists?(param)
+        (SPEC_PARAMS.include? param) ||
+        (SPEC_FILES_PARAMS.include? param) ||
+        (DEPENDENCY_PARAMS.include? param) ||
+        (GEMFILE_PARAMS.include? param)
+      end
+
+      def filter_params(params, param)
+        if param
+          if params.include? param
+            return [param]
+          else
+            return []
+          end
+        end
+
+        params
+      end
+
+      def same
+        Rainbow('SAME').green.bright
+      end
+
+      def different
+        Rainbow('DIFFERENT').red.bright
+      end
+
+      def info(msg)
+        say msg if Gem.configuration.really_verbose
+      end
+
+      def warn(msg)
+        say Rainbow("WARNING: #{msg}").red
+      end
+
+      def error(msg)
+        say Rainbow("ERROR: #{msg}").red
+        exit 1
+      end
+
+      def extract_gem(package, target_dir)
+        gem_file = File.basename(package.spec.full_name, '.gem')
+        gem_dir = File.join(target_dir, gem_file)
+
+        if Dir.exist? gem_dir
+          info "Unpacked gem version exists, using #{gem_dir}."
+          return gem_dir
+        end
+
+        info "Unpacking gem '#{package.spec.full_name}' in " + gem_dir
+        package.extract_files gem_dir
+        gem_dir
+      end
+
+      def check_diff_command_is_installed
+        begin
+          IO.popen('diff --version')
+        rescue Exception
+          raise DiffCommandMissing, \
+            'Calling `diff` command failed. Do you have it installed?'
+        end
+      end
+  end
+end

data/lib/rubygems/comparator/dependency_comparator.rb

@@ -0,0 +1,111 @@
+require 'rubygems/comparator/base'
+
+class Gem::Comparator
+
+  ##
+  # Gem::Comparator::DependencyComparator can
+  # compare dependencies between gem's versions
+  # based on the given Gem::Specification objects
+
+  class DependencyComparator
+    include Gem::Comparator::Base
+
+    COMPARES = :specs
+
+    ##
+    # Compare dependencies in given +specs+ and
+    # write the changes to the +report+
+    # 
+    # If +options[:param]+ is set, it compares only
+    # those dependencies
+
+    def compare(specs, report, options = {})
+      info 'Checking dependencies...'
+
+      filter_params(DEPENDENCY_PARAMS, options[:param]).each do |param|
+        all_same = true
+        type = param.gsub('_dependency', '').to_sym
+
+        specs.each_with_index do |s, index|
+          next if index == 0
+
+          prev_deps = specs[index-1].dependencies.keep_if { |d| d.type == type }
+          curr_deps = specs[index].dependencies.keep_if { |d| d.type == type }
+          added, deleted, updated = resolve_dependencies(prev_deps, curr_deps)
+
+          if (!deleted.empty? || !added.empty? || !updated.empty?)
+            all_same = false
+          end
+
+          ver = "#{specs[index-1].version}->#{specs[index].version}"
+
+          report[param][ver].section do
+            set_header "#{Rainbow(specs[index-1].version).blue}->#{Rainbow(s.version).blue}:"
+
+            nest('deleted').section do
+              set_header '* Deleted:'
+              puts deleted.map { |x| "#{x.name} #{x.requirements_list} (#{x.type})" } unless deleted.empty?
+            end
+
+            nest('added').section do
+              set_header '* Added:'
+              puts added.map { |x| "#{x.name} #{x.requirements_list} (#{x.type})" } unless added.empty?
+            end
+
+            nest('updated').section do
+              set_header '* Updated:'
+              puts updated unless updated.empty?
+            end
+          end
+        end
+        if all_same && options[:log_all]
+          report[param].set_header "#{same} #{type} dependencies:" if options[:log_all]
+          deps = specs[0].dependencies.keep_if{ |d| d.type == type }.map{ |d| "#{d.name}: #{d.requirements_list}" }
+          deps = '[]' if deps.empty?
+          report[param] << deps
+        elsif !all_same
+          report[param].set_header "#{different} #{type} dependencies:"
+        end
+      end
+      report
+    end
+
+    private
+      
+      ##
+      # Find dependencies between +prev_deps+ and +curr_deps+  
+      #
+      # Return [added, deleted, updated] deps
+
+      def resolve_dependencies(prev_deps, curr_deps)
+        added = curr_deps - prev_deps
+        deleted = prev_deps - curr_deps
+        split_dependencies(added, deleted)
+      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
+              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/file_list_comparator.rb

@@ -0,0 +1,262 @@
+require 'diffy'
+require 'rubygems/comparator/base'
+
+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
+    include Gem::Comparator::Base
+
+    COMPARES = :packages
+
+    ##
+    # 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...'
+      check_diff_command_is_installed
+
+      @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}"
+
+          if previous == current && !all_same
+            report[param][vers] << "#{Rainbow(packages[index-1].spec.version).blue}->" + \
+                                   "#{Rainbow(packages[index].spec.version).blue}: No change"
+          end
+
+          unless previous == current
+            deleted = previous - current
+            added = current - previous
+            same = current - added
+
+            if !added.empty? || !deleted.empty?
+              report[param].set_header "#{different} #{param}:"
+              all_same = false
+            end
+
+            report[param][vers].section do
+              set_header "#{Rainbow(packages[index-1].spec.version).blue}->" +
+                         "#{Rainbow(packages[index].spec.version).blue}:"
+              nest('deleted').section do
+                set_header '* Deleted:'
+                puts deleted unless deleted.empty?
+              end
+
+              nest('added').section do
+                set_header '* Added:'
+                puts added unless added.empty?
+              end
+            end
+
+            report[param][vers]['changed'].set_header '* Changed:'
+            report = check_same_files(param, vers, index, same, report)
+          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
+
+      def check_same_files(param, vers, index, files, report)
+        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 = lines_changed(prev_file, curr_file)
+
+          changes = permission_changed(prev_file, curr_file),
+                    executables_changed(prev_file, curr_file),
+                    shebangs_changed(prev_file, curr_file)
+
+          unless (line_changes.empty? && changes.join.empty?)
+            report[param][vers]['changed'] << \
+              "#{file} #{line_changes}"
+          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
+
+
+      ##
+      # Return how many lines differ between +prev_file+
+      # and +curr_file+ in format +ADDED/-DELETED
+
+      def lines_changed(prev_file, curr_file)
+        line = compact_files_diff(prev_file, curr_file)
+        return '' if line.empty?
+        "#{Rainbow(line.count('+')).green}/#{Rainbow(line.count('-')).red}"
+      end
+
+      ##
+      # Return +value+ in the given +spec+
+
+      def value_from_spec(param, spec)
+        if spec.respond_to? :"#{param}"
+          spec.send(:"#{param}")
+        else
+          warn "#{spec.full_name} does not respond to " +
+               "#{param}, skipping check"
+          nil
+        end
+      end
+
+      ##
+      # Return changes between files:
+      # + for line added
+      # - for line deleted
+
+      def compact_files_diff(prev_file, curr_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
+
+      ##
+      # Get file's permission
+
+      def file_permissions(file)
+        sprintf("%o", File.stat(file).mode)
+      end
+
+      ##
+      # Find and return permission changes between files
+
+      def permission_changed(prev_file, curr_file)
+        prev_permissions = file_permissions(prev_file)
+        curr_permissions = file_permissions(curr_file)
+
+        if prev_permissions != curr_permissions
+          "  (!) New permissions: " +
+          "#{prev_permissions} -> #{curr_permissions}"
+        else
+          ''
+        end
+      end
+    
+      ##
+      # Find if the file is now/or was executable
+
+      def executables_changed(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
+
+      ##
+      # Return the first line of the +file+
+
+      def first_line(file)
+        begin
+          File.open(file) { |f| f.readline }.gsub(/(.*)\n/, '\1')
+        rescue
+          info "#{file} is binary, skipping shebang check"
+          ''
+        end
+      end
+
+      ##
+      # Find if the shabang of the file has been changed
+
+      def shebangs_changed(prev_file, curr_file)
+        first_lines = {}
+
+        [prev_file, curr_file].each do |file|
+          first_lines[file] = first_line(file)
+        end
+
+        return '' if first_lines[prev_file] == first_lines[curr_file]
+
+        prev_has_shebang = (first_lines[prev_file] =~ SHEBANG_REGEX)
+        curr_has_shebang = (first_lines[curr_file] =~ SHEBANG_REGEX)
+
+        if prev_has_shebang && !curr_has_shebang
+            "  (!) Shebang probably lost: #{first_lines[prev_file]}"
+        elsif !prev_has_shebang && curr_has_shebang
+            "  (!) Shebang probably added: #{first_lines[curr_file]}"
+        elsif prev_has_shebang && curr_has_shebang
+            "  (!) Shebang probably changed: " +
+            "#{first_lines[prev_file]} -> #{first_lines[curr_file]}"
+        else
+            ''
+        end
+     end
+
+  end
+end