backbone-queryparams-rails 0.0.1 → 0.0.2

data/vendor/bundle/gems/rake-10.0.3/lib/rake/thread_history_display.rb

@@ -1,48 +0,0 @@
-require 'rake/private_reader'
-
-module Rake
-
-  class ThreadHistoryDisplay    # :nodoc: all
-    include Rake::PrivateReader
-
-    private_reader :stats, :items, :threads
-
-    def initialize(stats)
-      @stats   = stats
-      @items   = { :_seq_ =>  1  }
-      @threads = { :_seq_ => "A" }
-    end
-
-    def show
-      puts "Job History:"
-      stats.each do |stat|
-        stat[:data] ||= {}
-        rename(stat, :thread, threads)
-        rename(stat[:data], :item_id, items)
-        rename(stat[:data], :new_thread, threads)
-        rename(stat[:data], :deleted_thread, threads)
-        printf("%8d %2s %-20s %s\n",
-          (stat[:time] * 1_000_000).round,
-          stat[:thread],
-          stat[:event],
-          stat[:data].map { |k,v| "#{k}:#{v}" }.join(" "))
-      end
-    end
-
-    private
-
-    def rename(hash, key, renames)
-      if hash && hash[key]
-        original = hash[key]
-        value = renames[original]
-        unless value
-          value = renames[:_seq_]
-          renames[:_seq_] = renames[:_seq_].succ
-          renames[original] = value
-        end
-        hash[key] = value
-      end
-    end
-  end
-
-end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/thread_pool.rb

@@ -1,155 +0,0 @@
-require 'thread'
-require 'set'
-
-require 'rake/promise'
-
-module Rake
-
-  class ThreadPool              # :nodoc: all
-
-    # Creates a ThreadPool object.
-    # The parameter is the size of the pool.
-    def initialize(thread_count)
-      @max_active_threads = [thread_count, 0].max
-      @threads = Set.new
-      @threads_mon = Monitor.new
-      @queue = Queue.new
-      @join_cond = @threads_mon.new_cond
-
-      @history_start_time = nil
-      @history = []
-      @history_mon = Monitor.new
-      @total_threads_in_play = 0
-    end
-
-    # Creates a future executed by the +ThreadPool+.
-    #
-    # The args are passed to the block when executing (similarly to
-    # <tt>Thread#new</tt>) The return value is an object representing
-    # a future which has been created and added to the queue in the
-    # pool. Sending <tt>#value</tt> to the object will sleep the
-    # current thread until the future is finished and will return the
-    # result (or raise an exception thrown from the future)
-    def future(*args, &block)
-      promise = Promise.new(args, &block)
-      promise.recorder = lambda { |*stats| stat(*stats) }
-
-      @queue.enq promise
-      stat :queued, :item_id => promise.object_id
-      start_thread
-      promise
-    end
-
-    # Waits until the queue of futures is empty and all threads have exited.
-    def join
-      @threads_mon.synchronize do
-        begin
-          stat :joining
-          @join_cond.wait unless @threads.empty?
-          stat :joined
-        rescue Exception => e
-          stat :joined
-          $stderr.puts e
-          $stderr.print "Queue contains #{@queue.size} items. Thread pool contains #{@threads.count} threads\n"
-          $stderr.print "Current Thread #{Thread.current} status = #{Thread.current.status}\n"
-          $stderr.puts e.backtrace.join("\n")
-          @threads.each do |t|
-            $stderr.print "Thread #{t} status = #{t.status}\n"
-            # 1.8 doesn't support Thread#backtrace
-            $stderr.puts t.backtrace.join("\n") if t.respond_to? :backtrace
-          end
-          raise e
-        end
-      end
-    end
-
-    # Enable the gathering of history events.
-    def gather_history          #:nodoc:
-      @history_start_time = Time.now if @history_start_time.nil?
-    end
-
-    # Return a array of history events for the thread pool.
-    #
-    # History gathering must be enabled to be able to see the events
-    # (see #gather_history). Best to call this when the job is
-    # complete (i.e. after ThreadPool#join is called).
-    def history                 # :nodoc:
-      @history_mon.synchronize { @history.dup }.
-        sort_by { |i| i[:time] }.
-        each { |i| i[:time] -= @history_start_time }
-    end
-
-    # Return a hash of always collected statistics for the thread pool.
-    def statistics              #  :nodoc:
-      {
-        :total_threads_in_play => @total_threads_in_play,
-        :max_active_threads => @max_active_threads,
-      }
-    end
-
-    private
-
-    # processes one item on the queue. Returns true if there was an
-    # item to process, false if there was no item
-    def process_queue_item      #:nodoc:
-      return false if @queue.empty?
-
-      # Even though we just asked if the queue was empty, it
-      # still could have had an item which by this statement
-      # is now gone. For this reason we pass true to Queue#deq
-      # because we will sleep indefinitely if it is empty.
-      promise = @queue.deq(true)
-      stat :dequeued, :item_id => promise.object_id
-      promise.work
-      return true
-
-      rescue ThreadError # this means the queue is empty
-      false
-    end
-
-    def start_thread # :nodoc:
-      @threads_mon.synchronize do
-        next unless @threads.count < @max_active_threads
-
-        t = Thread.new do
-          begin
-            while @threads.count <= @max_active_threads
-              break unless process_queue_item
-            end
-          ensure
-            @threads_mon.synchronize do
-              @threads.delete Thread.current
-              stat :ended, :thread_count => @threads.count
-              @join_cond.broadcast if @threads.empty?
-            end
-          end
-        end
-        @threads << t
-        stat :spawned, :new_thread => t.object_id, :thread_count => @threads.count
-        @total_threads_in_play = @threads.count if @threads.count > @total_threads_in_play
-      end
-    end
-
-    def stat(event, data=nil) # :nodoc:
-      return if @history_start_time.nil?
-      info = {
-        :event  => event,
-        :data   => data,
-        :time   => Time.now,
-        :thread => Thread.current.object_id,
-      }
-      @history_mon.synchronize { @history << info }
-    end
-
-    # for testing only
-
-    def __queue__ # :nodoc:
-      @queue
-    end
-
-    def __threads__ # :nodoc:
-      @threads.dup
-    end
-  end
-
-end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/trace_output.rb

