geminfo 0.1.0 → 0.1.1

data/path/gems/guard-2.13.0/lib/guard/internals/session.rb

@@ -1,182 +0,0 @@
-require "guard/internals/plugins"
-require "guard/internals/groups"
-
-require "guard/options"
-
-module Guard
-  # @private api
-  module Internals
-    # TODO: split into a commandline class and session (plugins, groups)
-    # TODO: swap session and metadata
-    class Session
-      attr_reader :plugins
-      attr_reader :groups
-
-      DEFAULT_OPTIONS = {
-        clear: false,
-        debug: false,
-        no_bundler_warning: false,
-
-        # User defined scopes
-        group: [],
-        plugin: [],
-
-        # Notifier
-        notify: true,
-
-        # Interactor
-        no_interactions: false,
-
-        # Guardfile options:
-        # guardfile_contents
-        guardfile: nil,
-
-        # Listener options
-        # TODO: rename to watchdirs?
-        watchdir: Dir.pwd,
-        latency: nil,
-        force_polling: false,
-        wait_for_delay: nil,
-        listen_on: nil
-      }
-
-      def cmdline_groups
-        @cmdline_groups.dup.freeze
-      end
-
-      def cmdline_plugins
-        @cmdline_plugins.dup.freeze
-      end
-
-      def initialize(new_options)
-        @options = Options.new(new_options, DEFAULT_OPTIONS)
-
-        @plugins = Plugins.new
-        @groups = Groups.new
-
-        @cmdline_groups = @options[:group]
-        @cmdline_plugins = @options[:plugin]
-
-        @clear = @options[:clear]
-        @debug = @options[:debug]
-        @watchdirs = Array(@options[:watchdir])
-        @notify = @options[:notify]
-        @interactor_name = @options[:no_interactions] ? :sleep : :pry_wrapper
-
-        @guardfile_plugin_scope = []
-        @guardfile_group_scope = []
-        @guardfile_ignore = []
-        @guardfile_ignore_bang = []
-
-        @guardfile_notifier_options = {}
-      end
-
-      def guardfile_scope(scope)
-        opts = scope.dup
-
-        groups = Array(opts.delete(:groups))
-        group = Array(opts.delete(:group))
-        @guardfile_group_scope = Array(groups) + Array(group)
-
-        plugins = Array(opts.delete(:plugins))
-        plugin = Array(opts.delete(:plugin))
-        @guardfile_plugin_scope = Array(plugins) + Array(plugin)
-
-        fail "Unknown options: #{opts.inspect}" unless opts.empty?
-      end
-
-      # TODO: create a EvaluatorResult class?
-      attr_reader :guardfile_group_scope
-      attr_reader :guardfile_plugin_scope
-      attr_accessor :guardfile_ignore_bang
-
-      attr_reader :guardfile_ignore
-      def guardfile_ignore=(ignores)
-        @guardfile_ignore += Array(ignores).flatten
-      end
-
-      def clearing(on)
-        @clear = on
-      end
-
-      def clearing?
-        @clear
-      end
-
-      alias :clear? :clearing?
-
-      def debug?
-        @debug
-      end
-
-      def watchdirs
-        @watchdirs_from_guardfile ||= nil
-        @watchdirs_from_guardfile || @watchdirs
-      end
-
-      # set by Dsl with :directories() command
-      def watchdirs=(dirs)
-        dirs = [Dir.pwd] if dirs.empty?
-        @watchdirs_from_guardfile = dirs.map { |dir| File.expand_path dir }
-      end
-
-      def listener_args
-        if @options[:listen_on]
-          [:on, @options[:listen_on]]
-        else
-          listener_options = {}
-          [:latency, :force_polling, :wait_for_delay].each do |option|
-            listener_options[option] = @options[option] if @options[option]
-          end
-          expanded_watchdirs = watchdirs.map { |dir| File.expand_path dir }
-          [:to, *expanded_watchdirs, listener_options]
-        end
-      end
-
-      def evaluator_options
-        opts = { guardfile: @options[:guardfile] }
-        # TODO: deprecate :guardfile_contents
-        if @options[:guardfile_contents]
-          opts[:contents] = @options[:guardfile_contents]
-        end
-        opts
-      end
-
-      def notify_options
-        names = @guardfile_notifier_options.keys
-        return { notify: false } if names.include?(:off)
-
-        {
-          notify: @options[:notify],
-          notifiers: @guardfile_notifier_options
-        }
-      end
-
-      def guardfile_notification=(config)
-        @guardfile_notifier_options.merge!(config)
-      end
-
-      def interactor_name
-        @interactor_name
-      end
-
-      # TODO: call this from within action, not within interactor command
-      def convert_scope(entries)
-        scopes = { plugins: [], groups: [] }
-        unknown = []
-
-        entries.each do |entry|
-          if plugin = plugins.all(entry).first
-            scopes[:plugins] << plugin
-          elsif group = groups.all(entry).first
-            scopes[:groups] << group
-          else
-            unknown << entry
-          end
-        end
-
-        [scopes, unknown]
-      end
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/internals/state.rb

