gameboard 3.1.0 → 3.2.0

data/vendor/bundle/ruby/2.3.0/gems/guard-2.14.0/bin/guard

@@ -1,115 +0,0 @@
-#!/usr/bin/env ruby
-
-require "pathname"
-
-class GuardReloader
-  class Config
-    def using_rubygems?
-      ENV["RUBYGEMS_GEMDEPS"]
-    end
-
-    def setup_rubygems_for_deps
-      require "rubygems"
-    end
-
-    def current_bundler_gemfile
-      ENV["BUNDLE_GEMFILE"]
-    end
-
-    def using_bundler?
-      ENV["BUNDLE_GEMFILE"]
-    end
-
-    def setup_bundler_env(gemfile)
-      ENV["BUNDLE_GEMFILE"] = gemfile
-    end
-
-    def setup_bundler
-      require "rubygems"
-      require "bundler/setup"
-    end
-
-    def program_path
-      Pathname(__FILE__)
-    end
-
-    def program_arguments
-      ARGV
-    end
-
-    def windows?
-      Gem.win_platform?
-    end
-
-    def default_system_ruby
-      RbConfig.ruby
-    end
-
-    def exit_with(code)
-      exit(code)
-    end
-
-    def spawn_with(*args)
-      spawn(*args)
-    end
-
-    def wait_ignoring_interrupts(pid)
-      Process.wait2(pid)[1].exitstatus
-    rescue Interrupt
-      retry
-    rescue Errno::ECHILD
-      1
-    end
-
-    def exist?(path)
-      path.exist?
-    end
-
-    def guard_core_path
-      Gem.bin_path("guard", "_guard-core")
-    end
-  end
-
-  attr_reader :config
-  def initialize(config)
-    @config = config
-  end
-
-  def setup
-    return config.setup_bundler if config.using_bundler?
-    return config.setup_rubygems_for_deps if config.using_rubygems?
-
-    # No dependency management detected - check if binstubbed by bundler
-    relative_to_binstub = config.program_path + "../../Gemfile"
-    if config.exist?(relative_to_binstub)
-      config.setup_bundler_env(relative_to_binstub.to_s)
-      config.setup_bundler
-      return
-    end
-
-    unless config.exist?(Pathname("Gemfile"))
-      # Running guard with bare ruby here - it's up to the user
-      # to setup/install missing deps
-      return
-    end
-
-    STDERR.puts "Warning: you have a Gemfile, but you're not using"\
-      " bundler or RUBYGEMS_GEMDEPS"
-  end
-
-  def auto_restart
-    args = [config.guard_core_path] + config.program_arguments
-    args.unshift(config.default_system_ruby) if config.windows?
-    loop do
-      exitcode = config.wait_ignoring_interrupts(config.spawn_with(*args))
-      config.exit_with(exitcode) if exitcode != 2
-    end
-  end
-end
-
-unless ENV["GUARD_SPECS_RUNNING"]
-  config = GuardReloader::Config.new
-  reloader = GuardReloader.new(config)
-  reloader.setup
-  reloader.auto_restart
-end

data/vendor/bundle/ruby/2.3.0/gems/guard-2.14.0/lib/guard.rb