@@ -1,19 +0,0 @@
-module Rake
-  module TraceOutput
-
-    # Write trace output to output stream +out+.
-    #
-    # The write is done as a single IO call (to print) to lessen the
-    # chance that the trace output is interrupted by other tasks also
-    # producing output.
-    def trace_on(out, *strings)
-      sep = $\ || "\n"
-      if strings.empty?
-        output = sep
-      else
-        output = strings.map { |s| s.end_with?(sep) ? s : s + sep }.join
-      end
-      out.print(output)
-    end
-  end
-end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/version.rb

@@ -1,13 +0,0 @@
-module Rake
-  VERSION = '10.0.3'
-
-  module Version # :nodoc: all
-    MAJOR, MINOR, BUILD, = Rake::VERSION.split '.'
-
-    NUMBERS = [
-      MAJOR,
-      MINOR,
-      BUILD,
-    ]
-  end
-end

data/vendor/bundle/gems/rake-10.0.3/lib/rake/win32.rb

@@ -1,55 +0,0 @@
-
-module Rake
-  require 'rake/alt_system'
-
-  # Win 32 interface methods for Rake. Windows specific functionality
-  # will be placed here to collect that knowledge in one spot.
-  module Win32
-
-    # Error indicating a problem in locating the home directory on a
-    # Win32 system.
-    class Win32HomeError < RuntimeError
-    end
-
-    class << self
-      # True if running on a windows system.
-      def windows?
-        AltSystem::WINDOWS
-      end
-
-      # Run a command line on windows.
-      def rake_system(*cmd)
-        AltSystem.system(*cmd)
-      end
-
-      # The standard directory containing system wide rake files on
-      # Win 32 systems. Try the following environment variables (in
-      # order):
-      #
-      # * HOME
-      # * HOMEDRIVE + HOMEPATH
-      # * APPDATA
-      # * USERPROFILE
-      #
-      # If the above are not defined, the return nil.
-      def win32_system_dir #:nodoc:
-        win32_shared_path = ENV['HOME']
-        if win32_shared_path.nil? && ENV['HOMEDRIVE'] && ENV['HOMEPATH']
-          win32_shared_path = ENV['HOMEDRIVE'] + ENV['HOMEPATH']
-        end
-
-        win32_shared_path ||= ENV['APPDATA']
-        win32_shared_path ||= ENV['USERPROFILE']
-        raise Win32HomeError, "Unable to determine home path environment variable." if
-          win32_shared_path.nil? or win32_shared_path.empty?
-        normalize(File.join(win32_shared_path, 'Rake'))
-      end
-
-      # Normalize a win32 path so that the slashes are all forward slashes.
-      def normalize(path)
-        path.gsub(/\\/, '/')
-      end
-
-    end
-  end
-end