@@ -1,25 +0,0 @@
-require "guard/group"
-
-require "guard/plugin_util"
-require "guard/internals/session"
-require "guard/internals/scope"
-require "guard/runner"
-
-module Guard
-  module Internals
-    class State
-      # Minimal setup for non-interactive commands (list, init, show, etc.)
-      def initialize(cmdline_opts)
-        @session = Session.new(cmdline_opts)
-
-        @scope = Scope.new
-
-        # NOTE: must be set before anything calls Guard::UI.debug
-        Debugging.start if session.debug?
-      end
-
-      attr_reader :scope
-      attr_reader :session
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/internals/tracing.rb

@@ -1,33 +0,0 @@
-module Guard
-  module Internals
-    module Tracing
-      def self.trace(mod, meth)
-        meta = (class << mod; self; end)
-        original_meth = "original_#{meth}".to_sym
-
-        if mod.respond_to?(original_meth)
-          fail "ALREADY TRACED: #{mod}.#{meth}"
-        end
-
-        meta.send(:alias_method, original_meth, meth)
-        meta.send(:define_method, meth) do |*args, &block|
-          yield(*args) if block_given?
-          mod.send original_meth, *args, &block
-        end
-      end
-
-      def self.untrace(mod, meth)
-        meta = (class << mod; self; end)
-        original_meth = "original_#{meth}".to_sym
-
-        unless mod.respond_to?(original_meth)
-          fail "NOT TRACED: #{mod}.#{meth} (no method: #{original_meth})"
-        end
-
-        meta.send(:remove_method, meth)
-        meta.send(:alias_method, meth, original_meth)
-        meta.send(:undef_method, original_meth)
-      end
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/internals/traps.rb

@@ -1,10 +0,0 @@
-module Guard
-  module Internals
-    module Traps
-      def self.handle(signal, &block)
-        return unless Signal.list.key?(signal)
-        Signal.trap(signal, &block)
-      end
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/jobs/base.rb

@@ -1,21 +0,0 @@
-module Guard
-  module Jobs
-    class Base
-      def initialize(_options)
-      end
-
-      # @return [Symbol] :stopped once job is finished
-      # @return [Symbol] :exit to tell Guard to terminate
-      def foreground
-      end
-
-      def background
-      end
-
-      # Signal handler calls this, so avoid actually doing
-      # anything other than signaling threads
-      def handle_interrupt
-      end
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/jobs/pry_wrapper.rb

