search_biomodel 1.0.0 → 1.0.1

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/lib/rake/ext/module.rb

@@ -1,39 +0,0 @@
-require 'rake/ext/core'
-require 'rake/task'
-require 'rake/file_task'
-require 'rake/file_creation_task'
-require 'rake/application'
-require 'rake/task_manager'
-
-######################################################################
-# Rake extensions to Module.
-#
-class Module
-
-  # Rename the original handler to make it available.
-  alias :rake_original_const_missing :const_missing
-
-  # Check for deprecated uses of top level (i.e. in Object) uses of
-  # Rake class names.  If someone tries to reference the constant
-  # name, display a warning and return the proper object.  Using the
-  # --classic-namespace command line option will define these
-  # constants in Object and avoid this handler.
-  def const_missing(const_name)
-    case const_name
-    when :Task
-      Rake.application.const_warning(const_name)
-      Rake::Task
-    when :FileTask
-      Rake.application.const_warning(const_name)
-      Rake::FileTask
-    when :FileCreationTask
-      Rake.application.const_warning(const_name)
-      Rake::FileCreationTask
-    when :RakeApp
-      Rake.application.const_warning(const_name)
-      Rake::Application
-    else
-      rake_original_const_missing(const_name)
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/lib/rake/ext/string.rb

@@ -1,167 +0,0 @@
-require 'rake/ext/core'
-
-######################################################################
-# Rake extension methods for String.
-#
-class String
-  rake_extension("ext") do
-    # Replace the file extension with +newext+.  If there is no extension on
-    # the string, append the new extension to the end.  If the new extension
-    # is not given, or is the empty string, remove any existing extension.
-    #
-    # +ext+ is a user added method for the String class.
-    def ext(newext='')
-      return self.dup if ['.', '..'].include? self
-      if newext != ''
-        newext = (newext =~ /^\./) ? newext : ("." + newext)
-      end
-      self.chomp(File.extname(self)) << newext
-    end
-  end
-
-  rake_extension("pathmap") do
-    # Explode a path into individual components.  Used by +pathmap+.
-    def pathmap_explode
-      head, tail = File.split(self)
-      return [self] if head == self
-      return [tail] if head == '.' || tail == '/'
-      return [head, tail] if head == '/'
-      return head.pathmap_explode + [tail]
-    end
-    protected :pathmap_explode
-
-    # Extract a partial path from the path.  Include +n+ directories from the
-    # front end (left hand side) if +n+ is positive.  Include |+n+|
-    # directories from the back end (right hand side) if +n+ is negative.
-    def pathmap_partial(n)
-      dirs = File.dirname(self).pathmap_explode
-      partial_dirs =
-        if n > 0
-          dirs[0...n]
-        elsif n < 0
-          dirs.reverse[0...-n].reverse
-        else
-          "."
-        end
-      File.join(partial_dirs)
-    end
-    protected :pathmap_partial
-
-    # Preform the pathmap replacement operations on the given path. The
-    # patterns take the form 'pat1,rep1;pat2,rep2...'.
-    def pathmap_replace(patterns, &block)
-      result = self
-      patterns.split(';').each do |pair|
-        pattern, replacement = pair.split(',')
-        pattern = Regexp.new(pattern)
-        if replacement == '*' && block_given?
-          result = result.sub(pattern, &block)
-        elsif replacement
-          result = result.sub(pattern, replacement)
-        else
-          result = result.sub(pattern, '')
-        end
-      end
-      result
-    end
-    protected :pathmap_replace
-
-    # Map the path according to the given specification.  The specification
-    # controls the details of the mapping.  The following special patterns are
-    # recognized:
-    #
-    # * <b>%p</b> -- The complete path.
-    # * <b>%f</b> -- The base file name of the path, with its file extension,
-    #   but without any directories.
-    # * <b>%n</b> -- The file name of the path without its file extension.
-    # * <b>%d</b> -- The directory list of the path.
-    # * <b>%x</b> -- The file extension of the path.  An empty string if there
-    #   is no extension.
-    # * <b>%X</b> -- Everything *but* the file extension.
-    # * <b>%s</b> -- The alternate file separator if defined, otherwise use
-    #   the standard file separator.
-    # * <b>%%</b> -- A percent sign.
-    #
-    # The %d specifier can also have a numeric prefix (e.g. '%2d'). If the
-    # number is positive, only return (up to) +n+ directories in the path,
-    # starting from the left hand side.  If +n+ is negative, return (up to)
-    # |+n+| directories from the right hand side of the path.
-    #
-    # Examples:
-    #
-    #   'a/b/c/d/file.txt'.pathmap("%2d")   => 'a/b'
-    #   'a/b/c/d/file.txt'.pathmap("%-2d")  => 'c/d'
-    #
-    # Also the %d, %p, %f, %n, %x, and %X operators can take a
-    # pattern/replacement argument to perform simple string substitutions on a
-    # particular part of the path.  The pattern and replacement are separated
-    # by a comma and are enclosed by curly braces.  The replacement spec comes
-    # after the % character but before the operator letter.  (e.g.
-    # "%{old,new}d").  Multiple replacement specs should be separated by
-    # semi-colons (e.g. "%{old,new;src,bin}d").
-    #
-    # Regular expressions may be used for the pattern, and back refs may be
-    # used in the replacement text.  Curly braces, commas and semi-colons are
-    # excluded from both the pattern and replacement text (let's keep parsing
-    # reasonable).
-    #
-    # For example:
-    #
-    #    "src/org/onestepback/proj/A.java".pathmap("%{^src,bin}X.class")
-    #
-    # returns:
-    #
-    #    "bin/org/onestepback/proj/A.class"
-    #
-    # If the replacement text is '*', then a block may be provided to perform
-    # some arbitrary calculation for the replacement.
-    #
-    # For example:
-    #
-    #   "/path/to/file.TXT".pathmap("%X%{.*,*}x") { |ext|
-    #      ext.downcase
-    #   }
-    #
-    # Returns:
-    #
-    #  "/path/to/file.txt"
-    #
-    def pathmap(spec=nil, &block)
-      return self if spec.nil?
-      result = ''
-      spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
-        case frag
-        when '%f'
-          result << File.basename(self)
-        when '%n'
-          result << File.basename(self).ext
-        when '%d'
-          result << File.dirname(self)
-        when '%x'
-          result << File.extname(self)
-        when '%X'
-          result << self.ext
-        when '%p'
-          result << self
-        when '%s'
-          result << (File::ALT_SEPARATOR || File::SEPARATOR)
-        when '%-'
-          # do nothing
-        when '%%'
-          result << "%"
-        when /%(-?\d+)d/
-          result << pathmap_partial($1.to_i)
-        when /^%\{([^}]*)\}(\d*[dpfnxX])/
-          patterns, operator = $1, $2
-          result << pathmap('%' + operator).pathmap_replace(patterns, &block)
-        when /^%/
-          fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
-        else
-          result << frag
-        end
-      end
-      result
-    end
-  end
-end # class String
-

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/lib/rake/ext/time.rb