@@ -1,169 +0,0 @@
-require "thread"
-require "listen"
-
-require "guard/config"
-require "guard/deprecated/guard" unless Guard::Config.new.strict?
-require "guard/internals/helpers"
-
-require "guard/internals/debugging"
-require "guard/internals/traps"
-require "guard/internals/queue"
-
-# TODO: remove this class altogether
-require "guard/interactor"
-
-# Guard is the main module for all Guard related modules and classes.
-# Also Guard plugins should use this namespace.
-module Guard
-  Deprecated::Guard.add_deprecated(self) unless Config.new.strict?
-
-  class << self
-    attr_reader :state
-    attr_reader :queue
-    attr_reader :listener
-    attr_reader :interactor
-
-    # @private api
-
-    include Internals::Helpers
-
-    # Initializes the Guard singleton:
-    #
-    # * Initialize the internal Guard state;
-    # * Create the interactor
-    # * Select and initialize the file change listener.
-    #
-    # @option options [Boolean] clear if auto clear the UI should be done
-    # @option options [Boolean] notify if system notifications should be shown
-    # @option options [Boolean] debug if debug output should be shown
-    # @option options [Array<String>] group the list of groups to start
-    # @option options [Array<String>] watchdir the directories to watch
-    # @option options [String] guardfile the path to the Guardfile
-    #
-    # @return [Guard] the Guard singleton
-    def setup(cmdline_options = {})
-      init(cmdline_options)
-
-      @queue = Internals::Queue.new(Guard)
-
-      _evaluate(state.session.evaluator_options)
-
-      # NOTE: this should be *after* evaluate so :directories can work
-      # TODO: move listener setup to session?
-      @listener = Listen.send(*state.session.listener_args, &_listener_callback)
-
-      ignores = state.session.guardfile_ignore
-      @listener.ignore(ignores) unless ignores.empty?
-
-      ignores = state.session.guardfile_ignore_bang
-      @listener.ignore!(ignores) unless ignores.empty?
-
-      Notifier.connect(state.session.notify_options)
-
-      traps = Internals::Traps
-      traps.handle("USR1") { async_queue_add([:guard_pause, :paused]) }
-      traps.handle("USR2") { async_queue_add([:guard_pause, :unpaused]) }
-
-      @interactor = Interactor.new(state.session.interactor_name == :sleep)
-      traps.handle("INT") { @interactor.handle_interrupt }
-
-      self
-    end
-
-    def init(cmdline_options)
-      @state = Internals::State.new(cmdline_options)
-    end
-
-    # Asynchronously trigger changes
-    #
-    # Currently supported args:
-    #
-    #   @example Old style hash:
-    #     async_queue_add(modified: ['foo'], added: ['bar'], removed: [])
-    #
-    #   @example New style signals with args:
-    #     async_queue_add([:guard_pause, :unpaused ])
-    #
-    def async_queue_add(changes)
-      @queue << changes
-
-      # Putting interactor in background puts guard into foreground
-      # so it can handle change notifications
-      Thread.new { interactor.background }
-    end
-
-    private
-
-    # Check if any of the changes are actually watched for
-    # TODO: why iterate twice? reuse this info when running tasks
-    def _relevant_changes?(changes)
-      # TODO: no coverage!
-      files = changes.values.flatten(1)
-      scope = Guard.state.scope
-      watchers = scope.grouped_plugins.map do |_group, plugins|
-        plugins.map(&:watchers).flatten
-      end.flatten
-      watchers.any? { |watcher| files.any? { |file| watcher.match(file) } }
-    end
-
-    def _relative_pathnames(paths)
-      paths.map { |path| _relative_pathname(path) }
-    end
-
-    def _listener_callback
-      lambda do |modified, added, removed|
-        relative_paths = {
-          modified: _relative_pathnames(modified),
-          added: _relative_pathnames(added),
-          removed: _relative_pathnames(removed)
-        }
-
-        _guardfile_deprecated_check(relative_paths[:modified])
-
-        async_queue_add(relative_paths) if _relevant_changes?(relative_paths)
-      end
-    end
-
-    # TODO: obsoleted? (move to Dsl?)
-    def _pluginless_guardfile?
-      state.session.plugins.all.empty?
-    end
-
-    def _evaluate(options)
-      evaluator = Guardfile::Evaluator.new(options)
-      evaluator.evaluate
-
-      UI.reset_and_clear
-
-      msg = "No plugins found in Guardfile, please add at least one."
-      UI.error msg if _pluginless_guardfile?
-
-      if evaluator.inline?
-        UI.info("Using inline Guardfile.")
-      elsif evaluator.custom?
-        UI.info("Using Guardfile at #{ evaluator.path }.")
-      end
-    rescue Guardfile::Evaluator::NoPluginsError => e
-      UI.error(e.message)
-    end
-
-    # TODO: remove at some point
-    # TODO: not tested because collides with ongoing refactoring
-    def _guardfile_deprecated_check(modified)
-      modified.map!(&:to_s)
-      regexp = %r{^(?:.+/)?Guardfile$}
-      guardfiles = modified.select { |path| regexp.match(path) }
-      return if guardfiles.empty?
-
-      guardfile = Pathname("Guardfile").realpath
-      real_guardfiles = guardfiles.detect do |path|
-        /^Guardfile$/.match(path) || Pathname(path).expand_path == guardfile
-      end
-
-      return unless real_guardfiles
-
-      UI.warning "Guardfile changed -- _guard-core will exit.\n"
-      exit 2 # nonzero to break any while loop
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/guard-2.14.0/lib/guard/aruba_adapter.rb

