vergissberlin 0.0.5 → 0.0.7

data/vendor/bundle/gems/rake-10.0.4/lib/rake/backtrace.rb

@@ -0,0 +1,19 @@
+module Rake
+  module Backtrace
+    SUPPRESSED_PATHS =
+      RbConfig::CONFIG.values_at(*RbConfig::CONFIG.
+                                 keys.grep(/(prefix|libdir)/)).uniq + [
+        File.join(File.dirname(__FILE__), ".."),
+      ].map { |f| Regexp.quote(File.expand_path(f)) }
+    SUPPRESSED_PATHS.map! { |s| s.gsub("\\", "/") }
+    SUPPRESSED_PATHS.reject! { |s| s.nil? || s =~ /^ *$/ }
+
+    SUPPRESS_PATTERN = %r!(\A#{SUPPRESSED_PATHS.join('|')}|bin/rake:\d+)!i
+
+    def self.collapse(backtrace)
+      pattern = Rake.application.options.suppress_backtrace_pattern ||
+                SUPPRESS_PATTERN
+      backtrace.reject { |elem| elem =~ pattern }
+    end
+  end
+end

data/vendor/bundle/gems/rake-10.0.4/lib/rake/clean.rb

@@ -0,0 +1,32 @@
+# The 'rake/clean' file defines two file lists (CLEAN and CLOBBER) and
+# two rake tasks (:clean and :clobber).
+#
+# [:clean] Clean up the project by deleting scratch files and backup
+#          files.  Add files to the CLEAN file list to have the :clean
+#          target handle them.
+#
+# [:clobber] Clobber all generated and non-source files in a project.
+#            The task depends on :clean, so all the clean files will
+#            be deleted as well as files in the CLOBBER file list.
+#            The intent of this task is to return a project to its
+#            pristine, just unpacked state.
+
+require 'rake'
+
+# :stopdoc:
+CLEAN = Rake::FileList["**/*~", "**/*.bak", "**/core"]
+CLEAN.clear_exclude.exclude { |fn|
+  fn.pathmap("%f").downcase == 'core' && File.directory?(fn)
+}
+
+desc "Remove any temporary products."
+task :clean do
+  CLEAN.each { |fn| rm_r fn rescue nil }
+end
+
+CLOBBER = Rake::FileList.new
+
+desc "Remove any generated file."
+task :clobber => [:clean] do
+  CLOBBER.each { |fn| rm_r fn rescue nil }
+end

data/vendor/bundle/gems/rake-10.0.4/lib/rake/cloneable.rb

@@ -0,0 +1,16 @@
+module Rake
+  # ##########################################################################
+  # Mixin for creating easily cloned objects.
+  #
+  module Cloneable
+    # The hook that invoked by 'clone' and 'dup' methods.
+    def initialize_copy(source)
+      super
+      source.instance_variables.each do |var|
+        src_value  = source.instance_variable_get(var)
+        value = src_value.clone rescue src_value
+        instance_variable_set(var, value)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rake-10.0.4/lib/rake/contrib/compositepublisher.rb

@@ -0,0 +1,21 @@
+module Rake
+
+  # Manage several publishers as a single entity.
+  class CompositePublisher
+    def initialize
+      @publishers = []
+    end
+
+    # Add a publisher to the composite.
+    def add(pub)
+      @publishers << pub
+    end
+
+    # Upload all the individual publishers.
+    def upload
+      @publishers.each { |p| p.upload }
+    end
+  end
+
+end
+

data/vendor/bundle/gems/rake-10.0.4/lib/rake/contrib/ftptools.rb

@@ -0,0 +1,151 @@
+# = Tools for FTP uploading.
+#
+# This file is still under development and is not released for general
+# use.
+
+require 'date'
+require 'net/ftp'
+require 'rake/file_list'
+
+module Rake # :nodoc:
+
+  ####################################################################
+  # <b>Note:</b> <em> Not released for general use.</em>
+  class FtpFile
+    attr_reader :name, :size, :owner, :group, :time
+
+    def self.date
+      @date_class ||= Date
+    end
+
+    def self.time
+      @time_class ||= Time
+    end
+
+    def initialize(path, entry)
+      @path = path
+      @mode, _, @owner, @group, size, d1, d2, d3, @name = entry.split(' ')
+      @size = size.to_i
+      @time = determine_time(d1, d2, d3)
+    end
+
+    def path
+      File.join(@path, @name)
+    end
+
+    def directory?
+      @mode[0] == ?d
+    end
+
+    def mode
+      parse_mode(@mode)
+    end
+
+    def symlink?
+      @mode[0] == ?l
+    end
+
+    private # --------------------------------------------------------
+
+    def parse_mode(m)
+      result = 0
+      (1..9).each do |i|
+        result = 2*result + ((m[i]==?-) ? 0 : 1)
+      end
+      result
+    end
+
+    def determine_time(d1, d2, d3)
+      now = self.class.time.now
+      if /:/ =~ d3
+        result = Time.parse("#{d1} #{d2} #{now.year} #{d3}")
+        if result > now
+          result = Time.parse("#{d1} #{d2} #{now.year-1} #{d3}")
+        end
+      else
+        result = Time.parse("#{d1} #{d2} #{d3}")
+      end
+      result
+#       elements = ParseDate.parsedate("#{d1} #{d2} #{d3}")
+#       if elements[0].nil?
+#         today = self.class.date.today
+#         if elements[1] > today.month
+#           elements[0] = today.year - 1
+#         else
+#           elements[0] = today.year
+#         end
+#       end
+#       elements = elements.collect { |el| el.nil? ? 0 : el }
+#       Time.mktime(*elements[0,7])
+    end
+  end
+
+  ####################################################################
+  # Manage the uploading of files to an FTP account.
+  class FtpUploader
+
+    # Log uploads to standard output when true.
+    attr_accessor :verbose
+
+    class << FtpUploader
+      # Create an uploader and pass it to the given block as +up+.
+      # When the block is complete, close the uploader.
+      def connect(path, host, account, password)
+        up = self.new(path, host, account, password)
+        begin
+          yield(up)
+        ensure
+          up.close
+        end
+      end
+    end
+
+    # Create an FTP uploader targeting the directory +path+ on +host+
+    # using the given account and password.  +path+ will be the root
+    # path of the uploader.
+    def initialize(path, host, account, password)
+      @created = Hash.new
+      @path = path
+      @ftp = Net::FTP.new(host, account, password)
+      makedirs(@path)
+      @ftp.chdir(@path)
+    end
+
+    # Create the directory +path+ in the uploader root path.
+    def makedirs(path)
+      route = []
+      File.split(path).each do |dir|
+        route << dir
+        current_dir = File.join(route)
+        if @created[current_dir].nil?
+          @created[current_dir] = true
+          $stderr.puts "Creating Directory  #{current_dir}" if @verbose
+          @ftp.mkdir(current_dir) rescue nil
+        end
+      end
+    end
+
+    # Upload all files matching +wildcard+ to the uploader's root
+    # path.
+    def upload_files(wildcard)
+      FileList.glob(wildcard).each do |fn|
+        upload(fn)
+      end
+    end
+
+    # Close the uploader.
+    def close
+      @ftp.close
+    end
+
+    private # --------------------------------------------------------
+
+    # Upload a single file to the uploader's root path.
+    def upload(file)
+      $stderr.puts "Uploading #{file}" if @verbose
+      dir = File.dirname(file)
+      makedirs(dir)
+      @ftp.putbinaryfile(file, file) unless File.directory?(file)
+    end
+  end
+end

data/vendor/bundle/gems/rake-10.0.4/lib/rake/contrib/publisher.rb

@@ -0,0 +1,73 @@
+# Copyright 2003-2010 by Jim Weirich (jim.weirich@gmail.com)
+# All rights reserved.
+
+# :stopdoc:
+
+# Configuration information about an upload host system.
+# name   :: Name of host system.
+# webdir :: Base directory for the web information for the
+#           application.  The application name (APP) is appended to
+#           this directory before using.
+# pkgdir :: Directory on the host system where packages can be
+#           placed.
+HostInfo = Struct.new(:name, :webdir, :pkgdir)
+
+# :startdoc:
+
+# Manage several publishers as a single entity.
+class CompositePublisher
+  def initialize
+    @publishers = []
+  end
+
+  # Add a publisher to the composite.
+  def add(pub)
+    @publishers << pub
+  end
+
+  # Upload all the individual publishers.
+  def upload
+    @publishers.each { |p| p.upload }
+  end
+end
+
+# Publish an entire directory to an existing remote directory using
+# SSH.
+class SshDirPublisher
+  def initialize(host, remote_dir, local_dir)
+    @host = host
+    @remote_dir = remote_dir
+    @local_dir = local_dir
+  end
+
+  def upload
+    run %{scp -rq #{@local_dir}/* #{@host}:#{@remote_dir}}
+  end
+end
+
+# Publish an entire directory to a fresh remote directory using SSH.
+class SshFreshDirPublisher < SshDirPublisher
+  def upload
+    run %{ssh #{@host} rm -rf #{@remote_dir}} rescue nil
+    run %{ssh #{@host} mkdir #{@remote_dir}}
+    super
+  end
+end
+
+# Publish a list of files to an existing remote directory.
+class SshFilePublisher
+  # Create a publisher using the give host information.
+  def initialize(host, remote_dir, local_dir, *files)
+    @host = host
+    @remote_dir = remote_dir
+    @local_dir = local_dir
+    @files = files
+  end
+
+  # Upload the local directory to the remote directory.
+  def upload
+    @files.each do |fn|
+      run %{scp -q #{@local_dir}/#{fn} #{@host}:#{@remote_dir}}
+    end
+  end
+end

data/vendor/bundle/gems/rake-10.0.4/lib/rake/contrib/rubyforgepublisher.rb

@@ -0,0 +1,16 @@
+require 'rake/contrib/sshpublisher'
+
+module Rake
+
+  class RubyForgePublisher < SshDirPublisher
+    attr_reader :project, :proj_id, :user
+
+    def initialize(projname, user)
+      super(
+        "#{user}@rubyforge.org",
+        "/var/www/gforge-projects/#{projname}",
+        "html")
+    end
+  end
+
+end

data/vendor/bundle/gems/rake-10.0.4/lib/rake/contrib/sshpublisher.rb

@@ -0,0 +1,50 @@
+require 'rake/dsl_definition'
+require 'rake/contrib/compositepublisher'
+
+module Rake
+
+  # Publish an entire directory to an existing remote directory using
+  # SSH.
+  class SshDirPublisher
+    include Rake::DSL
+
+    def initialize(host, remote_dir, local_dir)
+      @host = host
+      @remote_dir = remote_dir
+      @local_dir = local_dir
+    end
+
+    def upload
+      sh %{scp -rq #{@local_dir}/* #{@host}:#{@remote_dir}}
+    end
+  end
+
+  # Publish an entire directory to a fresh remote directory using SSH.
+  class SshFreshDirPublisher < SshDirPublisher
+    def upload
+      sh %{ssh #{@host} rm -rf #{@remote_dir}} rescue nil
+      sh %{ssh #{@host} mkdir #{@remote_dir}}
+      super
+    end
+  end
+
+  # Publish a list of files to an existing remote directory.
+  class SshFilePublisher
+    include Rake::DSL
+
+    # Create a publisher using the give host information.
+    def initialize(host, remote_dir, local_dir, *files)
+      @host = host
+      @remote_dir = remote_dir
+      @local_dir = local_dir
+      @files = files
+    end
+
+    # Upload the local directory to the remote directory.
+    def upload
+      @files.each do |fn|
+        sh %{scp -q #{@local_dir}/#{fn} #{@host}:#{@remote_dir}}
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rake-10.0.4/lib/rake/contrib/sys.rb

@@ -0,0 +1 @@
+fail "ERROR: 'rake/contrib/sys' is obsolete and no longer supported. Use 'FileUtils' instead."

data/vendor/bundle/gems/rake-10.0.4/lib/rake/default_loader.rb

@@ -0,0 +1,10 @@
+module Rake
+
+  # Default Rakefile loader used by +import+.
+  class DefaultLoader
+    def load(fn)
+      Rake.load_rakefile(File.expand_path(fn))
+    end
+  end
+
+end

data/vendor/bundle/gems/rake-10.0.4/lib/rake/dsl_definition.rb

@@ -0,0 +1,156 @@
+# Rake DSL functions.
+require 'rake/file_utils_ext'
+
+module Rake
+
+  ##
+  # DSL is a module that provides #task, #desc, #namespace, etc.  Use this
+  # when you'd like to use rake outside the top level scope.
+
+  module DSL
+
+    #--
+    # Include the FileUtils file manipulation functions in the top
+    # level module, but mark them private so that they don't
+    # unintentionally define methods on other objects.
+    #++
+
+    include FileUtilsExt
+    private(*FileUtils.instance_methods(false))
+    private(*FileUtilsExt.instance_methods(false))
+
+    private
+
+    # Declare a basic task.
+    #
+    # Example:
+    #   task :clobber => [:clean] do
+    #     rm_rf "html"
+    #   end
+    #
+    def task(*args, &block)
+      Rake::Task.define_task(*args, &block)
+    end
+
+    # Declare a file task.
+    #
+    # Example:
+    #   file "config.cfg" => ["config.template"] do
+    #     open("config.cfg", "w") do |outfile|
+    #       open("config.template") do |infile|
+    #         while line = infile.gets
+    #           outfile.puts line
+    #         end
+    #       end
+    #     end
+    #  end
+    #
+    def file(*args, &block)
+      Rake::FileTask.define_task(*args, &block)
+    end
+
+    # Declare a file creation task.
+    # (Mainly used for the directory command).
+    def file_create(*args, &block)
+      Rake::FileCreationTask.define_task(*args, &block)
+    end
+
+    # Declare a set of files tasks to create the given directories on
+    # demand.
+    #
+    # Example:
+    #   directory "testdata/doc"
+    #
+    def directory(*args, &block)
+      result = file_create(*args, &block)
+      dir, _ = *Rake.application.resolve_args(args)
+      Rake.each_dir_parent(dir) do |d|
+        file_create d do |t|
+          mkdir_p t.name if ! File.exist?(t.name)
+        end
+      end
+      result
+    end
+
+    # Declare a task that performs its prerequisites in
+    # parallel. Multitasks does *not* guarantee that its prerequisites
+    # will execute in any given order (which is obvious when you think
+    # about it)
+    #
+    # Example:
+    #   multitask :deploy => [:deploy_gem, :deploy_rdoc]
+    #
+    def multitask(*args, &block)
+      Rake::MultiTask.define_task(*args, &block)
+    end
+
+    # Create a new rake namespace and use it for evaluating the given
+    # block.  Returns a NameSpace object that can be used to lookup
+    # tasks defined in the namespace.
+    #
+    # E.g.
+    #
+    #   ns = namespace "nested" do
+    #     task :run
+    #   end
+    #   task_run = ns[:run] # find :run in the given namespace.
+    #
+    def namespace(name=nil, &block)
+      name = name.to_s if name.kind_of?(Symbol)
+      name = name.to_str if name.respond_to?(:to_str)
+      unless name.kind_of?(String) || name.nil?
+        raise ArgumentError, "Expected a String or Symbol for a namespace name"
+      end
+      Rake.application.in_namespace(name, &block)
+    end
+
+    # Declare a rule for auto-tasks.
+    #
+    # Example:
+    #  rule '.o' => '.c' do |t|
+    #    sh %{cc -o #{t.name} #{t.source}}
+    #  end
+    #
+    def rule(*args, &block)
+      Rake::Task.create_rule(*args, &block)
+    end
+
+    # Describe the next rake task.
+    #
+    # Example:
+    #   desc "Run the Unit Tests"
+    #   task :test => [:build]
+    #     runtests
+    #   end
+    #
+    def desc(description)
+      Rake.application.last_description = description
+    end
+
+    # Import the partial Rakefiles +fn+.  Imported files are loaded
+    # _after_ the current file is completely loaded.  This allows the
+    # import statement to appear anywhere in the importing file, and yet
+    # allowing the imported files to depend on objects defined in the
+    # importing file.
+    #
+    # A common use of the import statement is to include files
+    # containing dependency declarations.
+    #
+    # See also the --rakelibdir command line option.
+    #
+    # Example:
+    #   import ".depend", "my_rules"
+    #
+    def import(*fns)
+      fns.each do |fn|
+        Rake.application.add_import(fn)
+      end
+    end
+  end
+  extend FileUtilsExt
+end
+
+# Extend the main object with the DSL commands. This allows top-level
+# calls to task, etc. to work from a Rakefile without polluting the
+# object inheritance tree.
+self.extend Rake::DSL