@@ -1,14 +0,0 @@
-# ###########################################################################
-# Extensions to time to allow comparisons with an early time class.
-#
-class Time
-  alias rake_original_time_compare :<=>
-  def <=>(other)
-    if Rake::EarlyTime === other
-      - other.<=>(self)
-    else
-      rake_original_time_compare(other)
-    end
-  end
-end # class Time
-

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/lib/rake/file_creation_task.rb

@@ -1,24 +0,0 @@
-require 'rake/file_task'
-require 'rake/early_time'
-
-module Rake
-
-  # A FileCreationTask is a file task that when used as a dependency will be
-  # needed if and only if the file has not been created.  Once created, it is
-  # not re-triggered if any of its dependencies are newer, nor does trigger
-  # any rebuilds of tasks that depend on it whenever it is updated.
-  #
-  class FileCreationTask < FileTask
-    # Is this file task needed?  Yes if it doesn't exist.
-    def needed?
-      ! File.exist?(name)
-    end
-
-    # Time stamp for file creation task.  This time stamp is earlier
-    # than any other time stamp.
-    def timestamp
-      Rake::EARLY
-    end
-  end
-
-end

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/lib/rake/file_list.rb

@@ -1,403 +0,0 @@
-require 'rake/cloneable'
-require 'rake/file_utils_ext'
-require 'rake/pathmap'
-
-######################################################################
-module Rake
-
-  # #########################################################################
-  # A FileList is essentially an array with a few helper methods defined to
-  # make file manipulation a bit easier.
-  #
-  # FileLists are lazy.  When given a list of glob patterns for possible files
-  # to be included in the file list, instead of searching the file structures
-  # to find the files, a FileList holds the pattern for latter use.
-  #
-  # This allows us to define a number of FileList to match any number of
-  # files, but only search out the actual files when then FileList itself is
-  # actually used.  The key is that the first time an element of the
-  # FileList/Array is requested, the pending patterns are resolved into a real
-  # list of file names.
-  #
-  class FileList
-
-    include Cloneable
-
-    # == Method Delegation
-    #
-    # The lazy evaluation magic of FileLists happens by implementing all the
-    # array specific methods to call +resolve+ before delegating the heavy
-    # lifting to an embedded array object (@items).
-    #
-    # In addition, there are two kinds of delegation calls.  The regular kind
-    # delegates to the @items array and returns the result directly.  Well,
-    # almost directly.  It checks if the returned value is the @items object
-    # itself, and if so will return the FileList object instead.
-    #
-    # The second kind of delegation call is used in methods that normally
-    # return a new Array object.  We want to capture the return value of these
-    # methods and wrap them in a new FileList object.  We enumerate these
-    # methods in the +SPECIAL_RETURN+ list below.
-
-    # List of array methods (that are not in +Object+) that need to be
-    # delegated.
-    ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map { |n| n.to_s }
-
-    # List of additional methods that must be delegated.
-    MUST_DEFINE = %w[to_a inspect <=>]
-
-    # List of methods that should not be delegated here (we define special
-    # versions of them explicitly below).
-    MUST_NOT_DEFINE = %w[to_a to_ary partition *]
-
-    # List of delegated methods that return new array values which need
-    # wrapping.
-    SPECIAL_RETURN = %w[
-      map collect sort sort_by select find_all reject grep
-      compact flatten uniq values_at
-      + - & |
-    ]
-
-    DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).collect{ |s| s.to_s }.sort.uniq
-
-    # Now do the delegation.
-    DELEGATING_METHODS.each_with_index do |sym, i|
-      if SPECIAL_RETURN.include?(sym)
-        ln = __LINE__+1
-        class_eval %{
-          def #{sym}(*args, &block)
-            resolve
-            result = @items.send(:#{sym}, *args, &block)
-            FileList.new.import(result)
-          end
-        }, __FILE__, ln
-      else
-        ln = __LINE__+1
-        class_eval %{
-          def #{sym}(*args, &block)
-            resolve
-            result = @items.send(:#{sym}, *args, &block)
-            result.object_id == @items.object_id ? self : result
-          end
-        }, __FILE__, ln
-      end
-    end
-
-    # Create a file list from the globbable patterns given.  If you wish to
-    # perform multiple includes or excludes at object build time, use the
-    # "yield self" pattern.
-    #
-    # Example:
-    #   file_list = FileList.new('lib/**/*.rb', 'test/test*.rb')
-    #
-    #   pkg_files = FileList.new('lib/**/*') do |fl|
-    #     fl.exclude(/\bCVS\b/)
-    #   end
-    #
-    def initialize(*patterns)
-      @pending_add = []
-      @pending = false
-      @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
-      @exclude_procs = DEFAULT_IGNORE_PROCS.dup
-      @items = []
-      patterns.each { |pattern| include(pattern) }
-      yield self if block_given?
-    end
-
-    # Add file names defined by glob patterns to the file list.  If an array
-    # is given, add each element of the array.
-    #
-    # Example:
-    #   file_list.include("*.java", "*.cfg")
-    #   file_list.include %w( math.c lib.h *.o )
-    #
-    def include(*filenames)
-      # TODO: check for pending
-      filenames.each do |fn|
-        if fn.respond_to? :to_ary
-          include(*fn.to_ary)
-        else
-          @pending_add << fn
-        end
-      end
-      @pending = true
-      self
-    end
-    alias :add :include
-
-    # Register a list of file name patterns that should be excluded from the
-    # list.  Patterns may be regular expressions, glob patterns or regular
-    # strings.  In addition, a block given to exclude will remove entries that
-    # return true when given to the block.
-    #
-    # Note that glob patterns are expanded against the file system. If a file
-    # is explicitly added to a file list, but does not exist in the file
-    # system, then an glob pattern in the exclude list will not exclude the
-    # file.
-    #
-    # Examples:
-    #   FileList['a.c', 'b.c'].exclude("a.c") => ['b.c']
-    #   FileList['a.c', 'b.c'].exclude(/^a/)  => ['b.c']
-    #
-    # If "a.c" is a file, then ...
-    #   FileList['a.c', 'b.c'].exclude("a.*") => ['b.c']
-    #
-    # If "a.c" is not a file, then ...
-    #   FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
-    #
-    def exclude(*patterns, &block)
-      patterns.each do |pat|
-        @exclude_patterns << pat
-      end
-      if block_given?
-        @exclude_procs << block
-      end
-      resolve_exclude if ! @pending
-      self
-    end
-
-
-    # Clear all the exclude patterns so that we exclude nothing.
-    def clear_exclude
-      @exclude_patterns = []
-      @exclude_procs = []
-      self
-    end
-
-    # Define equality.
-    def ==(array)
-      to_ary == array
-    end
-
-    # Return the internal array object.
-    def to_a
-      resolve
-      @items
-    end
-
-    # Return the internal array object.
-    def to_ary
-      to_a
-    end
-
-    # Lie about our class.
-    def is_a?(klass)
-      klass == Array || super(klass)
-    end
-    alias kind_of? is_a?
-
-    # Redefine * to return either a string or a new file list.
-    def *(other)
-      result = @items * other
-      case result
-      when Array
-        FileList.new.import(result)
-      else
-        result
-      end
-    end
-
-    # Resolve all the pending adds now.
-    def resolve
-      if @pending
-        @pending = false
-        @pending_add.each do |fn| resolve_add(fn) end
-        @pending_add = []
-        resolve_exclude
-      end
-      self
-    end
-
-    def resolve_add(fn)
-      case fn
-      when %r{[*?\[\{]}
-        add_matching(fn)
-      else
-        self << fn
-      end
-    end
-    private :resolve_add
-
-    def resolve_exclude
-      reject! { |fn| exclude?(fn) }
-      self
-    end
-    private :resolve_exclude
-
-    # Return a new FileList with the results of running +sub+ against each
-    # element of the original list.
-    #
-    # Example:
-    #   FileList['a.c', 'b.c'].sub(/\.c$/, '.o')  => ['a.o', 'b.o']
-    #
-    def sub(pat, rep)
-      inject(FileList.new) { |res, fn| res << fn.sub(pat,rep) }
-    end
-
-    # Return a new FileList with the results of running +gsub+ against each
-    # element of the original list.
-    #
-    # Example:
-    #   FileList['lib/test/file', 'x/y'].gsub(/\//, "\\")
-    #      => ['lib\\test\\file', 'x\\y']
-    #
-    def gsub(pat, rep)
-      inject(FileList.new) { |res, fn| res << fn.gsub(pat,rep) }
-    end
-
-    # Same as +sub+ except that the original file list is modified.
-    def sub!(pat, rep)
-      each_with_index { |fn, i| self[i] = fn.sub(pat,rep) }
-      self
-    end
-
-    # Same as +gsub+ except that the original file list is modified.
-    def gsub!(pat, rep)
-      each_with_index { |fn, i| self[i] = fn.gsub(pat,rep) }
-      self
-    end
-
-    # Apply the pathmap spec to each of the included file names, returning a
-    # new file list with the modified paths.  (See String#pathmap for
-    # details.)
-    def pathmap(spec=nil)
-      collect { |fn| fn.pathmap(spec) }
-    end
-
-    # Return a new FileList with <tt>String#ext</tt> method applied to
-    # each member of the array.
-    #
-    # This method is a shortcut for:
-    #
-    #    array.collect { |item| item.ext(newext) }
-    #
-    # +ext+ is a user added method for the Array class.
-    def ext(newext='')
-      collect { |fn| fn.ext(newext) }
-    end
-
-
-    # Grep each of the files in the filelist using the given pattern. If a
-    # block is given, call the block on each matching line, passing the file
-    # name, line number, and the matching line of text.  If no block is given,
-    # a standard emacs style file:linenumber:line message will be printed to
-    # standard out.  Returns the number of matched items.
-    def egrep(pattern, *options)
-      matched = 0
-      each do |fn|
-        begin
-          open(fn, "rb", *options) do |inf|
-            count = 0
-            inf.each do |line|
-              count += 1
-              if pattern.match(line)
-                matched += 1
-                if block_given?
-                  yield fn, count, line
-                else
-                  puts "#{fn}:#{count}:#{line}"
-                end
-              end
-            end
-          end
-        rescue StandardError => ex
-          $stderr.puts "Error while processing '#{fn}': #{ex}"
-        end
-      end
-      matched
-    end
-
-    # Return a new file list that only contains file names from the current
-    # file list that exist on the file system.
-    def existing
-      select { |fn| File.exist?(fn) }
-    end
-
-    # Modify the current file list so that it contains only file name that
-    # exist on the file system.
-    def existing!
-      resolve
-      @items = @items.select { |fn| File.exist?(fn) }
-      self
-    end
-
-    # FileList version of partition.  Needed because the nested arrays should
-    # be FileLists in this version.
-    def partition(&block)       # :nodoc:
-      resolve
-      result = @items.partition(&block)
-      [
-        FileList.new.import(result[0]),
-        FileList.new.import(result[1]),
-      ]
-    end
-
-    # Convert a FileList to a string by joining all elements with a space.
-    def to_s
-      resolve
-      self.join(' ')
-    end
-
-    # Add matching glob patterns.
-    def add_matching(pattern)
-      Dir[pattern].each do |fn|
-        self << fn unless exclude?(fn)
-      end
-    end
-    private :add_matching
-
-    # Should the given file name be excluded?
-    def exclude?(fn)
-      return true if @exclude_patterns.any? do |pat|
-        case pat
-        when Regexp
-          fn =~ pat
-        when /[*?]/
-          File.fnmatch?(pat, fn, File::FNM_PATHNAME)
-        else
-          fn == pat
-        end
-      end
-      @exclude_procs.any? { |p| p.call(fn) }
-    end
-
-    DEFAULT_IGNORE_PATTERNS = [
-      /(^|[\/\\])CVS([\/\\]|$)/,
-      /(^|[\/\\])\.svn([\/\\]|$)/,
-      /\.bak$/,
-      /~$/
-    ]
-    DEFAULT_IGNORE_PROCS = [
-      proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) }
-    ]
-
-    def import(array)
-      @items = array
-      self
-    end
-
-    class << self
-      # Create a new file list including the files listed. Similar to:
-      #
-      #   FileList.new(*args)
-      def [](*args)
-        new(*args)
-      end
-    end
-  end
-end
-
-module Rake
-  class << self
-
-    # Yield each file or directory component.
-    def each_dir_parent(dir)    # :nodoc:
-      old_length = nil
-      while dir != '.' && dir.length != old_length
-        yield(dir)
-        old_length = dir.length
-        dir = File.dirname(dir)
-      end
-    end
-  end
-end # module Rake

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/lib/rake/file_task.rb

@@ -1,47 +0,0 @@
-require 'rake/task.rb'
-require 'rake/early_time'
-
-module Rake
-  # #########################################################################
-  # A FileTask is a task that includes time based dependencies.  If any of a
-  # FileTask's prerequisites have a timestamp that is later than the file
-  # represented by this task, then the file must be rebuilt (using the
-  # supplied actions).
-  #
-  class FileTask < Task
-
-    # Is this file task needed?  Yes if it doesn't exist, or if its time stamp
-    # is out of date.
-    def needed?
-      ! File.exist?(name) || out_of_date?(timestamp)
-    end
-
-    # Time stamp for file task.
-    def timestamp
-      if File.exist?(name)
-        File.mtime(name.to_s)
-      else
-        Rake::EARLY
-      end
-    end
-
-    private
-
-    # Are there any prerequisites with a later time than the given time stamp?
-    def out_of_date?(stamp)
-      @prerequisites.any? { |n| application[n, @scope].timestamp > stamp}
-    end
-
-    # ----------------------------------------------------------------
-    # Task class methods.
-    #
-    class << self
-      # Apply the scope to the task name according to the rules for this kind
-      # of task.  File based tasks ignore the scope when creating the name.
-      def scope_name(scope, task_name)
-        task_name
-      end
-    end
-  end
-end
-