roll 0.8.0 → 1.1.0

data/lib/roll/locals.rb

@@ -0,0 +1,96 @@
+module Roll
+
+  #
+  class Locals
+
+    include Enumerable
+
+    #
+    DIR = XDG.config_home, 'roll', 'locals'
+
+    #
+    #def self.save(name)
+    #  File.open(file, 'w'){ |f| f << "#{name}" }
+    #end
+
+    # List of available environments.
+    def self.list
+      Dir[File.join(DIR, '*')].map do |file|
+        File.basename(file)
+      end
+    end
+
+    #
+    def initialize(name=nil)
+      @name = name || self.class.current
+      reload
+    end
+
+    #
+    def name
+      @name
+    end
+
+    #
+    def file
+      @file ||= File.join(DIR, name)
+    end
+
+    #
+    def reload
+      t = []
+      if File.exist?(file)
+        lines = File.readlines(file)
+        lines.each do |line|
+          line = line.strip
+          path, depth = *line.split(/\s+/)
+          next if line =~ /^\s*$/  # blank
+          next if line =~ /^\#/    # comment
+          dir, depth = *line.split(/\s+/)
+          t << [path, (depth || 3).to_i]
+        end
+      else
+        t = []
+      end
+      @table = t
+    end
+
+    #
+    def each(&block)
+      @table.each(&block)
+    end
+
+    #
+    def size
+      @table.size
+    end
+
+    #
+    def append(path, depth=3)
+      path  = File.expand_path(path)
+      depth = (depth || 3).to_i
+      @table = @table.reject{ |(p, d)| path == p }
+      @table.push([path, depth])
+    end
+
+    #
+    def delete(path)
+      @table.reject!{ |p,d| path == p }
+    end
+
+    #
+    def save
+      out = @table.map do |(path, depth)|
+        "#{path}   #{depth}"
+      end
+      dir = File.dirname(file)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      File.open(file, 'w') do |f|
+        f <<  out.join("\n")
+      end
+    end
+
+  end
+
+end
+

data/lib/roll/metadata.rb

@@ -0,0 +1,112 @@
+module Roll
+
+  #--
+  # TODO: Use POM? If available?
+  #--
+  class Metadata
+
+    #TODO: hide most methods
+
+    attr :location
+
+    #
+    def initialize(location)
+      @location = location
+      @cache = {}
+    end
+
+    # Get library name.
+    def name
+      @cache[:name] ||= read('name')
+    end
+
+    # Get library version. 
+    #--
+    # TODO: handle VERSION file
+    # TODO: handle YAML
+    #++
+    def version
+      @cache[:version] ||= Version.new(read(:version))
+    end
+
+    # Get library active state.
+    def active
+      return @cache[:active] if @cache.key?(:active)
+      @cache[:active] = (
+        case read(:active).to_s.downcase
+        when 'false', 'no'
+          false
+        else
+          true
+        end
+      )
+    end
+
+    # Get library release date. 
+    #--
+    # TODO: default date to what?
+    #++
+    def released
+      @cache[:released] ||= read(:released) || "1900-01-01"
+    end
+
+    # Get library loadpath.
+    def loadpath
+      @cache[:loadpath] ||= (
+        val = read(:loadpath).to_s.strip.split(/\s*\n/)  # TODO: handle YAML
+        val = ['lib'] if val.empty?
+        val
+      )
+    end
+
+    #
+    def requires
+      @cache[:requires] ||= (
+        if entry = read(:requires)
+          entry.strip.split("\n").map do |line|
+            line.strip.split(/\s+/)
+          end
+        else
+          []
+        end
+      )
+    end
+
+    #
+    def method_missing(name, *args)
+      if @cache.key?(name)
+        @cache[name]
+      else
+        @cache[name] = read(name)
+      end
+    end
+
+  private
+
+    #
+    def read(name)
+      file = Dir[File.join(location, "{meta,.meta}", name.to_s)].first
+      if file
+        text = File.read(file)
+        if text =~ /^---/
+          require_yaml
+          YAML.load(text)
+        else
+          text.strip
+        end
+      else
+        nil
+      end
+    end
+
+    #
+    def require_yaml
+      @require_yaml ||=(
+        require 'yaml'
+        true
+      )
+    end
+  end
+
+end
+

data/lib/roll/original.rb

@@ -0,0 +1,10 @@
+# Rubinius
+RUBY_IGNORE_CALLERS = [] unless defined? RUBY_IGNORE_CALLERS
+RUBY_IGNORE_CALLERS << %r{roll/kernel\.rb$}
+RUBY_IGNORE_CALLERS << %r{roll/original\.rb$}
+ 
+module ::Kernel
+  alias_method :original_require, :require
+  alias_method :original_load, :load
+end
+

data/lib/roll/version.rb

