skillnad 1.2.2

data/lib/rubygems/comparator/spec_comparator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'rubygems/comparator/base'
+
+class Gem::Comparator
+
+  ##
+  # Gem::Comparator::SpecComparator can
+  # compare values from the gem verions specs
+
+  class SpecComparator < Gem::Comparator::Base
+
+    ##
+    # Compare common fields in spec
+
+    def compare(specs, report, options = {})
+      info 'Checking spec parameters...'
+      p = options[:param]
+      b = options[:brief]
+
+      filter_params(SPEC_PARAMS, p, b).each do |param|
+        values = values_from_specs(param, specs)
+
+        if same_values?(values) && options[:log_all]
+          v = value(values[0])
+          report[param].section do
+            set_header "#{self.same} #{param}:"
+            puts v
+          end
+        elsif !same_values?(values)
+          report[param].set_header "#{different} #{param}:"
+          values.each_with_index do |value, index|
+            report[param] << \
+              "#{Rainbow(specs[index].version).cyan}: #{value}"
+          end
+        end
+      end
+      report
+    end
+
+    private
+
+      def value(value)
+        case value
+        when Gem::Requirement
+          unless value.requirements.empty?
+            r = value.requirements[0]
+            "#{r[0]} #{r[1].version} "
+          else
+            '[]'
+          end
+        when Gem::Platform
+          value.to_s
+        when String
+          return value unless value.empty?
+          ''
+        else
+          value.inspect
+        end
+      end
+
+      def same_values?(values)
+        values.count(values[0]) == values.size
+      end
+  end
+end

data/lib/rubygems/comparator/utils.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+require 'rubygems'
+require 'rubygems/user_interaction'
+
+class Gem::Comparator
+  module Utils
+    include Gem::UserInteraction
+
+    SPACE = ' '
+    DEFAULT_INDENT = SPACE*7
+    OPERATORS = ['=', '!=', '>', '<', '>=', '<=', '~>']
+    VERSION_REGEX = /\A(\d+\.){0,}\d+(\.[a-zA-Z]+\.{0,1}\d{0,1}){0,1}\z/
+    SPEC_PARAMS = %w[ author
+                      authors
+                      bindir
+                      cert_chain
+                      date
+                      description
+                      email
+                      executables
+                      extensions
+                      homepage
+                      license
+                      licenses
+                      metadata
+                      name
+                      platform
+                      post_install_message
+                      rdoc_options
+                      require_paths
+                      required_ruby_version
+                      required_rubygems_version
+                      requirements
+                      rubygems_version
+                      signing_key
+                      summary
+                      version ]
+    SPEC_FILES_PARAMS = %w[ files
+                            test_files
+                            extra_rdoc_files ]
+    DEPENDENCY_PARAMS = %w[ runtime_dependency
+                            development_dependency ]
+    GEMFILE_PARAMS = %w[ gemfiles ]
+
+    # Duplicates or obvious changes
+    FILTER_WHEN_BRIEF = %w[ author
+                            date
+                            license
+                            platform
+                            rubygems_version
+                            version ]
+
+    # Not present in marshal file containing the specs
+    NOT_IN_MARSHAL = %w[ cert_chain
+                         executables
+                         extensions
+                         extra_rdoc_files
+                         files
+                         license
+                         licenses
+                         metadata
+                         post_install_message
+                         rdoc_options
+                         requirements
+                         signing_key
+                         test_files ]
+
+    private
+
+      def param_exists?(param)
+        (SPEC_PARAMS.include? param) ||
+        (SPEC_FILES_PARAMS.include? param) ||
+        (DEPENDENCY_PARAMS.include? param) ||
+        (GEMFILE_PARAMS.include? param)
+      end
+
+      def param_available_in_marshal?(param)
+        param_exists?(param) && !NOT_IN_MARSHAL.include?(param)
+      end
+
+      def filter_params(params, param, brief_mode = false)
+        if param
+          if params.include? param
+            return [param]
+          else
+            return []
+          end
+        end
+        if brief_mode
+          filter_for_brief_mode(params)
+        else
+          params
+        end
+      end
+
+      def filter_for_brief_mode(params)
+        params.delete_if{ |p| FILTER_WHEN_BRIEF.include?(p) }
+      end
+
+      def values_from_specs(param, specs)
+        values = []
+        specs.each do |s|
+         val = value_from_spec(param, s)
+         values << val if val
+        end
+        values
+      end
+
+      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
+
+      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
+  end
+end

