plyom_user 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/packagetask.rb

@@ -0,0 +1,190 @@
+# Define a package task library to aid in the definition of
+# redistributable package files.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Rake
+
+  # Create a packaging task that will package the project into
+  # distributable files (e.g zip archive or tar files).
+  #
+  # The PackageTask will create the following targets:
+  #
+  # [<b>:package</b>]
+  #   Create all the requested package files.
+  #
+  # [<b>:clobber_package</b>]
+  #   Delete all the package files.  This target is automatically
+  #   added to the main clobber target.
+  #
+  # [<b>:repackage</b>]
+  #   Rebuild the package files from scratch, even if they are not out
+  #   of date.
+  #
+  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tgz"</b>]
+  #   Create a gzipped tar package (if <em>need_tar</em> is true).
+  #
+  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tar.gz"</b>]
+  #   Create a gzipped tar package (if <em>need_tar_gz</em> is true).
+  #
+  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tar.bz2"</b>]
+  #   Create a bzip2'd tar package (if <em>need_tar_bz2</em> is true).
+  #
+  # [<b>"<em>package_dir</em>/<em>name</em>-<em>version</em>.zip"</b>]
+  #   Create a zip package archive (if <em>need_zip</em> is true).
+  #
+  # Example:
+  #
+  #   Rake::PackageTask.new("rake", "1.2.3") do |p|
+  #     p.need_tar = true
+  #     p.package_files.include("lib/**/*.rb")
+  #   end
+  #
+  class PackageTask < TaskLib
+    # Name of the package (from the GEM Spec).
+    attr_accessor :name
+
+    # Version of the package (e.g. '1.3.2').
+    attr_accessor :version
+
+    # Directory used to store the package files (default is 'pkg').
+    attr_accessor :package_dir
+
+    # True if a gzipped tar file (tgz) should be produced (default is
+    # false).
+    attr_accessor :need_tar
+
+    # True if a gzipped tar file (tar.gz) should be produced (default
+    # is false).
+    attr_accessor :need_tar_gz
+
+    # True if a bzip2'd tar file (tar.bz2) should be produced (default
+    # is false).
+    attr_accessor :need_tar_bz2
+
+    # True if a zip file should be produced (default is false)
+    attr_accessor :need_zip
+
+    # List of files to be included in the package.
+    attr_accessor :package_files
+
+    # Tar command for gzipped or bzip2ed archives.  The default is 'tar'.
+    attr_accessor :tar_command
+
+    # Zip command for zipped archives.  The default is 'zip'.
+    attr_accessor :zip_command
+
+    # Create a Package Task with the given name and version.  Use +:noversion+
+    # as the version to build a package without a version or to provide a
+    # fully-versioned package name.
+
+    def initialize(name=nil, version=nil)
+      init(name, version)
+      yield self if block_given?
+      define unless name.nil?
+    end
+
+    # Initialization that bypasses the "yield self" and "define" step.
+    def init(name, version)
+      @name = name
+      @version = version
+      @package_files = Rake::FileList.new
+      @package_dir = 'pkg'
+      @need_tar = false
+      @need_tar_gz = false
+      @need_tar_bz2 = false
+      @need_zip = false
+      @tar_command = 'tar'
+      @zip_command = 'zip'
+    end
+
+    # Create the tasks defined by this task library.
+    def define
+      fail "Version required (or :noversion)" if @version.nil?
+      @version = nil if :noversion == @version
+
+      desc "Build all the packages"
+      task :package
+
+      desc "Force a rebuild of the package files"
+      task :repackage => [:clobber_package, :package]
+
+      desc "Remove package products"
+      task :clobber_package do
+        rm_r package_dir rescue nil
+      end
+
+      task :clobber => [:clobber_package]
+
+      [
+        [need_tar, tgz_file, "z"],
+        [need_tar_gz, tar_gz_file, "z"],
+        [need_tar_bz2, tar_bz2_file, "j"]
+      ].each do |(need, file, flag)|
+        if need
+          task :package => ["#{package_dir}/#{file}"]
+          file "#{package_dir}/#{file}" =>
+            [package_dir_path] + package_files do
+            chdir(package_dir) do
+              sh %{#{@tar_command} #{flag}cvf #{file} #{package_name}}
+            end
+          end
+        end
+      end
+
+      if need_zip
+        task :package => ["#{package_dir}/#{zip_file}"]
+        file "#{package_dir}/#{zip_file}" =>
+          [package_dir_path] + package_files do
+          chdir(package_dir) do
+            sh %{#{@zip_command} -r #{zip_file} #{package_name}}
+          end
+        end
+      end
+
+      directory package_dir
+
+      file package_dir_path => @package_files do
+        mkdir_p package_dir rescue nil
+        @package_files.each do |fn|
+          f = File.join(package_dir_path, fn)
+          fdir = File.dirname(f)
+          mkdir_p(fdir) unless File.exist?(fdir)
+          if File.directory?(fn)
+            mkdir_p(f)
+          else
+            rm_f f
+            safe_ln(fn, f)
+          end
+        end
+      end
+      self
+    end
+
+    def package_name
+      @version ? "#{@name}-#{@version}" : @name
+    end
+
+    def package_dir_path
+      "#{package_dir}/#{package_name}"
+    end
+
+    def tgz_file
+      "#{package_name}.tgz"
+    end
+
+    def tar_gz_file
+      "#{package_name}.tar.gz"
+    end
+
+    def tar_bz2_file
+      "#{package_name}.tar.bz2"
+    end
+
+    def zip_file
+      "#{package_name}.zip"
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/pathmap.rb

@@ -0,0 +1 @@
+require 'rake/ext/string'

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/phony.rb

@@ -0,0 +1,15 @@
+# Defines a :phony task that you can use as a dependency. This allows
+# file-based tasks to use non-file-based tasks as prerequisites
+# without forcing them to rebuild.
+#
+# See FileTask#out_of_date? and Task#timestamp for more info.
+
+require 'rake'
+
+task :phony
+
+Rake::Task[:phony].tap do |task|
+  def task.timestamp # :nodoc:
+    Time.at 0
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/private_reader.rb

@@ -0,0 +1,20 @@
+module Rake
+
+  # Include PrivateReader to use +private_reader+.
+  module PrivateReader           # :nodoc: all
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Declare a list of private accessors
+      def private_reader(*names)
+        attr_reader(*names)
+        private(*names)
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/promise.rb

@@ -0,0 +1,99 @@
+module Rake
+
+  # A Promise object represents a promise to do work (a chore) in the
+  # future. The promise is created with a block and a list of
+  # arguments for the block. Calling value will return the value of
+  # the promised chore.
+  #
+  # Used by ThreadPool.
+  #
+  class Promise               # :nodoc: all
+    NOT_SET = Object.new.freeze # :nodoc:
+
+    attr_accessor :recorder
+
+    # Create a promise to do the chore specified by the block.
+    def initialize(args, &block)
+      @mutex = Mutex.new
+      @result = NOT_SET
+      @error = NOT_SET
+      @args = args
+      @block = block
+    end
+
+    # Return the value of this promise.
+    #
+    # If the promised chore is not yet complete, then do the work
+    # synchronously. We will wait.
+    def value
+      unless complete?
+        stat :sleeping_on, :item_id => object_id
+        @mutex.synchronize do
+          stat :has_lock_on, :item_id => object_id
+          chore
+          stat :releasing_lock_on, :item_id => object_id
+        end
+      end
+      error? ? raise(@error) : @result
+    end
+
+    # If no one else is working this promise, go ahead and do the chore.
+    def work
+      stat :attempting_lock_on, :item_id => object_id
+      if @mutex.try_lock
+        stat :has_lock_on, :item_id => object_id
+        chore
+        stat :releasing_lock_on, :item_id => object_id
+        @mutex.unlock
+      else
+        stat :bailed_on, :item_id => object_id
+      end
+    end
+
+    private
+
+    # Perform the chore promised
+    def chore
+      if complete?
+        stat :found_completed, :item_id => object_id
+        return
+      end
+      stat :will_execute, :item_id => object_id
+      begin
+        @result = @block.call(*@args)
+      rescue Exception => e
+        @error = e
+      end
+      stat :did_execute, :item_id => object_id
+      discard
+    end
+
+    # Do we have a result for the promise
+    def result?
+      ! @result.equal?(NOT_SET)
+    end
+
+    # Did the promise throw an error
+    def error?
+      ! @error.equal?(NOT_SET)
+    end
+
+    # Are we done with the promise
+    def complete?
+      result? || error?
+    end
+
+    # free up these items for the GC
+    def discard
+      @args = nil
+      @block = nil
+    end
+
+    # Record execution statistics if there is a recorder
+    def stat(*args)
+      @recorder.call(*args) if @recorder
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/pseudo_status.rb

@@ -0,0 +1,29 @@
+module Rake
+
+  ####################################################################
+  # Exit status class for times the system just gives us a nil.
+  class PseudoStatus
+    attr_reader :exitstatus
+
+    def initialize(code=0)
+      @exitstatus = code
+    end
+
+    def to_i
+      @exitstatus << 8
+    end
+
+    def >>(n)
+      to_i >> n
+    end
+
+    def stopped?
+      false
+    end
+
+    def exited?
+      true
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/rake_module.rb

@@ -0,0 +1,37 @@
+require 'rake/application'
+
+module Rake
+
+  # Rake module singleton methods.
+  #
+  class << self
+    # Current Rake Application
+    def application
+      @application ||= Rake::Application.new
+    end
+
+    # Set the current Rake application object.
+    def application=(app)
+      @application = app
+    end
+
+    # Return the original directory where the Rake application was started.
+    def original_dir
+      application.original_dir
+    end
+
+    # Load a rakefile.
+    def load_rakefile(path)
+      load(path)
+    end
+
+    # Add files to the rakelib list
+    def add_rakelib(*files)
+      application.options.rakelib ||= []
+      files.each do |file|
+        application.options.rakelib << file
+      end
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/rake_test_loader.rb

@@ -0,0 +1,22 @@
+require 'rake'
+
+# Load the test files from the command line.
+argv = ARGV.select do |argument|
+  case argument
+  when /^-/ then
+    argument
+  when /\*/ then
+    FileList[argument].to_a.each do |file|
+      require File.expand_path file
+    end
+
+    false
+  else
+    require File.expand_path argument
+
+    false
+  end
+end
+
+ARGV.replace argv
+

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/rdoctask.rb

@@ -0,0 +1,2 @@
+fail "ERROR: 'rake/rdoctask' is obsolete and no longer supported. " +
+  "Use 'rdoc/task' (available in RDoc 2.4.2+) instead."

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/ruby182_test_unit_fix.rb

@@ -0,0 +1,27 @@
+# Local Rake override to fix bug in Ruby 0.8.2
+module Test                     # :nodoc:
+  # Local Rake override to fix bug in Ruby 0.8.2
+  module Unit                   # :nodoc:
+    # Local Rake override to fix bug in Ruby 0.8.2
+    module Collector            # :nodoc:
+      # Local Rake override to fix bug in Ruby 0.8.2
+      class Dir                 # :nodoc:
+        undef collect_file
+        def collect_file(name, suites, already_gathered) # :nodoc:
+          dir = File.dirname(File.expand_path(name))
+          $:.unshift(dir) unless $:.first == dir
+          if @req
+            @req.require(name)
+          else
+            require(name)
+          end
+          find_test_cases(already_gathered).each do |t|
+            add_suite(suites, t.suite)
+          end
+        ensure
+          $:.delete_at $:.rindex(dir)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/rule_recursion_overflow_error.rb

@@ -0,0 +1,20 @@
+
+module Rake
+
+  # Error indicating a recursion overflow error in task selection.
+  class RuleRecursionOverflowError < StandardError
+    def initialize(*args)
+      super
+      @targets = []
+    end
+
+    def add_target(target)
+      @targets << target
+    end
+
+    def message
+      super + ": [" + @targets.reverse.join(' => ') + "]"
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/runtest.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'test/unit/assertions'
+require 'rake/file_list'
+
+module Rake
+  include Test::Unit::Assertions
+
+  def run_tests(pattern='test/test*.rb', log_enabled=false)
+    FileList.glob(pattern).each do |fn|
+      $stderr.puts fn if log_enabled
+      begin
+        require fn
+      rescue Exception => ex
+        $stderr.puts "Error in #{fn}: #{ex.message}"
+        $stderr.puts ex.backtrace
+        assert false
+      end
+    end
+  end
+
+  extend self
+end

data/vendor/bundle/ruby/2.0.0/gems/rake-10.1.1/lib/rake/scope.rb

@@ -0,0 +1,42 @@
+module Rake
+  class Scope < LinkedList
+
+    # Path for the scope.
+    def path
+      map { |item| item.to_s }.reverse.join(":")
+    end
+
+    # Path for the scope + the named path.
+    def path_with_task_name(task_name)
+      "#{path}:#{task_name}"
+    end
+
+    # Trim +n+ innermost scope levels from the scope. In no case will
+    # this trim beyond the toplevel scope.
+    def trim(n)
+      result = self
+      while n > 0 && ! result.empty?
+        result = result.tail
+        n -= 1
+      end
+      result
+    end
+
+    # Scope lists always end with an EmptyScope object. See Null
+    # Object Pattern)
+    class EmptyScope < EmptyLinkedList
+      @parent = Scope
+
+      def path
+        ""
+      end
+
+      def path_with_task_name(task_name)
+        task_name
+      end
+    end
+
+    # Singleton null object for an empty scope.
+    EMPTY = EmptyScope.new
+  end
+end