library 0.1.0

data/lib/library/rubygems.rb

@@ -0,0 +1,19 @@
+if not defined?(Gem)
+
+  module Gem
+    # Some libraries, such as RDoc search through
+    # all libraries for plugins using this method.
+    # If RubyGems is not being used, then Rolls
+    # emulates it.
+    #
+    #  Gem.find_files('rdoc/discover')
+    #
+    # TODO: Perhaps it should override if it exists
+    # and call back to it on failuer?
+    def self.find_files(path)
+      ::Library.search(path).map{ |f| f.to_s }
+    end
+  end
+
+end
+

data/lib/library/rubylib.rb

@@ -0,0 +1,206 @@
+require 'rbconfig'
+require 'library'
+
+# RubyLibrary is a specialized subclass of Library specifically designed
+# to sever Ruby's standard library. It is used to speed up load times for
+# for library files that are standard Ruby scripts and should never be
+# overriden by any 3rd party libraries. Good examples are 'ostruct' and
+# 'optparse'.
+#
+# This class is in the proccess of being refined to exclude certian 3rd
+# party redistributions, such RDoc and Soap4r.
+#
+class RubyLibrary < Library
+
+  include ::RbConfig
+
+  #
+  # Setup Ruby library.
+  #
+  def initialize(*) #(location, metadata={})
+    #rubylibdir  = ::RbConfig::CONFIG['rubylibdir']
+    #rubyarchdir = ::RbConfig::CONFIG['archdir']
+    #rel_archdir  = rubyarchdir.sub(rubylibdir+'/', '')
+    #
+    #@location = rubylibdir
+    #@loadpath = ['', rel_archpath]
+
+    location = find_base_path(CONFIG.values_at('rubylibdir', 'sitelibdir', 'vendorlibdir'))
+    loadpath = CONFIG.values_at(
+      'rubylibdir',
+      'archdir',
+      'sitelibdir',
+      'sitearchdir',
+      'vendorlibdir',
+      'vendorarchdir'
+    ).map{ |d| d.sub(location + '/','') }
+
+    @location = location
+    @loadpath = loadpath
+    @name     = 'ruby'
+    @metadata = {}  # TODO: can we fillout Ruby's metadata some ?
+  end
+
+  #
+  # Then name of RubyLibrary is `ruby`.
+  #
+  def name
+    'ruby'
+  end
+
+  #
+  # Ruby version is RUBY_VERSION.
+  #
+  def version
+    RUBY_VERSION
+  end
+
+  # TODO: Remove rugbygems from $LOAD_PATH and use that?
+
+  # TODO: Sometimes people add paths directly to $LOAD_PATH,
+  #   should these be accessible via `ruby/`?
+
+  #
+  # Load path is essentially $LOAD_PATH, less gem paths.
+  #
+  def loadpath
+    #$LOAD_PATH - ['.']
+    @loadpath
+  end
+
+  alias load_path loadpath
+
+  #
+  # Release date.
+  #
+  # @todo This currently just returns current date/time.
+  #   Is there a way to get Ruby's own release date?
+  #
+  def date
+    Time.now
+  end
+
+  #
+  alias released date
+
+  #
+  # Ruby requires nothing.
+  #
+  def requirements
+    []
+  end
+
+  #
+  # Ruby needs to ignore a few 3rd party libraries. They will
+  # be picked up by the final fallback to Ruby's original require
+  # if all else fails.
+  #
+  def find(file, suffix=true)
+    return nil if /^rdoc/ =~ file
+    super(file, suffix)
+  end
+
+  #
+  # Location of executables, which for Ruby is `RbConfig::CONFIG['bindir']`.
+  #
+  def bindir
+    ::RbConfig::CONFIG['bindir']
+  end
+
+  #
+  # Is there a `bin/` location?
+  #
+  def bindir?
+    File.exist?(bindir)
+  end
+
+  #
+  # Location of library system configuration files.
+  # For Ruby this is `RbConfig::CONFIG['sysconfdir']`.
+  #
+  def confdir
+    ::RbConfig::CONFIG['sysconfdir']
+  end
+
+  #
+  # Is there a "`etc`" location?
+  #
+  def confdir?
+    File.exist?(confdir)
+  end
+
+  #
+  # Location of library shared data directory. For Ruby this is
+  # `RbConfig::CONFIG['datadir']`.
+  #
+  def datadir
+    ::RbConfig::CONFIG['datadir']
+  end
+
+  #
+  # Is there a `data/` location?
+  #
+  def datadir?
+    File.exist?(datadir)
+  end
+
+  #
+  # Require library +file+ given as a Script instance.
+  #
+  # @param [String] feature
+  #   Instance of Feature.
+  #
+  # @return [Boolean] Success of requiring the feature.
+  #
+  def require_absolute(feature)
+    return false if $".include?(feature.localname)  # ruby 1.8 does not use absolutes
+    success = super(feature)
+    $" << feature.localname # ruby 1.8 does not use absolutes TODO: move up?
+    $".uniq!
+    success
+  end
+
+  #
+  # Load library +file+ given as a Script instance.
+  #
+  # @param [String] feature
+  #   Instance of Feature.
+  #
+  # @return [Boolean] Success of loading the feature.
+  #
+  def load_absolute(feature, wrap=nil)
+    success = super(feature, wrap)
+    $" << feature.localname # ruby 1.8 does not use absolutes TODO: move up?
+    $".uniq!
+    success
+  end
+
+  #
+  # The loadpath sorted by largest path first.
+  #
+  def loadpath_sorted
+    loadpath.sort{ |a,b| b.size <=> a.size }
+  end
+
+  #
+  # Construct a Script match.
+  #
+  def libfile(lpath, file, ext=nil)
+    Library::Feature.new(self, lpath, file, ext) 
+  end
+
+private
+
+  # Given an array of path strings, find the longest common prefix path.
+  def find_base_path(paths)
+    return paths.first if paths.length <= 1
+    arr = paths.sort
+    f = arr.first.split('/')
+    l = arr.last.split('/')
+    i = 0
+    i += 1 while f[i] == l[i] && i <= f.length
+    f.slice(0, i).join('/')
+  end
+
+end
+