@@ -1,59 +0,0 @@
-require "guard/cli"
-
-module Guard
-  class ArubaAdapter
-    def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR,
-                   kernel = Kernel)
-      @argv = argv
-      @stdin = stdin
-      @stdout = stdout
-      @stderr = stderr
-      @kernel = kernel
-
-      if ENV["INSIDE_ARUBA_TEST"] == "1"
-        UI.options = UI.options.merge(flush_seconds: 0)
-      end
-    end
-
-    def execute!
-      exit_code = execute
-      # Proxy our exit code back to the injected kernel.
-      @kernel.exit(exit_code)
-    end
-
-    def execute
-      # Thor accesses these streams directly rather than letting
-      # them be injected, so we replace them...
-      $stderr = @stderr
-      $stdin = @stdin
-      $stdout = @stdout
-
-      # Run our normal Thor app the way we know and love.
-      CLI.start(@argv)
-
-      # Thor::Base#start does not have a return value, assume
-      # success if no exception is raised.
-      0
-    rescue StandardError => e
-      # The ruby interpreter would pipe this to STDERR and exit 1 in the case
-      # of an unhandled exception
-      b = e.backtrace
-      @stderr.puts "#{b.shift}: #{e.message} (#{e.class})"
-      @stderr.puts b.map { |s| "\tfrom #{s}" }.join("\n")
-      1
-    rescue SystemExit => e
-      e.status
-    ensure
-      # flush the logger so the output doesn't appear in next CLI invocation
-      Guard.listener.stop if Guard.listener
-      UI.logger.flush
-      UI.logger.close
-      UI.reset_logger
-
-      # ...then we put them back.
-      $stderr = STDERR
-      $stdin = STDIN
-      $stdout = STDOUT
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/guard-2.14.0/lib/guard/cli.rb