data/lib/rubygems/comparator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Gem::Comparator
+  VERSION = '1.2.2'
+end

data/lib/rubygems/comparator.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'rbconfig'
+require 'rainbow'
+require 'uri'
+require 'json'
+require 'rubygems/package'
+require 'rubygems/dependency'
+require 'rubygems/spec_fetcher'
+require 'rubygems/remote_fetcher'
+require 'rubygems/comparator/version'
+require 'rubygems/comparator/utils'
+require 'rubygems/comparator/report'
+require 'rubygems/comparator/spec_comparator'
+require 'rubygems/comparator/file_list_comparator'
+require 'rubygems/comparator/dependency_comparator'
+require 'rubygems/comparator/gemfile_comparator'
+
+##
+# Gem::Comparator compares different version of the given
+# gem. It can compare spec values as well as file lists or
+# Gemfiles
+
+class Gem::Comparator
+  include Gem::Comparator::Utils
+  attr_accessor :options, :report
+
+  ##
+  # Set the working dir and process options
+  #
+  # Creates temporal directory if the gem files shouldn't be kept
+
+  def initialize(options)
+    info "skillnad in #{VERSION}"
+
+    unless options[:keep_all]
+      options[:output] = Dir.mktmpdir
+    end
+
+    if options[:param] && !param_exists?(options[:param])
+      error 'Invalid parameter.'
+    end
+
+    if options[:no_color]
+      Rainbow.enabled = false
+    end
+
+    # Let's override platforms with the latest one if
+    # a platform has been specified via --platform
+    if options[:added_platform]
+      Gem.platforms = [Gem.platforms.last]
+      options[:platform] = Gem.platforms.last.to_s
+      info "Overriding platform to: #{options[:platform]}"
+    end
+
+    @options = options
+
+    # Results from the comparison
+    @report = Gem::Comparator::Report.new
+  end
+
+  ##
+  # Compare versions
+  #
+  # Compares file lists, requirements, other meta data
+
+  def compare_versions(gem_name, versions)
+    # Expand versions (<=, >=, ~>) and sort them
+    compared_versions = expand_versions(gem_name, versions)
+
+    if versions.include?('_') && (compared_versions.size == 1)
+      error 'Latest upstream version matches the version given. Nothing to compare.'
+    elsif versions.include?('_') && (compared_versions.size == (versions.size - 1))
+      warn 'Latest upstream version matches one of the versions given.'
+    elsif compared_versions.size == 1
+      error 'Only one version specified. Specify at lease two versions.'
+    end
+
+    # This should match the final versions that has been compared
+    @compared_versions = compared_versions
+
+    compared_versions.each do |version|
+      download_gems? ?
+        get_package(gem_name, version) :
+        get_specification(gem_name, version)
+    end
+
+    @report.set_header "Compared versions: #{@compared_versions}"
+
+    comparators = [SpecComparator,
+                   FileListComparator,
+                   DependencyComparator,
+                   GemfileComparator]
+
+    # Use different gem sources if specified
+    with_sources @options[:sources] do
+      comparators.each do |c|
+        comparator = c.new
+        cmp = (comparator.compares == :packages) ? gem_packages.values : gem_specs.values
+        @report = comparator.compare(cmp, @report, @options)
+      end
+    end
+
+    # Clean up
+    FileUtils.rm_rf options[:output] unless options[:keep_all]
+  end
+
+  def print_results
+    info 'Printing results...'
+    @report.print
+  end
+
+  private
+
+    def with_sources(sources, &block)
+      if sources
+        override_sources sources do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    def override_sources(new_sources, &block)
+      original_sources = Gem.sources.clone
+      old_sources = Gem.sources.to_a
+      old_sources.each do |source_uri|
+        Gem.sources.delete source_uri
+      end
+      new_sources.each do |source_uri|
+        source = Gem::Source.new source_uri
+        source.load_specs :released
+        Gem.sources << source
+      end
+      Gem.configuration.write
+      yield
+    rescue URI::Error, ArgumentError
+      error 'Given URI is not valid.'
+    rescue Gem::RemoteFetcher::FetchError => e
+      error "Fetching the gem from the given URI failed with the " +
+            "following error:\n       #{e.message}"
+    ensure
+      original_sources.each do |source_uri|
+        source = Gem::Source.new source_uri
+        source.load_specs :released
+        Gem.sources << source
+      end
+      Gem.configuration.write
+    end
+
+    ##
+    # If there is an unexpanded version in +versions+ such
+    # as '>= 4.0.0' or '~>1.0.0', find all existing
+    # +gem_name+ versions that match the criteria
+    #
+    # Return list of expanded versions
+
+    def expand_versions(gem_name, versions)
+      info "Expanding versions #{versions}..."
+      expanded = []
+      versions.each do |version|
+        version = latest_gem_version(gem_name) if version == '_'
+        if version =~ VERSION_REGEX
+          expanded << version
+          next
+        end
+        op, v = (version.scan(/(>=|<=|~>|!=|>|<|=)\s*(.*)/)).flatten
+        # Supported operator and version?
+        if OPERATORS.include?(op) && v =~ VERSION_REGEX
+          dep = Gem::Dependency.new gem_name, version
+          specs_and_sources, _errors = Gem::SpecFetcher.fetcher.spec_for_dependency dep
+          specs_and_sources.each do |s|
+            expanded << s[0].version
+          end
+        else
+          warn "Unsupported version specification: #{version}, skipping."
+        end
+      end
+
+      versions = expanded.uniq.map do |v|
+        Gem::Version.new v
+      end.sort.map(&:to_s)
+
+      error 'No versions found.' if versions.size == 0
+
+      info "Expanded versions: #{versions}"
+      versions
+    end
+
+    def remote_gem_versions(gem_name)
+      body_str = URI.open("https://rubygems.org/api/v1/versions/#{gem_name}.json").read
+      json = JSON.parse(body_str)
+      gems = json.collect { |version| version['number'] }
+      info "Upstream versions: #{gems}"
+      gems
+    # "This rubygem could not be found."
+    rescue JSON::ParserError
+      error "Gem #{gem_name} does not exist."
+      exit 1
+    end
+
+    def latest_gem_version(gem_name)
+      remote_gem_versions(gem_name).map{ |v| Gem::Version.new v }.max.to_s
+    end
+
+    def gem_file_name(gem_name, version)
+      if @options[:platform]
+        "#{gem_name}-#{version}-#{@options[:platform]}.gem"
+      else
+        "#{gem_name}-#{version}.gem"
+      end
+    end
+
+    def get_package(gem_name, version)
+      gem_file = gem_file_name(gem_name, version)
+      return gem_packages["#{gem_file}"] if gem_packages["#{gem_file}"]
+
+      find_downloaded_gem(gem_file)
+      return gem_packages["#{gem_file}"] if gem_packages["#{gem_file}"]
+
+      download_package(gem_name, version)
+    end
+
+    def download_package(gem_name, version)
+      spec, source = get_specification(gem_name, version)
+
+      gem_file_path = Dir.chdir @options[:output] do
+        source.download spec
+      end
+
+      package = Gem::Package.new(gem_file_path)
+      use_package(package)
+      info "#{gem_file_path} downloaded."
+
+      package
+    end
+
+    def get_specification(gem_name, version)
+      gem_file = gem_file_name(gem_name, version)
+      return gem_specs["#{gem_file}"] if gem_specs["#{gem_file}"]
+
+      find_downloaded_gem(gem_file)
+      return gem_specs["#{gem_file}"] if gem_specs["#{gem_file}"]
+
+      download_specification(gem_name, version)
+    end
+
+    def download_specification(gem_name, version)
+      dep = Gem::Dependency.new gem_name, version
+      specs_and_sources, _errors = Gem::SpecFetcher.fetcher.spec_for_dependency dep
+      spec, source = specs_and_sources.max_by { |s,| s.version }
+      error "Gem #{gem_name} in #{version} doesn't exist." if spec.nil?
+
+      fix_comparing_version(version, spec.version.to_s)
+      gem_file = gem_file_name(gem_name, spec.version.to_s)
+
+      gem_specs["#{gem_file}"] = spec
+
+      [spec, source]
+    end
+
+    ##
+    # Ensure the right version is referenced
+
+    def fix_comparing_version(version, spec_version)
+      if spec_version != version
+        @compared_versions.each do |v|
+          if v == version
+            @compared_versions[@compared_versions.index(version)] = spec_version
+            return
+          end
+        end
+      end
+    end
+
+    def find_downloaded_gem(gem_file)
+      if File.exist? File.join(@options[:output], gem_file)
+        info "#{gem_file} exists, using already downloaded file."
+        package = Gem::Package.new File.join(@options[:output], gem_file)
+        use_package(package)
+        [package, package.spec]
+      else
+        [nil, nil]
+      end
+    end
+
+    def use_package(package)
+      gem_file = gem_file_name(package.spec.name, package.spec.version)
+      gem_packages["#{gem_file}"] = package
+      gem_specs["#{gem_file}"] = package.spec
+    end
+
+    def download_gems?
+      return true if @options[:keep_all]
+      @options[:param] ? !param_available_in_marshal?(@options[:param]) : true
+    end
+
+    def gem_packages
+      @gem_packages ||= {}
+    end
+
+    def gem_specs
+      @gem_specs ||= {}
+    end
+
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'rubygems/command_manager'
+Gem::CommandManager.instance.register_command :compare