@@ -1,293 +0,0 @@
-require "guard/commands/all"
-require "guard/commands/change"
-require "guard/commands/notification"
-require "guard/commands/pause"
-require "guard/commands/reload"
-require "guard/commands/scope"
-require "guard/commands/show"
-require "shellany/sheller"
-
-require "guard/jobs/base"
-
-module Guard
-  module Jobs
-    class TerminalSettings
-      def initialize
-        @settings = nil
-        @works = Shellany::Sheller.run("hash", "stty") || false
-      end
-
-      def restore
-        return unless configurable? && @settings
-        Shellany::Sheller.run("stty #{ @setting } 2>#{IO::NULL}")
-      end
-
-      def save
-        return unless configurable?
-        @settings = Shellany::Sheller.stdout("stty -g 2>#{IO::NULL}").chomp
-      end
-
-      def echo
-        return unless configurable?
-        Shellany::Sheller.run("stty echo 2>#{IO::NULL}")
-      end
-
-      def configurable?
-        @works
-      end
-    end
-
-    class PryWrapper < Base
-      # The default Ruby script to configure Guard Pry if the option `:guard_rc`
-      # is not defined.
-      GUARD_RC = "~/.guardrc"
-
-      # The default Guard Pry history file if the option `:history_file` is not
-      # defined.
-      HISTORY_FILE = "~/.guard_history"
-
-      # List of shortcuts for each interactor command
-      SHORTCUTS = {
-        help: "h",
-        all: "a",
-        reload: "r",
-        change: "c",
-        show: "s",
-        scope: "o",
-        notification: "n",
-        pause: "p",
-        exit: "e",
-        quit: "q"
-      }
-
-      def initialize(options)
-        @mutex = Mutex.new
-        @thread = nil
-        @terminal_settings = TerminalSettings.new
-
-        _setup(options)
-      end
-
-      def foreground
-        UI.debug "Start interactor"
-        @terminal_settings.save
-
-        _switch_to_pry
-        # TODO: rename :stopped to continue
-        _killed? ? :stopped : :exit
-      ensure
-        UI.reset_line
-        UI.debug "Interactor was stopped or killed"
-        @terminal_settings.restore
-      end
-
-      def background
-        _kill_pry
-      end
-
-      def handle_interrupt
-        thread = @thread
-        fail Interrupt unless thread
-        thread.raise Interrupt
-      end
-
-      private
-
-      attr_reader :thread
-
-      def _switch_to_pry
-        th = nil
-        @mutex.synchronize do
-          unless @thread
-            @thread = Thread.new { Pry.start }
-            @thread.join(0.5) # give pry a chance to start
-            th = @thread
-          end
-        end
-        # check for nill, because it might've been killed between the mutex and
-        # now
-        th.join unless th.nil?
-      end
-
-      def _killed?
-        th = nil
-        @mutex.synchronize { th = @thread }
-        th.nil?
-      end
-
-      def _kill_pry
-        @mutex.synchronize do
-          unless @thread.nil?
-            @thread.kill
-            @thread = nil # set to nil so we know we were killed
-          end
-        end
-      end
-
-      def _setup(options)
-        Pry.config.should_load_rc = false
-        Pry.config.should_load_local_rc = false
-        history_file_path = options[:history_file] || HISTORY_FILE
-        Pry.config.history.file = File.expand_path(history_file_path)
-
-        _add_hooks(options)
-
-        Commands::All.import
-        Commands::Change.import
-        Commands::Notification.import
-        Commands::Pause.import
-        Commands::Reload.import
-        Commands::Show.import
-        Commands::Scope.import
-
-        _setup_commands
-        _configure_prompt
-      end
-
-      # Add Pry hooks:
-      #
-      # * Load `~/.guardrc` within each new Pry session.
-      # * Load project's `.guardrc` within each new Pry session.
-      # * Restore prompt after each evaluation.
-      #
-      def _add_hooks(options)
-        _add_load_guard_rc_hook(Pathname(options[:guard_rc] || GUARD_RC))
-        _add_load_project_guard_rc_hook(Pathname.pwd + ".guardrc")
-        _add_restore_visibility_hook if @terminal_settings.configurable?
-      end
-
-      # Add a `when_started` hook that loads a global .guardrc if it exists.
-      #
-      def _add_load_guard_rc_hook(guard_rc)
-        Pry.config.hooks.add_hook :when_started, :load_guard_rc do
-          guard_rc.expand_path.tap { |p| load p if p.exist? }
-        end
-      end
-
-      # Add a `when_started` hook that loads a project .guardrc if it exists.
-      #
-      def _add_load_project_guard_rc_hook(guard_rc)
-        Pry.config.hooks.add_hook :when_started, :load_project_guard_rc do
-          load guard_rc if guard_rc.exist?
-        end
-      end
-
-      # Add a `after_eval` hook that restores visibility after a command is
-      # eval.
-      def _add_restore_visibility_hook
-        Pry.config.hooks.add_hook :after_eval, :restore_visibility do
-          @terminal_settings.echo
-        end
-      end
-
-      def _setup_commands
-        _replace_reset_command
-        _create_run_all_command
-        _create_command_aliases
-        _create_guard_commands
-        _create_group_commands
-      end
-
-      # Replaces reset defined inside of Pry with a reset that
-      # instead restarts guard.
-      #
-      def _replace_reset_command
-        Pry.commands.command "reset", "Reset the Guard to a clean state." do
-          output.puts "Guard reset."
-          exec "guard"
-        end
-      end
-
-      # Creates a command that triggers the `:run_all` action
-      # when the command is empty (just pressing enter on the
-      # beginning of a line).
-      #
-      def _create_run_all_command
-        Pry.commands.block_command(/^$/, "Hit enter to run all") do
-          Pry.run_command "all"
-        end
-      end
-
-      # Creates command aliases for the commands: `help`, `reload`, `change`,
-      # `scope`, `notification`, `pause`, `exit` and `quit`, which will be the
-      # first letter of the command.
-      #
-      def _create_command_aliases
-        SHORTCUTS.each do |command, shortcut|
-          Pry.commands.alias_command shortcut, command.to_s
-        end
-      end
-
-      # Create a shorthand command to run the `:run_all`
-      # action on a specific Guard plugin. For example,
-      # when guard-rspec is available, then a command
-      # `rspec` is created that runs `all rspec`.
-      #
-      def _create_guard_commands
-        Guard.state.session.plugins.all.each do |guard_plugin|
-          cmd = "Run all #{ guard_plugin.title }"
-          Pry.commands.create_command guard_plugin.name, cmd do
-            group "Guard"
-
-            def process
-              Pry.run_command "all #{ match }"
-            end
-          end
-        end
-      end
-
-      # Create a shorthand command to run the `:run_all`
-      # action on a specific Guard group. For example,
-      # when you have a group `frontend`, then a command
-      # `frontend` is created that runs `all frontend`.
-      #
-      def _create_group_commands
-        Guard.state.session.groups.all.each do |group|
-          next if group.name == :default
-
-          cmd = "Run all #{ group.title }"
-          Pry.commands.create_command group.name.to_s, cmd do
-            group "Guard"
-
-            def process
-              Pry.run_command "all #{ match }"
-            end
-          end
-        end
-      end
-
-      # Configures the pry prompt to see `guard` instead of
-      # `pry`.
-      #
-      def _configure_prompt
-        Pry.config.prompt = [_prompt(">"), _prompt("*")]
-      end
-
-      # Returns the plugins scope, or the groups scope ready for display in the
-      # prompt.
-      #
-      def _scope_for_prompt
-        titles = Guard.state.scope.titles.join(",")
-        titles == "all" ? "" : titles + " "
-      end
-
-      # Returns a proc that will return itself a string ending with the given
-      # `ending_char` when called.
-      #
-      def _prompt(ending_char)
-        proc do |target_self, nest_level, pry|
-          history = pry.input_array.size
-          process = Guard.listener.paused? ? "pause" : "guard"
-          level = ":#{ nest_level }" unless nest_level.zero?
-
-          "[#{ history }] #{ _scope_for_prompt }#{ process }"\
-            "(#{ _clip_name(target_self) })#{ level }#{ ending_char } "
-        end
-      end
-
-      def _clip_name(target)
-        Pry.view_clip(target)
-      end
-    end
-  end
-end