data/vendor/bundle/gems/rake-10.0.3/test/file_creation.rb

@@ -1,34 +0,0 @@
-module FileCreation
-  OLDFILE = "old"
-  NEWFILE = "new"
-
-  def create_timed_files(oldfile, *newfiles)
-    return if (File.exist?(oldfile) &&
-      newfiles.all? { |newfile|
-        File.exist?(newfile) && File.stat(newfile).mtime > File.stat(oldfile).mtime
-      })
-    now = Time.now
-
-    create_file(oldfile, now - 60)
-
-    newfiles.each do |newfile|
-      create_file(newfile, now)
-    end
-  end
-
-  def create_dir(dirname)
-    FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
-    File.stat(dirname).mtime
-  end
-
-  def create_file(name, file_time=nil)
-    create_dir(File.dirname(name))
-    FileUtils.touch(name) unless File.exist?(name)
-    File.utime(file_time, file_time, name) unless file_time.nil?
-    File.stat(name).mtime
-  end
-
-  def delete_file(name)
-    File.delete(name) rescue nil
-  end
-end

data/vendor/bundle/gems/rake-10.0.3/test/helper.rb

@@ -1,562 +0,0 @@
-require 'rubygems'
-$:.unshift File.expand_path('../../lib', __FILE__)
-
-begin
-  gem 'minitest'
-rescue Gem::LoadError
-end
-
-require 'minitest/autorun'
-require 'rake'
-require 'tmpdir'
-require File.expand_path('../file_creation', __FILE__)
-
-begin
-  require_relative '../ruby/envutil'
-rescue NoMethodError, LoadError
-  # for ruby trunk
-end
-
-class Rake::TestCase < MiniTest::Unit::TestCase
-  include FileCreation
-
-  include Rake::DSL
-
-  class TaskManager
-    include Rake::TaskManager
-  end
-
-  RUBY = defined?(EnvUtil) ? EnvUtil.rubybin : Gem.ruby
-
-  def setup
-    ARGV.clear
-
-    test_dir = File.basename File.dirname File.expand_path __FILE__
-
-    @rake_root = if test_dir == 'test' then
-                   # rake repository
-                   File.expand_path '../../', __FILE__
-                 else
-                   # ruby repository
-                   File.expand_path '../../../', __FILE__
-                 end
-
-    @rake_exec = File.join @rake_root, 'bin', 'rake'
-    @rake_lib  = File.join @rake_root, 'lib'
-
-    @orig_PWD = Dir.pwd
-    @orig_APPDATA      = ENV['APPDATA']
-    @orig_HOME         = ENV['HOME']
-    @orig_HOMEDRIVE    = ENV['HOMEDRIVE']
-    @orig_HOMEPATH     = ENV['HOMEPATH']
-    @orig_RAKE_COLUMNS = ENV['RAKE_COLUMNS']
-    @orig_RAKE_SYSTEM  = ENV['RAKE_SYSTEM']
-    @orig_RAKEOPT      = ENV['RAKEOPT']
-    @orig_USERPROFILE  = ENV['USERPROFILE']
-    ENV.delete 'RAKE_COLUMNS'
-    ENV.delete 'RAKE_SYSTEM'
-    ENV.delete 'RAKEOPT'
-
-    tmpdir = Dir.chdir Dir.tmpdir do Dir.pwd end
-    @tempdir = File.join tmpdir, "test_rake_#{$$}"
-
-    FileUtils.mkdir_p @tempdir
-
-    Dir.chdir @tempdir
-
-    Rake.application = Rake::Application.new
-    Rake::TaskManager.record_task_metadata = true
-    RakeFileUtils.verbose_flag = false
-  end
-
-  def teardown
-    Dir.chdir @orig_PWD
-    FileUtils.rm_rf @tempdir
-
-    if @orig_APPDATA then
-      ENV['APPDATA'] = @orig_APPDATA
-    else
-      ENV.delete 'APPDATA'
-    end
-
-    ENV['HOME']         = @orig_HOME
-    ENV['HOMEDRIVE']    = @orig_HOMEDRIVE
-    ENV['HOMEPATH']     = @orig_HOMEPATH
-    ENV['RAKE_COLUMNS'] = @orig_RAKE_COLUMNS
-    ENV['RAKE_SYSTEM']  = @orig_RAKE_SYSTEM
-    ENV['RAKEOPT']      = @orig_RAKEOPT
-    ENV['USERPROFILE']  = @orig_USERPROFILE
-  end
-
-  def ignore_deprecations
-    Rake.application.options.ignore_deprecate = true
-    yield
-  ensure
-    Rake.application.options.ignore_deprecate = false
-  end
-
-  def rake_system_dir
-    @system_dir = 'system'
-
-    FileUtils.mkdir_p @system_dir
-
-    open File.join(@system_dir, 'sys1.rake'), 'w' do |io|
-      io << <<-SYS
-task "sys1" do
-  puts "SYS1"
-end
-      SYS
-    end
-
-    ENV['RAKE_SYSTEM'] = @system_dir
-  end
-
-  def rakefile contents
-    open 'Rakefile', 'w' do |io|
-      io << contents
-    end
-  end
-
-  def rakefile_access
-    rakefile <<-ACCESS
-TOP_LEVEL_CONSTANT = 0
-
-def a_top_level_function
-end
-
-task :default => [:work, :obj, :const]
-
-task :work do
-  begin
-    a_top_level_function
-    puts "GOOD:M Top level methods can be called in tasks"
-  rescue NameError => ex
-    puts "BAD:M  Top level methods can not be called in tasks"
-  end
-end
-
-# TODO: remove `disabled_' when DeprecatedObjectDSL removed
-task :obj
-task :disabled_obj do
-  begin
-    Object.new.instance_eval { task :xyzzy }
-    puts "BAD:D  Rake DSL are polluting objects"
-  rescue StandardError => ex
-    puts "GOOD:D Rake DSL are not polluting objects"
-  end
-end
-
-task :const do
-  begin
-    TOP_LEVEL_CONSTANT
-    puts "GOOD:C Top level constants are available in tasks"
-  rescue StandardError => ex
-    puts "BAD:C  Top level constants are NOT available in tasks"
-  end
-end
-    ACCESS
-  end
-
-  def rakefile_chains
-    rakefile <<-DEFAULT
-task :default => "play.app"
-
-file "play.scpt" => "base" do |t|
-  cp t.prerequisites.first, t.name
-end
-
-rule ".app" => ".scpt" do |t|
-  cp t.source, t.name
-end
-
-file 'base' do
-  touch 'base'
-end
-    DEFAULT
-  end
-
-  def rakefile_comments
-    rakefile <<-COMMENTS
-# comment for t1
-task :t1 do
-end
-
-# no comment or task because there's a blank line
-
-task :t2 do
-end
-
-desc "override comment for t3"
-# this is not the description
-multitask :t3 do
-end
-
-# this is not the description
-desc "override comment for t4"
-file :t4 do
-end
-    COMMENTS
-  end
-
-  def rakefile_default
-    rakefile <<-DEFAULT
-if ENV['TESTTOPSCOPE']
-  puts "TOPSCOPE"
-end
-
-task :default do
-  puts "DEFAULT"
-end
-
-task :other => [:default] do
-  puts "OTHER"
-end
-
-task :task_scope do
-  if ENV['TESTTASKSCOPE']
-    puts "TASKSCOPE"
-  end
-end
-    DEFAULT
-  end
-
-  def rakefile_dryrun
-    rakefile <<-DRYRUN
-task :default => ["temp_main"]
-
-file "temp_main" => [:all_apps]  do touch "temp_main" end
-
-task :all_apps => [:one, :two]
-task :one => ["temp_one"]
-task :two => ["temp_two"]
-
-file "temp_one" do |t|
-  touch "temp_one"
-end
-file "temp_two" do |t|
-  touch "temp_two"
-end
-
-task :clean do
-  ["temp_one", "temp_two", "temp_main"].each do |file|
-    rm_f file
-  end
-end
-    DRYRUN
-
-    FileUtils.touch 'temp_main'
-    FileUtils.touch 'temp_two'
-  end
-
-  def rakefile_extra
-    rakefile 'task :default'
-
-    FileUtils.mkdir_p 'rakelib'
-
-    open File.join('rakelib', 'extra.rake'), 'w' do |io|
-      io << <<-EXTRA_RAKE
-# Added for testing
-
-namespace :extra do
-  desc "An Extra Task"
-  task :extra do
-    puts "Read all about it"
-  end
-end
-      EXTRA_RAKE
-    end
-  end
-
-  def rakefile_file_creation
-    rakefile <<-'FILE_CREATION'
-N = 2
-
-task :default => :run
-
-BUILD_DIR = 'build'
-task :clean do
-  rm_rf 'build'
-  rm_rf 'src'
-end
-
-task :run
-
-TARGET_DIR = 'build/copies'
-
-FileList['src/*'].each do |src|
-  directory TARGET_DIR
-  target = File.join TARGET_DIR, File.basename(src)
-  file target => [src, TARGET_DIR] do
-    cp src, target
-    # sleep 3 if src !~ /foo#{N-1}$/   # I'm commenting out this sleep, it doesn't seem to do anything.
-  end
-  task :run => target
-end
-
-task :prep => :clean do
-  mkdir_p 'src'
-  N.times do |n|
-    touch "src/foo#{n}"
-  end
-end
-    FILE_CREATION
-  end
-
-  def rakefile_imports
-    rakefile <<-IMPORTS
-require 'rake/loaders/makefile'
-
-task :default
-
-task :other do
-  puts "OTHER"
-end
-
-file "dynamic_deps" do |t|
-  open(t.name, "w") do |f| f.puts "puts 'DYNAMIC'" end
-end
-
-import "dynamic_deps"
-import "static_deps"
-import "static_deps"
-import "deps.mf"
-puts "FIRST"
-    IMPORTS
-
-    open 'deps.mf', 'w' do |io|
-      io << <<-DEPS
-default: other
-      DEPS
-    end
-
-    open "static_deps", "w" do |f|
-      f.puts 'puts "STATIC"'
-    end
-  end
-
-  def rakefile_multidesc
-    rakefile <<-MULTIDESC
-task :b
-
-desc "A"
-task :a
-
-desc "B"
-task :b
-
-desc "A2"
-task :a
-
-task :c
-
-desc "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-task :d
-    MULTIDESC
-  end
-
-  def rakefile_namespace
-    rakefile <<-NAMESPACE
-desc "copy"
-task :copy do
-  puts "COPY"
-end
-
-namespace "nest" do
-  desc "nest copy"
-  task :copy do
-    puts "NEST COPY"
-  end
-  task :xx => :copy
-end
-
-anon_ns = namespace do
-  desc "anonymous copy task"
-  task :copy do
-    puts "ANON COPY"
-  end
-end
-
-desc "Top level task to run the anonymous version of copy"
-task :anon => anon_ns[:copy]
-
-namespace "very" do
-  namespace "nested" do
-    task "run" => "rake:copy"
-  end
-end
-
-namespace "a" do
-  desc "Run task in the 'a' namespace"
-  task "run" do
-    puts "IN A"
-  end
-end
-
-namespace "b" do
-  desc "Run task in the 'b' namespace"
-  task "run" => "a:run" do
-    puts "IN B"
-  end
-end
-
-namespace "file1" do
-  file "xyz.rb" do
-    puts "XYZ1"
-  end
-end
-
-namespace "file2" do
-  file "xyz.rb" do
-    puts "XYZ2"
-  end
-end
-
-namespace "scopedep" do
-  task :prepare do
-    touch "scopedep.rb"
-    puts "PREPARE"
-  end
-  file "scopedep.rb" => [:prepare] do
-    puts "SCOPEDEP"
-  end
-end
-    NAMESPACE
-  end
-
-  def rakefile_nosearch
-    FileUtils.touch 'dummy'
-  end
-
-  def rakefile_rakelib
-    FileUtils.mkdir_p 'rakelib'
-
-    Dir.chdir 'rakelib' do
-      open 'test1.rb', 'w' do |io|
-        io << <<-TEST1
-task :default do
-  puts "TEST1"
-end
-        TEST1
-      end
-
-      open 'test2.rake', 'w' do |io|
-        io << <<-TEST1
-task :default do
-  puts "TEST2"
-end
-        TEST1
-      end
-    end
-  end
-
-  def rakefile_rbext
-    open 'rakefile.rb', 'w' do |io|
-      io << 'task :default do puts "OK" end'
-    end
-  end
-
-  def rakefile_unittest
-    rakefile '# Empty Rakefile for Unit Test'
-
-    readme = File.join 'subdir', 'README'
-    FileUtils.mkdir_p File.dirname readme
-
-    FileUtils.touch readme
-  end
-
-  def rakefile_verbose
-    rakefile <<-VERBOSE
-task :standalone_verbose_true do
-  verbose true
-  sh "#{RUBY} -e '0'"
-end
-
-task :standalone_verbose_false do
-  verbose false
-  sh "#{RUBY} -e '0'"
-end
-
-task :inline_verbose_default do
-  sh "#{RUBY} -e '0'"
-end
-
-task :inline_verbose_false do
-  sh "#{RUBY} -e '0'", :verbose => false
-end
-
-task :inline_verbose_true do
-  sh "#{RUBY} -e '0'", :verbose => true
-end
-
-task :block_verbose_true do
-  verbose(true) do
-    sh "#{RUBY} -e '0'"
-  end
-end
-
-task :block_verbose_false do
-  verbose(false) do
-    sh "#{RUBY} -e '0'"
-  end
-end
-    VERBOSE
-  end
-
-  def rakefile_test_signal
-    rakefile <<-TEST_SIGNAL
-require 'rake/testtask'
-
-Rake::TestTask.new(:a) do |t|
-  t.test_files = ['a_test.rb']
-end
-
-Rake::TestTask.new(:b) do |t|
-  t.test_files = ['b_test.rb']
-end
-
-task :test do
-  Rake::Task[:a].invoke
-  Rake::Task[:b].invoke
-end
-
-task :default => :test
-    TEST_SIGNAL
-    open 'a_test.rb', 'w' do |io|
-      io << 'puts "ATEST"' << "\n"
-      io << '$stdout.flush' << "\n"
-      io << 'Process.kill("TERM", $$)' << "\n"
-    end
-    open 'b_test.rb', 'w' do |io|
-      io << 'puts "BTEST"' << "\n"
-      io << '$stdout.flush' << "\n"
-    end
-  end
-
-  def rakefile_failing_test_task
-    rakefile <<-TEST_TASK
-require 'rake/testtask'
-
-task :default => :test
-Rake::TestTask.new(:test) do |t|
-  t.test_files = ['a_test.rb']
-end
-    TEST_TASK
-    open 'a_test.rb', 'w' do |io|
-      io << "require 'minitest/autorun'\n"
-      io << "class ExitTaskTest < MiniTest::Unit::TestCase\n"
-      io << "  def test_exit\n"
-      io << "    assert false, 'this should fail'\n"
-      io << "  end\n"
-      io << "end\n"
-    end
-  end
-
-  def rakefile_stand_alone_filelist
-    open 'stand_alone_filelist.rb', 'w' do |io|
-      io << "require 'rake/file_list'\n"
-      io << "FL = Rake::FileList['*.rb']\n"
-      io << "puts FL\n"
-    end
-  end
-
-end