@@ -1,127 +1,117 @@
-# TITLE:
-#
-#   VersionNumber
-#
-# DESCRIPTION:
-#
-#   VersionNumber is a simplified form of a Tuple class
-#   desgined specifically for dealing with version numbers.
-#
-# AUTHOR:
-#
-#   - Thomas Sawyer (7rans)
-#
-# LICENSE:
-#
-#   Copyright (c) 2005 Thomas Sawyer
-#
-#   Ruby License
-#
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
-#
-#   This program is distributed in the hope that it will be useful, but WITHOUT
-#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-#   FOR A PARTICULAR PURPOSE.
-#
-# TODO:
-#
-#   - Maybe add Kernel method #version ?
-#
-#   - If Tuple were standard part of Ruby this probably would
-#     not be needed or at least might be simple sublcass instead.
-
-
-# = VersionNumber
-#
-# VersionNumber is a simplified form of a Tuple class
-# desgined specifically for dealing with version numbers.
-#
-class VersionNumber #< Tuple
-
-  #include Enumerable
-  include Comparable
-
-  def initialize( *args )
-    args = args.join('.').split(/\W+/)
-    @self = args.collect { |i| i.to_i }
-  end
+module Roll
 
-  def to_s ; @self.join('.') ; end
+  # = Version
+  #
+  # VersionNumber is a simplified form of a Tuple class
+  # desgined specifically for dealing with version numbers.
+  #
+  class Version #< Tuple
 
-  # This is here only becuase File.join calls it instead of to_s.
+    #include Enumerable
+    include Comparable
 
-  def to_str ; @self.join('.') ; end
+  # metaclass
+  class << self
+    # Convenience alias for ::new.
 
-  def inspect
-    @self.to_s
-  end
+    def [](*args)
+      new(*args)
+    end
 
-  def [](i)
-    @self.fetch(i,0)
-  end
+    # Parses a string constraint returning the operation as a lambda.
 
-  # "Spaceship" comparsion operator.
+    def constraint_lambda(constraint)
+      op, val = *parse_constraint(constraint)
+      lambda{ |t| t.send(op, val) }
+    end
 
-  def <=>( other )
-    #other = other.to_t
-    [@self.size, other.size].max.times do |i|
-      c = @self[i] <=> other[i]
-      return c if c != 0
+    # Converts a constraint into an operator and value.
+
+    def parse_constraint(constraint)
+      constraint = constraint.strip
+      re = %r{^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\d+)*)$}
+      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
-    0
   end
 
-  # For pessimistic constraint (like '~>' in gems)
+  private
 
-  def =~( other )
-    #other = other.to_t
-    upver = other.dup
-    upver[0] += 1
-    @self >= other and @self < upver
-  end
+    def initialize(*args)
+      args = args.join('.').split(/\W+/)
+      @tuple = args.collect { |i| i.to_i }
+      #@tuple.extend(Comparable)
+    end
 
-  # Major is the first number in the version series.
+  public
 
-  def major ; @self[0] ; end
+    def to_s ; @tuple.join('.') ; end
 
-  # Minor is the second number in the version series.
+    # This is here only becuase File.join calls it instead of to_s.
+    def to_str ; @tuple.join('.') ; end
 
-  def minor ; @self[1] || 0 ; end
+    #def inspect; to_s; end
 
-  # Teeny is third number in the version series.
+    def [](i)
+      @tuple.fetch(i,0)
+    end
 
-  def teeny ; @self[2] || 0 ; end
+    # "Spaceship" comparsion operator.
 
-  # Delegate to the array.
+    def <=>(other)
+      #other = other.to_t
+      [@tuple.size, other.size].max.times do |i|
+        c = @tuple[i] <=> other[i]
+        return c if c != 0
+      end
+      0
+    end
 
-  def method_missing( sym, *args, &blk )
-    @self.send(sym, *args, &blk ) rescue super
-  end
+    # For pessimistic constraint (like '~>' in gems).
 
-  # Parses a string constraint returning the operation as a lambda.
+    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
 
-  def self.constraint_lambda( constraint )
-    op, val = *parse_constraint( constraint )
-    lambda { |t| t.send(op, val) }
-  end
+    # Major is the first number in the version series.
 
-  def self.parse_constraint( constraint )
-    constraint = constraint.strip
-    re = %r{^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\d+)*)$}
-    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"
+    def major ; @tuple[0] ; end
+
+    # Minor is the second number in the version series.
+
+    def minor ; @tuple[1] || 0 ; end
+
+    # Teeny is third number in the version series.
+
+    def teeny ; @tuple[2] || 0 ; end
+
+    # Delegate to the array.
+
+    def method_missing(sym, *args, &blk)
+      @tuple.send(sym, *args, &blk) rescue super
     end
-    return op, val
+
+  protected
+
+    def tuple ; @tuple ; end
+
   end
 
 end
+

data/meta/active

@@ -0,0 +1 @@
+false

data/meta/authors

@@ -0,0 +1 @@
+Thomas Sawyer

data/meta/contact

@@ -0,0 +1 @@
+http://groups.google.com/group/proutils

data/meta/created

@@ -0,0 +1 @@
+2006-12-10