@@ -1,200 +0,0 @@
-require "thor"
-
-require "guard/version"
-
-require "guard/dsl_describer"
-require "guard/cli/environments/valid"
-require "guard/cli/environments/evaluate_only"
-
-module Guard
-  # Facade for the Guard command line interface managed by
-  # [Thor](https://github.com/wycats/thor).
-  #
-  # This is the main interface to Guard that is called by the Guard binary
-  # `bin/guard`. Do not put any logic in here, create a class and delegate
-  # instead.
-  #
-  class CLI < Thor
-    default_task :start
-
-    desc "start", "Starts Guard"
-
-    method_option :clear,
-                  type: :boolean,
-                  default: false,
-                  aliases: "-c",
-                  banner: "Auto clear shell before each action"
-
-    method_option :notify,
-                  type: :boolean,
-                  default: true,
-                  aliases: "-n",
-                  banner: "Notifications feature"
-
-    method_option :debug,
-                  type: :boolean,
-                  default: false,
-                  aliases: "-d",
-                  banner: "Show debug information"
-
-    method_option :group,
-                  type: :array,
-                  default: [],
-                  aliases: "-g",
-                  banner: "Run only the passed groups"
-
-    method_option :plugin,
-                  type: :array,
-                  default: [],
-                  aliases: "-P",
-                  banner: "Run only the passed plugins"
-
-    # TODO: make it plural
-    method_option :watchdir,
-                  type: :array,
-                  aliases: "-w",
-                  banner: "Specify the directories to watch"
-
-    method_option :guardfile,
-                  type: :string,
-                  aliases: "-G",
-                  banner: "Specify a Guardfile"
-
-    method_option :no_interactions,
-                  type: :boolean,
-                  default: false,
-                  aliases: "-i",
-                  banner: "Turn off completely any Guard terminal interactions"
-
-    method_option :no_bundler_warning,
-                  type: :boolean,
-                  default: false,
-                  aliases: "-B",
-                  banner: "Turn off warning when Bundler is not present"
-
-    # Listen options
-    method_option :latency,
-                  type: :numeric,
-                  aliases: "-l",
-                  banner: 'Overwrite Listen\'s default latency'
-
-    method_option :force_polling,
-                  type: :boolean,
-                  default: false,
-                  aliases: "-p",
-                  banner: "Force usage of the Listen polling listener"
-
-    method_option :wait_for_delay,
-                  type: :numeric,
-                  aliases: "-y",
-                  banner: 'Overwrite Listen\'s default wait_for_delay'
-
-    method_option :listen_on,
-                  type: :string,
-                  aliases: "-o",
-                  default: false,
-                  banner: "Specify a network address to Listen on for "\
-                  "file change events (e.g. for use in VMs)"
-
-    def self.help(shell, subcommand = false)
-      super
-      command_help(shell, default_task)
-    end
-
-    # Start Guard by initializing the defined Guard plugins and watch the file
-    # system.
-    #
-    # This is the default task, so calling `guard` is the same as calling
-    # `guard start`.
-    #
-    # @see Guard.start
-    #
-    def start
-      if defined?(JRUBY_VERSION)
-        unless options[:no_interactions]
-          abort "\nSorry, JRuby and interactive mode are incompatible.\n"\
-            "As a workaround, use the '-i' option instead.\n\n"\
-            "More info: \n"\
-            " * https://github.com/guard/guard/issues/754\n"\
-            " * https://github.com/jruby/jruby/issues/2383\n\n"
-        end
-      end
-      exit(Cli::Environments::Valid.new(options).start_guard)
-    end
-
-    desc "list", "Lists Guard plugins that can be used with init"
-
-    # List the Guard plugins that are available for use in your system and
-    # marks those that are currently used in your `Guardfile`.
-    #
-    # @see Guard::DslDescriber.list
-    #
-    def list
-      Cli::Environments::EvaluateOnly.new(options).evaluate
-      DslDescriber.new.list
-    end
-
-    desc "notifiers", "Lists notifiers and its options"
-
-    # List the Notifiers for use in your system.
-    #
-    # @see Guard::DslDescriber.notifiers
-    #
-    def notifiers
-      Cli::Environments::EvaluateOnly.new(options).evaluate
-      # TODO: pass the data directly to the notifiers?
-      DslDescriber.new.notifiers
-    end
-
-    desc "version", "Show the Guard version"
-    map %w(-v --version) => :version
-
-    # Shows the current version of Guard.
-    #
-    # @see Guard::VERSION
-    #
-    def version
-      $stdout.puts "Guard version #{ VERSION }"
-    end
-
-    desc "init [GUARDS]", "Generates a Guardfile at the current directory"\
-      " (if it is not already there) and adds all installed Guard plugins"\
-      " or the given GUARDS into it"
-
-    method_option :bare,
-                  type: :boolean,
-                  default: false,
-                  aliases: "-b",
-                  banner: "Generate a bare Guardfile without adding any"\
-                  " installed plugin into it"
-
-    # Initializes the templates of all installed Guard plugins and adds them
-    # to the `Guardfile` when no Guard name is passed. When passing
-    # Guard plugin names it does the same but only for those Guard plugins.
-    #
-    # @see Guard::Guardfile.initialize_template
-    # @see Guard::Guardfile.initialize_all_templates
-    #
-    # @param [Array<String>] plugin_names the name of the Guard plugins to
-    # initialize
-    #
-    def init(*plugin_names)
-      env = Cli::Environments::Valid.new(options)
-      exitcode = env.initialize_guardfile(plugin_names)
-      exit(exitcode)
-    end
-
-    desc "show", "Show all defined Guard plugins and their options"
-    map %w(-T) => :show
-
-    # Shows all Guard plugins and their options that are defined in
-    # the `Guardfile`
-    #
-    # @see Guard::DslDescriber.show
-    #
-    def show
-      Cli::Environments::EvaluateOnly.new(options).evaluate
-      DslDescriber.new.show
-    end
-  end
-end