data/lib/library/version.rb

@@ -0,0 +1,387 @@
+class Library
+
+  # The Library::Version class is essentially a tuple (immutable array)
+  # with special comparision operators.
+  #
+  class Version
+    include Comparable
+    include Enumerable
+
+    #
+    # Convenience alias for ::new.
+    #
+    def self.[](*args)
+      new(*args)
+    end
+
+    # Parses a string constraint returning the operation as a lambda.
+    #
+    # @param constraint [String]
+    #   valid version constraint, e.g. ">1.0" and "1.0+"
+    #
+    # @return [Proc] procedure for making contraint comparisons
+    #
+    def self.constraint_lambda(constraint)
+      op, val = *parse_constraint(constraint)
+      lambda do |t|
+        case t
+        when Version
+          t.send(op, val)
+        else
+          Version.new(t).send(op, val)
+        end
+      end
+    end
+
+    #
+    # Converts a constraint into an operator and value.
+    #
+    # @param [String]
+    #   valid version constraint , e.g. "= 2.1.3"
+    #
+    # @return [Array<String>] operator and version number pair
+    #
+    def self.parse_constraint(constraint)
+      constraint = constraint.strip
+      re = %r{^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?\.\S+)*)$}
+      if md = re.match(constraint)
+        if op = md[1]
+          op = '=~' if op == '~>'
+          op = '==' if op == '='
+          val = new(*md[2].split(/\W+/))
+        else
+          op = '=='
+          val = new(*constraint.split(/\W+/))
+        end
+      else
+        raise ArgumentError, "invalid constraint"
+      end
+      return op, val
+    end
+
+    #
+    # Parse common Hash-based version, i.e. Jeweler format.
+    #
+    # @param [Hash] version hash
+    #
+    # @return [Library::Version] instance of Version
+    #
+    def self.parse_hash(data)
+      data = data.inject({}){ |h,(k,v)| h[k.to_sym] = v; h }
+      if data[:major]
+        vers = data.values_at(:major, :minor, :patch, :build)
+      else
+        vers = data[:vers] || data[:version]
+      end
+      new vers
+    end
+
+    #
+    # Parse YAML-based version.
+    # TODO: deprecate ?
+    #
+    def parse_yaml(yaml)
+      require 'yaml'
+      parse_hash( YAML.load(yaml) )
+    end
+
+    #
+    # Instantiate new instance of Version.
+    #
+    def initialize(*args)
+      args   = args.flatten.compact
+      args   = args.join('.').split(/\W+/)
+      @tuple = args.map{ |i| /^\d+$/ =~ i.to_s ? i.to_i : i }
+    end
+
+    #
+    # Returns string representation of version, e.g. "1.0.0".
+    #
+    # @return [String] version number in dot format
+    #
+    def to_s
+      @tuple.compact.join('.')
+    end
+
+    #
+    # Library::Version is not technically a String-type. This is here
+    # only becuase `File.join` calls it instead of #to_s.
+    #
+    # @return [String] version number in dot format
+    #
+    def to_str
+      @tuple.compact.join('.')
+    end
+
+    #
+    #def inspect; to_s; end
+
+    #
+    # Access indexed segment of version number.
+    # Returns `0` if index is non-existant.
+    #
+    # @param index [Integer] a segment index of the version
+    #
+    # @return [Integer, String] version segment
+    #
+    def [](index)
+      @tuple.fetch(index,0)
+    end
+
+    #
+    # "Spaceship" comparsion operator.
+    #
+    # @param other [Library::Version, Array] 
+    #   a Library::Version or equvalent Array to compare
+    #
+    # @return [Integer] 
+    #   `-1`, `0`, or `1` for less, equal or greater, respectively
+    #
+    def <=>(other)
+      [size, other.size].max.times do |i|
+        c = self[i] <=> (other[i] || 0)
+        return c if c != 0
+      end
+      0
+    end
+
+    #
+    # Pessimistic constraint (like '~>' in gems).
+    #
+    # @param other [Library::Version]
+    #   another instance of version
+    #
+    # @return [Boolean] match pessimistic constraint?
+    #
+    def =~(other)
+      #other = other.to_t
+      upver = other.tuple.dup
+      i = upver.index(0)
+      i = upver.size unless i
+      upver[i-1] += 1
+      self >= other && self < upver
+    end
+
+    #
+    # Major is the first number in the version series.
+    #
+    def major ; @tuple[0] ; end
+
+    #
+    # Minor is the second number in the version series.
+    #
+    def minor ; @tuple[1] || 0 ; end
+
+    #
+    # Patch is third number in the version series.
+    #
+    def patch ; @tuple[2] || 0 ; end
+
+    #
+    # Build returns the remaining portions of the version
+    # tuple after +patch+ joined by '.'.
+    #
+    # @return [String] version segments after the 3rd in point-format
+    #
+    def build
+      @tuple[3..-1].join('.')
+    end
+
+    #
+    # Iterate over each version segment.
+    #
+    def each(&block)
+      @tuple.each(&block)
+    end
+
+    #
+    # Size of version tuple.
+    #
+    # @return [Integer] number of segments
+    #
+    def size
+      @tuple.size
+    end
+
+    # Delegate to the array.
+    #def method_missing(sym, *args, &blk)
+    #  @tuple.__send__(sym, *args, &blk) rescue super
+    #end
+
+    #
+    # Does this version satisfy a given constraint?
+    #
+    def satisfy?(constraint)
+      c = Constraint.parse(constraint)
+      send(c.operator, c.number)
+    end
+
+    protected
+
+    #
+    # The internal tuple modeling the version number.
+    #
+    # @return [Array] internal tuple representing the version
+    #
+    def tuple
+      @tuple
+    end
+
+  end
+
+  # VersionError is raised when a requested version cannot be found.
+  #
+  class VersionError < ::RangeError  # :nodoc:
+  end
+
+  # VersionConflict is raised when selecting another version
+  # of a library when a previous version has already been selected.
+  #
+  class VersionConflict < ::LoadError  # :nodoc:
+
+    #
+    # Setup conflict error instance.
+    #
+    def initialize(lib1, lib2=nil)
+      @lib1 = lib1
+      @lib2 = lib2
+    end
+
+    #
+    #
+    #
+    def to_s
+      if @lib2
+        @lib1.inspect + " vs. " + @lib2.inspect
+      else
+        "previously selected version -- #{@lib1.inspect}"
+      end
+    end
+
+  end
+
+  class Version
+
+    # The Constraint class models a single version equality or inequality.
+    # It consists of the operator and the version number.
+    #--
+    # TODO: Please improve me!
+    #
+    # TODO: This should ultimately replace the class methods of Version::Number.
+    #
+    # TODO: Do we need to support version "from-to" spans ?
+    #++
+    class Constraint
+
+      #
+      def self.parse(constraint)
+        return constraint if self === constraint
+        new(constraint)
+      end
+
+      #
+      def self.[](operator, number)
+        new([operator, number])
+      end
+
+      #
+      def initialize(constraint)
+        @operator, @number = parse(constraint || '0+')
+
+        case constraint
+        when Array
+          @stamp = "%s %s" % [@operator, @number]
+        when String
+          @stamp = constraint || '0+'
+        end
+      end
+
+      # Constraint operator.
+      attr :operator
+
+      # Verison number.
+      attr :number
+
+      #
+      def to_s
+        @stamp
+      end
+
+      # Converts the version into a constraint string recognizable
+      # by RubyGems.
+      #--
+      # TODO: Better name Constraint#to_s2.
+      #++
+      def to_gem_version
+        op = (operator == '=~' ? '~>' : operator)
+        "%s %s" % [op, number]
+      end
+
+      # Convert constraint to Proc object which can be
+      # used to test a version number.
+      def to_proc
+        lambda do |v|
+          n = Version::Number.parse(v)
+          n.send(operator, number)
+        end
+      end
+
+      #
+      def compare(version)
+        version.send(operator, number)
+      end
+
+    private
+
+      #
+      def parse(constraint)
+        case constraint
+        when Array
+          op, num = constraint
+        when /^(.*?)\~$/
+          op, val = "=~", $1
+        when /^(.*?)\+$/
+          op, val = ">=", $1
+        when /^(.*?)\-$/
+          op, val = "<", $1
+        when /^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\w+)*)$/
+          if op = $1
+            op = '=~' if op == '~>'
+            op = '==' if op == '='
+            val = $2.split(/\W+/)
+          else
+            op = '=='
+            val = constraint.split(/\W+/)
+          end
+        else
+          raise ArgumentError #constraint.split(/\s+/)
+        end
+        return op, Version.new(*val) #Version::Number.new(*val)
+      end
+
+      # Parse package entry into name and version constraint.
+      #def parse(package)
+      #  parts = package.strip.split(/\s+/)
+      #  name = parts.shift
+      #  vers = parts.empty? ? nil : parts.join(' ')
+      # [name, vers]
+      #end
+
+    public
+
+      # Parses a string constraint returning the operation as a lambda.
+      def self.constraint_lambda(constraint)
+        new(constraint).to_proc
+      end
+
+      # Parses a string constraint returning the operator and value.
+      def self.parse_constraint(constraint)
+        c = new(constraint)
+        return c.operator, c.number
+      end
+
+    end
+
+  end
+
+end