libgems 0.0.1

data/lib/libgems/validator.rb

@@ -0,0 +1,240 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'find'
+
+require 'digest'
+require 'libgems/format'
+require 'libgems/installer'
+
+begin
+  gem 'test-unit'
+rescue LibGems::LoadError
+  # Ignore - use the test-unit library that's part of the standard library
+end
+
+##
+# Validator performs various gem file and gem database validation
+
+class LibGems::Validator
+
+  include LibGems::UserInteraction
+
+  ##
+  # Given a gem file's contents, validates against its own MD5 checksum
+  # gem_data:: [String] Contents of the gem file
+
+  def verify_gem(gem_data)
+    raise LibGems::VerificationError, 'empty gem file' if gem_data.size == 0
+
+    unless gem_data =~ /MD5SUM/ then
+      return # Don't worry about it...this sucks.  Need to fix MD5 stuff for
+      # new format
+      # FIXME
+    end
+
+    sum_data = gem_data.gsub(/MD5SUM = "([a-z0-9]+)"/,
+                             "MD5SUM = \"#{"F" * 32}\"")
+
+    unless Digest::MD5.hexdigest(sum_data) == $1.to_s then
+      raise LibGems::VerificationError, 'invalid checksum for gem file'
+    end
+  end
+
+  ##
+  # Given the path to a gem file, validates against its own MD5 checksum
+  #
+  # gem_path:: [String] Path to gem file
+
+  def verify_gem_file(gem_path)
+    open gem_path, LibGems.binary_mode do |file|
+      gem_data = file.read
+      verify_gem gem_data
+    end
+  rescue Errno::ENOENT, Errno::EINVAL
+    raise LibGems::VerificationError, "missing gem file #{gem_path}"
+  end
+
+  private
+
+  def find_files_for_gem(gem_directory)
+    installed_files = []
+    Find.find gem_directory do |file_name|
+      fn = file_name[gem_directory.size..file_name.size-1].sub(/^\//, "")
+      installed_files << fn unless
+        fn =~ /CVS/ || fn.empty? || File.directory?(file_name)
+    end
+    installed_files
+  end
+
+  public
+
+  ErrorData = Struct.new :path, :problem
+
+  ##
+  # Checks the gem directory for the following potential
+  # inconsistencies/problems:
+  #
+  # * Checksum gem itself
+  # * For each file in each gem, check consistency of installed versions
+  # * Check for files that aren't part of the gem but are in the gems directory
+  # * 1 cache - 1 spec - 1 directory.
+  #
+  # returns a hash of ErrorData objects, keyed on the problem gem's name.
+
+  def alien(gems=[])
+    errors = Hash.new { |h,k| h[k] = {} }
+
+    LibGems::SourceIndex.from_installed_gems.each do |gem_name, gem_spec|
+      next unless gems.include? gem_spec.name unless gems.empty?
+
+      install_dir = gem_spec.installation_path
+      gem_path = File.join install_dir, "cache", gem_spec.file_name
+      spec_path = File.join install_dir, "specifications", gem_spec.spec_name
+      gem_directory = gem_spec.full_gem_path
+
+      unless File.directory? gem_directory then
+        errors[gem_name][gem_spec.full_name] =
+          "Gem registered but doesn't exist at #{gem_directory}"
+        next
+      end
+
+      unless File.exist? spec_path then
+        errors[gem_name][spec_path] = "Spec file missing for installed gem"
+      end
+
+      begin
+        verify_gem_file(gem_path)
+
+        good, gone, unreadable = nil, nil, nil, nil
+
+        open gem_path, LibGems.binary_mode do |file|
+          format = LibGems::Format.from_file_by_path(gem_path)
+
+          good, gone = format.file_entries.partition { |entry, _|
+            File.exist? File.join(gem_directory, entry['path'])
+          }
+
+          gone.map! { |entry, _| entry['path'] }
+          gone.sort.each do |path|
+            errors[gem_name][path] = "Missing file"
+          end
+
+          good, unreadable = good.partition { |entry, _|
+            File.readable? File.join(gem_directory, entry['path'])
+          }
+
+          unreadable.map! { |entry, _| entry['path'] }
+          unreadable.sort.each do |path|
+            errors[gem_name][path] = "Unreadable file"
+          end
+
+          good.each do |entry, data|
+            begin
+              next unless data # HACK `gem check -a mkrf`
+
+              open File.join(gem_directory, entry['path']), LibGems.binary_mode do |f|
+                unless Digest::MD5.hexdigest(f.read).to_s ==
+                    Digest::MD5.hexdigest(data).to_s then
+                  errors[gem_name][entry['path']] = "Modified from original"
+                end
+              end
+            end
+          end
+        end
+
+        installed_files = find_files_for_gem(gem_directory)
+        good.map! { |entry, _| entry['path'] }
+        extras = installed_files - good - unreadable
+
+        extras.each do |extra|
+          errors[gem_name][extra] = "Extra file"
+        end
+      rescue LibGems::VerificationError => e
+        errors[gem_name][gem_path] = e.message
+      end
+    end
+
+    errors.each do |name, subhash|
+      errors[name] = subhash.map { |path, msg| ErrorData.new(path, msg) }
+    end
+
+    errors
+  end
+
+  if RUBY_VERSION < '1.9' then
+    class TestRunner
+      def initialize(suite, ui)
+        @suite = suite
+        @ui = ui
+      end
+
+      def self.run(suite, ui)
+        require 'test/unit/ui/testrunnermediator'
+        return new(suite, ui).start
+      end
+
+      def start
+        @mediator = Test::Unit::UI::TestRunnerMediator.new(@suite)
+        @mediator.add_listener(Test::Unit::TestResult::FAULT, &method(:add_fault))
+        return @mediator.run_suite
+      end
+
+      def add_fault(fault)
+        if LibGems.configuration.verbose then
+          @ui.say fault.long_display
+        end
+      end
+    end
+
+    autoload :TestRunner, 'test/unit/ui/testrunnerutilities'
+  end
+
+  ##
+  # Runs unit tests for a given gem specification
+
+  def unit_test(gem_spec)
+    start_dir = Dir.pwd
+    Dir.chdir(gem_spec.full_gem_path)
+    $: << gem_spec.full_gem_path
+    # XXX: why do we need this gem_spec when we've already got 'spec'?
+    test_files = gem_spec.test_files
+
+    if test_files.empty? then
+      say "There are no unit tests to run for #{gem_spec.full_name}"
+      return nil
+    end
+
+    gem gem_spec.name, "= #{gem_spec.version.version}"
+
+    test_files.each do |f| require f end
+
+    if RUBY_VERSION < '1.9' then
+      suite = Test::Unit::TestSuite.new("#{gem_spec.name}-#{gem_spec.version}")
+
+      ObjectSpace.each_object(Class) do |klass|
+        suite << klass.suite if (klass < Test::Unit::TestCase)
+      end
+
+      result = TestRunner.run suite, ui
+
+      alert_error result.to_s unless result.passed?
+    else
+      result = MiniTest::Unit.new
+      result.run
+    end
+
+    result
+  ensure
+    Dir.chdir(start_dir)
+  end
+
+  def remove_leading_dot_dir(path)
+    path.sub(/^\.\//, "")
+  end
+
+end
+

data/lib/libgems/version.rb

@@ -0,0 +1,316 @@
+##
+# The Version class processes string versions into comparable
+# values. A version string should normally be a series of numbers
+# separated by periods. Each part (digits separated by periods) is
+# considered its own number, and these are used for sorting. So for
+# instance, 3.10 sorts higher than 3.2 because ten is greater than
+# two.
+#
+# If any part contains letters (currently only a-z are supported) then
+# that version is considered prerelease. Versions with a prerelease
+# part in the Nth part sort less than versions with N-1
+# parts. Prerelease parts are sorted alphabetically using the normal
+# Ruby string sorting rules. If a prerelease part contains both
+# letters and numbers, it will be broken into multiple parts to
+# provide expected sort behavior.(1.0.a10 becomes 1.0.a.10, and is
+# greater than 1.0.a9).
+#
+# Prereleases sort between real releases (newest to oldest):
+#
+# 1. 1.0
+# 2. 1.0.b1
+# 3. 1.0.a.2
+# 4. 0.9
+#
+# == How Software Changes
+#
+# Users expect to be able to specify a version constraint that gives them
+# some reasonable expectation that new versions of a library will work with
+# their software if the version constraint is true, and not work with their
+# software if the version constraint is false.  In other words, the perfect
+# system will accept all compatible versions of the library and reject all
+# incompatible versions.
+#
+# Libraries change in 3 ways (well, more than 3, but stay focused here!).
+#
+# 1. The change may be an implementation detail only and have no effect on
+#    the client software.
+# 2. The change may add new features, but do so in a way that client software
+#    written to an earlier version is still compatible.
+# 3. The change may change the public interface of the library in such a way
+#    that old software is no longer compatible.
+#
+# Some examples are appropriate at this point.  Suppose I have a Stack class
+# that supports a <tt>push</tt> and a <tt>pop</tt> method.
+#
+# === Examples of Category 1 changes:
+#
+# * Switch from an array based implementation to a linked-list based
+#   implementation.
+# * Provide an automatic (and transparent) backing store for large stacks.
+#
+# === Examples of Category 2 changes might be:
+#
+# * Add a <tt>depth</tt> method to return the current depth of the stack.
+# * Add a <tt>top</tt> method that returns the current top of stack (without
+#   changing the stack).
+# * Change <tt>push</tt> so that it returns the item pushed (previously it
+#   had no usable return value).
+#
+# === Examples of Category 3 changes might be:
+#
+# * Changes <tt>pop</tt> so that it no longer returns a value (you must use
+#   <tt>top</tt> to get the top of the stack).
+# * Rename the methods to <tt>push_item</tt> and <tt>pop_item</tt>.
+#
+# == SlimGems Rational Versioning
+#
+# * Versions shall be represented by three non-negative integers, separated
+#   by periods (e.g. 3.1.4).  The first integers is the "major" version
+#   number, the second integer is the "minor" version number, and the third
+#   integer is the "build" number.
+#
+# * A category 1 change (implementation detail) will increment the build
+#   number.
+#
+# * A category 2 change (backwards compatible) will increment the minor
+#   version number and reset the build number.
+#
+# * A category 3 change (incompatible) will increment the major build number
+#   and reset the minor and build numbers.
+#
+# * Any "public" release of a gem should have a different version.  Normally
+#   that means incrementing the build number.  This means a developer can
+#   generate builds all day long for himself, but as soon as he/she makes a
+#   public release, the version must be updated.
+#
+# === Examples
+#
+# Let's work through a project lifecycle using our Stack example from above.
+#
+# Version 0.0.1:: The initial Stack class is release.
+# Version 0.0.2:: Switched to a linked=list implementation because it is
+#                 cooler.
+# Version 0.1.0:: Added a <tt>depth</tt> method.
+# Version 1.0.0:: Added <tt>top</tt> and made <tt>pop</tt> return nil
+#                 (<tt>pop</tt> used to return the  old top item).
+# Version 1.1.0:: <tt>push</tt> now returns the value pushed (it used it
+#                 return nil).
+# Version 1.1.1:: Fixed a bug in the linked list implementation.
+# Version 1.1.2:: Fixed a bug introduced in the last fix.
+#
+# Client A needs a stack with basic push/pop capability.  He writes to the
+# original interface (no <tt>top</tt>), so his version constraint looks
+# like:
+#
+#   gem 'stack', '~> 0.0'
+#
+# Essentially, any version is OK with Client A.  An incompatible change to
+# the library will cause him grief, but he is willing to take the chance (we
+# call Client A optimistic).
+#
+# Client B is just like Client A except for two things: (1) He uses the
+# <tt>depth</tt> method and (2) he is worried about future
+# incompatibilities, so he writes his version constraint like this:
+#
+#   gem 'stack', '~> 0.1'
+#
+# The <tt>depth</tt> method was introduced in version 0.1.0, so that version
+# or anything later is fine, as long as the version stays below version 1.0
+# where incompatibilities are introduced.  We call Client B pessimistic
+# because he is worried about incompatible future changes (it is OK to be
+# pessimistic!).
+#
+# == Preventing Version Catastrophe:
+#
+# From: http://blog.zenspider.com/2008/10/rubygems-howto-preventing-cata.html
+#
+# Let's say you're depending on the fnord gem version 2.y.z. If you
+# specify your dependency as ">= 2.0.0" then, you're good, right? What
+# happens if fnord 3.0 comes out and it isn't backwards compatible
+# with 2.y.z? Your stuff will break as a result of using ">=". The
+# better route is to specify your dependency with a "spermy" version
+# specifier. They're a tad confusing, so here is how the dependency
+# specifiers work:
+#
+#   Specification From  ... To (exclusive)
+#   ">= 3.0"      3.0   ... &infin;
+#   "~> 3.0"      3.0   ... 4.0
+#   "~> 3.0.0"    3.0.0 ... 3.1
+#   "~> 3.5"      3.5   ... 4.0
+#   "~> 3.5.0"    3.5.0 ... 3.6
+
+class LibGems::Version
+  include Comparable
+
+  VERSION_PATTERN = '[0-9]+(\.[0-9a-zA-Z]+)*' # :nodoc:
+  ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})*\s*\z/ # :nodoc:
+
+  ##
+  # A string representation of this Version.
+
+  attr_reader :version
+  alias to_s version
+
+  ##
+  # True if the +version+ string matches SlimGems' requirements.
+
+  def self.correct? version
+    version.to_s =~ ANCHORED_VERSION_PATTERN
+  end
+
+  ##
+  # Factory method to create a Version object. Input may be a Version
+  # or a String. Intended to simplify client code.
+  #
+  #   ver1 = Version.create('1.3.17')   # -> (Version object)
+  #   ver2 = Version.create(ver1)       # -> (ver1)
+  #   ver3 = Version.create(nil)        # -> nil
+
+  def self.create input
+    if input.respond_to? :version then
+      input
+    elsif input.nil? then
+      nil
+    else
+      new input
+    end
+  end
+
+  ##
+  # Constructs a Version from the +version+ string.  A version string is a
+  # series of digits or ASCII letters separated by dots.
+
+  def initialize version
+    raise ArgumentError, "Malformed version number string #{version}" unless
+      self.class.correct?(version)
+
+    @version = version.to_s
+    @version.strip!
+  end
+
+  ##
+  # Return a new version object where the next to the last revision
+  # number is one greater (e.g., 5.3.1 => 5.4).
+  #
+  # Pre-release (alpha) parts, e.g, 5.3.1.b.2 => 5.4, are ignored.
+
+  def bump
+    segments = self.segments.dup
+    segments.pop while segments.any? { |s| String === s }
+    segments.pop if segments.size > 1
+
+    segments[-1] = segments[-1].succ
+    self.class.new segments.join(".")
+  end
+
+  ##
+  # A Version is only eql? to another version if it's specified to the
+  # same precision. Version "1.0" is not the same as version "1".
+
+  def eql? other
+    self.class === other and @version == other.version
+  end
+
+  def hash # :nodoc:
+    @hash ||= segments.hash
+  end
+
+  def inspect # :nodoc:
+    "#<#{self.class} #{version.inspect}>"
+  end
+
+  ##
+  # Dump only the raw version string, not the complete object. It's a
+  # string for backwards (SlimGems 1.3.5 and earlier) compatibility.
+
+  def marshal_dump
+    [version]
+  end
+
+  ##
+  # Load custom marshal format. It's a string for backwards (SlimGems
+  # 1.3.5 and earlier) compatibility.
+
+  def marshal_load array
+    initialize array[0]
+  end
+
+  ##
+  # A version is considered a prerelease if it contains a letter.
+
+  def prerelease?
+    @prerelease ||= @version =~ /[a-zA-Z]/
+  end
+
+  def pretty_print q # :nodoc:
+    q.text "LibGems::Version.new(#{version.inspect})"
+  end
+
+  ##
+  # The release for this version (e.g. 1.2.0.a -> 1.2.0).
+  # Non-prerelease versions return themselves.
+
+  def release
+    return self unless prerelease?
+
+    segments = self.segments.dup
+    segments.pop while segments.any? { |s| String === s }
+    self.class.new segments.join('.')
+  end
+
+  def segments # :nodoc:
+
+    # segments is lazy so it can pick up version values that come from
+    # old marshaled versions, which don't go through marshal_load.
+
+    @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
+      /^\d+$/ =~ s ? s.to_i : s
+    end
+  end
+
+  ##
+  # A recommended version for use with a ~> Requirement.
+
+  def spermy_recommendation
+    segments = self.segments.dup
+
+    segments.pop    while segments.any? { |s| String === s }
+    segments.pop    while segments.size > 2
+    segments.push 0 while segments.size < 2
+
+    "~> #{segments.join(".")}"
+  end
+
+  ##
+  # Compares this version with +other+ returning -1, 0, or 1 if the
+  # other version is larger, the same, or smaller than this
+  # one. Attempts to compare to something that's not a
+  # <tt>LibGems::Version</tt> return +nil+.
+
+  def <=> other
+    return unless LibGems::Version === other
+    return 0 if @version == other.version
+
+    lhsegments = segments
+    rhsegments = other.segments
+
+    lhsize = lhsegments.size
+    rhsize = rhsegments.size
+    limit  = (lhsize > rhsize ? lhsize : rhsize) - 1
+
+    i = 0
+
+    while i <= limit
+      lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0
+      i += 1
+
+      next               if lhs == rhs
+      return  -1         if String  === lhs && Numeric === rhs
+      return   1         if Numeric === lhs && String  === rhs
+      return lhs <=> rhs
+    end
+
+    return 0
+  end
+end