data/test/gemfiles/lorem-0.0.1/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lorem.gemspec
+gemspec

data/test/gemfiles/lorem-0.0.1/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Josef Stribny
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/test/gemfiles/lorem-0.0.1/README.md

@@ -0,0 +1,29 @@
+# Lorem
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lorem'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lorem
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/lorem/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/test/gemfiles/lorem-0.0.1/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/test/gemfiles/lorem-0.0.1/lib/lorem/version.rb

@@ -0,0 +1,3 @@
+module Lorem
+  VERSION = "0.0.1"
+end

data/test/gemfiles/lorem-0.0.1/lib/lorem.rb

@@ -0,0 +1,7 @@
+require "lorem/version"
+
+module Lorem
+  def hello_world
+    puts 'Hello World'
+  end
+end

data/test/gemfiles/lorem-0.0.1/lorem.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lorem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lorem"
+  spec.version       = Lorem::VERSION
+  spec.authors       = ["Josef Stribny"]
+  spec.email         = ["jstribny@redhat.com"]
+  spec.summary       = "lorem is a gem for testing skillnad"
+  spec.description   = "lorem changes a lot so we can test skillnad a lot"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = ["lorem.gemspec", "Gemfile", "Rakefile", "LICENSE.txt", "README.md"] +
+                       Dir.glob("lib/**/*")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/test/gemfiles/lorem-0.0.2/CHANGELOG.md

@@ -0,0 +1,6 @@
+lorem 0.0.2
+===========
+
+- add changelog file
+- change license to GPLv2
+- add new method to lib/lorem.rb

data/test/gemfiles/lorem-0.0.2/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lorem.gemspec
+gemspec

data/test/gemfiles/lorem-0.0.2/LICENSE.txt

@@ -0,0 +1,3 @@
+Copyright (c) 2014 Josef Stribny
+
+You can use this library under GPLv2 conditions.

data/test/gemfiles/lorem-0.0.2/README.md

@@ -0,0 +1,29 @@
+# Lorem
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lorem'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lorem
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/lorem/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/test/gemfiles/lorem-0.0.2/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/test/gemfiles/lorem-0.0.2/lib/lorem/version.rb

@@ -0,0 +1,3 @@
+module Lorem
+  VERSION = "0.0.2"
+end

data/test/gemfiles/lorem-0.0.2/lib/lorem.rb

@@ -0,0 +1,11 @@
+require "lorem/version"
+
+module Lorem
+  def hello_world
+    puts 'Hello World'
+  end
+
+  def new_method
+    raise 'needs to be implemented'
+  end
+end