gem-compare 0.0.2 → 0.0.3

data/lib/rubygems/comparator/file_list_comparator.rb

@@ -1,5 +1,7 @@
 require 'diffy'
 require 'rubygems/comparator/base'
+require 'rubygems/comparator/dir_utils'
+require 'rubygems/comparator/monitor'
 
 class Gem::Comparator
 
@@ -11,10 +13,18 @@ class Gem::Comparator
   # To compare the files it needs to extract
   # gem packages to +options[:output]+
 
-  class FileListComparator
-    include Gem::Comparator::Base
+  class FileListComparator < Gem::Comparator::Base
 
-    COMPARES = :packages
+    def initialize
+      expect(:packages)
+
+      # We need diff
+      begin
+        IO.popen('diff --version')
+      rescue Exception
+        error('Calling `diff` command failed. Do you have it installed?')
+      end
+    end
 
     ##
     # Compare file lists for gem's Gem::Package objects
@@ -25,7 +35,6 @@ class Gem::Comparator
 
     def compare(packages, report, options = {})
       info 'Checking file lists...'
-      check_diff_command_is_installed
 
       @packages = packages
 
@@ -44,38 +53,42 @@ class Gem::Comparator
 
           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"
+          deleted = previous - current
+          added = current - previous
+          same = current - added
+
+          if options[:brief]
+            deleted, dirs_added = dir_changed(previous, current)
           end
 
-          unless previous == current
-            deleted = previous - current
-            added = current - previous
-            same = current - added
+          report[param].set_header "#{different} #{param}:"
 
-            if !added.empty? || !deleted.empty?
-              report[param].set_header "#{different} #{param}:"
-              all_same = false
+          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
 
-            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
+            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])
 
-            report[param][vers]['changed'].set_header '* Changed:'
-            report = check_same_files(param, vers, index, same, report)
+          report[param][vers]['changed'].set_header '* Changed:'
+          report = check_same_files(param, vers, index, same, report, options[:brief])
+          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).blue}->" + \
+                                   "#{Rainbow(packages[index].spec.version).blue}: No change"
           end
+
         end
 
         if all_same && options[:log_all]
@@ -93,27 +106,62 @@ class Gem::Comparator
       ##
       # 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)
+      ##
+      # 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)
+        files.each do |file|
+          added_file = File.join(unpacked_gem_dirs[@packages[index].spec.version], file)
+
+          #line_changes = lines_changed(prev_file, curr_file)
+
+          changes = Monitor.new_file_permissions(added_file),
+                    Monitor.new_file_executability(added_file),
+                    Monitor.new_file_shebang(added_file)
+
+          if(!changes.join.empty? || !brief_mode)
+            report[param][vers]['added'] << "#{file}"
+          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)
         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)
+          line_changes = Monitor.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)
+          changes = Monitor.files_permissions_changes(prev_file, curr_file),
+                    Monitor.files_executability_changes(prev_file, curr_file),
+                    Monitor.files_shebang_changes(prev_file, curr_file)
 
-          unless (line_changes.empty? && changes.join.empty?)
+          if(!changes.join.empty? || (!brief_mode && !line_changes.empty?))
             report[param][vers]['changed'] << \
               "#{file} #{line_changes}"
           end
@@ -139,124 +187,5 @@ class Gem::Comparator
         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

data/lib/rubygems/comparator/gemfile_comparator.rb

@@ -11,10 +11,11 @@ class Gem::Comparator
   # To compare Gemfiles it needs to extract
   # gem packages to +options[:output]+
 
-  class GemfileComparator
-    include Gem::Comparator::Base
+  class GemfileComparator < Gem::Comparator::Base
 
-    COMPARES = :packages
+    def initialize
+      expect(:packages)
+    end
 
     ##
     # Compare Gemfiles using gem's +packages+
@@ -39,29 +40,21 @@ class Gem::Comparator
         report['gemfiles'][vers].set_header "#{Rainbow(packages[index-1].spec.version).blue}->" +
                                             "#{Rainbow(packages[index].spec.version).blue}:"
 
-        if File.exist?(prev_gemfile) && File.exist?(curr_gemfile)
-          added, deleted, updated = compare_gemfiles(prev_gemfile, curr_gemfile)
+        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}" }  unless added.empty?
-          end
-          report['gemfiles'][vers]['deleted'].section do
-            set_header '* Deleted'
-            puts deleted.map { |x| "#{x.name} #{x.requirements_list}" }  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?
-        elsif File.exist?(prev_gemfile)
-          report['gemfiles'][vers] << "Gemfile removed"
-          all_same = false
-        elsif File.exist?(curr_gemfile)
-          report['gemfiles'][vers] << "Gemfile added"
-          all_same = false
+        report['gemfiles'][vers]['added'].section do
+          set_header '* Added:'
+          puts added.map { |x| "#{x.name} #{x.requirements_list}" } unless added.empty?
         end
+        report['gemfiles'][vers]['deleted'].section do
+          set_header '* Deleted'
+          puts deleted.map { |x| "#{x.name} #{x.requirements_list}" } 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:"
@@ -81,17 +74,17 @@ class Gem::Comparator
     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
       #
@@ -105,14 +98,18 @@ class Gem::Comparator
 
         split_dependencies(added, deleted)
       end
-    
+
       ##
       # Get the Gemfile dependencies from +gemfile+
 
       def gemfile_deps(gemfile)
-        parse_gemfile(gemfile).dependencies
+        if File.exist?(gemfile)
+          parse_gemfile(gemfile).dependencies
+        else
+          []
+        end
       end
-    
+
       ##
       # Parse +gemfile+ using Gemnasium::Parser
       #
@@ -121,7 +118,7 @@ class Gem::Comparator
       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+.

data/lib/rubygems/comparator/monitor.rb

@@ -0,0 +1,106 @@
+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)
+      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_permissions_changes(prev_file, curr_file)
+      prev_permissions = DirUtils.file_permissions(prev_file)
+      curr_permissions = DirUtils.file_permissions(curr_file)
+
+      if prev_permissions != curr_permissions
+        "  (!) New permissions: " +
+        "#{prev_permissions} -> #{curr_permissions}"
+      else
+        ''
+      end
+    end
+
+    def self.new_file_permissions(file)
+      file_permissions = DirUtils.file_permissions(file)
+
+      if file_permissions != '100644'
+        unless (DirUtils.gem_bin_file?(file) && file_permissions == '100755')
+          "  (!) Unexpected permissions: #{file_permissions}"
+        end
+      else
+        ''
+      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
+  end
+end