geminfo 0.1.0 → 0.1.1

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

@@ -1,26 +0,0 @@
-require "guard/jobs/base"
-require "guard/ui"
-
-module Guard
-  module Jobs
-    class Sleep < Base
-      def foreground
-        UI.debug "Guards jobs done. Sleeping..."
-        sleep
-        UI.debug "Sleep interrupted by events."
-        :stopped
-      rescue Interrupt
-        UI.debug "Sleep interrupted by user."
-        :exit
-      end
-
-      def background
-        Thread.main.wakeup
-      end
-
-      def handle_interrupt
-        Thread.main.raise Interrupt
-      end
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/notifier.rb

@@ -1,71 +0,0 @@
-require "notiffany/notifier"
-require "guard/ui"
-
-module Guard
-  class Notifier
-    def self.connect(options = {})
-      @notifier ||= nil
-      fail "Already connected!" if @notifier
-      begin
-        opts = options.merge(namespace: "guard", logger: UI)
-        @notifier = Notiffany.connect(opts)
-      rescue Notiffany::Notifier::Detected::UnknownNotifier => e
-        UI.error "Failed to setup notification: #{e.message}"
-        fail
-      end
-    end
-
-    def self.disconnect
-      @notifier.disconnect
-      @notifier = nil
-    end
-
-    DEPRECATED_IMPLICIT_CONNECT = "Calling Notiffany::Notifier.notify()"\
-                                  " without a prior Notifier.connect() is"\
-                                  " deprecated"
-
-    def self.notify(message, options = {})
-      unless @notifier
-        # TODO: reenable again?
-        # UI.deprecation(DEPRECTED_IMPLICIT_CONNECT)
-        connect(notify: true)
-      end
-
-      @notifier.notify(message, options)
-    rescue RuntimeError => e
-      UI.error "Notification failed for #{@notifier.class.name}: #{e.message}"
-      UI.debug e.backtrace.join("\n")
-    end
-
-    def self.turn_on
-      @notifier.turn_on
-    end
-
-    def self.toggle
-      unless @notifier.enabled?
-        UI.error NOTIFICATIONS_DISABLED
-        return
-      end
-
-      if @notifier.active?
-        UI.info "Turn off notifications"
-        @notifier.turn_off
-        return
-      end
-
-      @notifier.turn_on
-    end
-
-    # Used by dsl describer
-    def self.supported
-      Notiffany::Notifier::SUPPORTED.inject(:merge)
-    end
-
-    # Used by dsl describer
-    def self.detected
-      @notifier.available.map do |mod|
-        { name: mod.name.to_sym, options: mod.options }
-      end
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/options.rb

@@ -1,17 +0,0 @@
-require "thor/core_ext/hash_with_indifferent_access"
-
-module Guard
-  # A class that holds options. Can be instantiated with default options.
-  #
-  class Options < Thor::CoreExt::HashWithIndifferentAccess
-    # Initializes an Guard::Options object. `default_opts` is merged into
-    # `opts`.
-    #
-    # @param [Hash] opts the options
-    # @param [Hash] default_opts the default options
-    #
-    def initialize(opts = {}, default_opts = {})
-      super(default_opts.merge(opts || {}))
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/plugin.rb

@@ -1,303 +0,0 @@
-require "guard"
-require "guard/internals/groups"
-
-module Guard
-  # Base class from which every Guard plugin implementation must inherit.
-  #
-  # Guard will trigger the {#start}, {#stop}, {#reload}, {#run_all} and
-  # {#run_on_changes} ({#run_on_additions}, {#run_on_modifications} and
-  # {#run_on_removals}) task methods depending on user interaction and file
-  # modification.
-  #
-  # {#run_on_changes} could be implemented to handle all the changes task case
-  # (additions, modifications, removals) in once, or each task can be
-  # implemented separately with a specific behavior.
-  #
-  # In each of these Guard task methods you have to implement some work when
-  # you want to support this kind of task. The return value of each Guard task
-  # method is not evaluated by Guard, but it'll be passed to the "_end" hook
-  # for further evaluation. You can throw `:task_has_failed` to indicate that
-  # your Guard plugin method was not successful, and successive Guard plugin
-  # tasks will be aborted when the group has set the `:halt_on_fail` option.
-  #
-  # @see Guard::Group
-  #
-  # @example Throw :task_has_failed
-  #
-  #   def run_all
-  #     if !runner.run(['all'])
-  #       throw :task_has_failed
-  #     end
-  #   end
-  #
-  # Each Guard plugin should provide a template Guardfile located within the Gem
-  # at `lib/guard/guard-name/templates/Guardfile`.
-  #
-  # Watchers for a Guard plugin should return a file path or an array of files
-  # paths to Guard, but if your Guard plugin wants to allow any return value
-  # from a watcher, you can set the `any_return` option to true.
-  #
-  # If one of those methods raises an exception other than `:task_has_failed`,
-  # the `Guard::GuardName` instance will be removed from the active Guard
-  # plugins.
-  #
-  class Plugin
-    TEMPLATE_FORMAT = "%s/lib/guard/%s/templates/Guardfile"
-
-    require "guard/ui"
-
-    # Get all callbacks registered for all Guard plugins present in the
-    # Guardfile.
-    #
-    def self.callbacks
-      @callbacks ||= Hash.new { |hash, key| hash[key] = [] }
-    end
-
-    # Add a callback.
-    #
-    # @param [Block] listener the listener to notify
-    # @param [Guard::Plugin] guard_plugin the Guard plugin to add the callback
-    # @param [Array<Symbol>] events the events to register
-    #
-    def self.add_callback(listener, guard_plugin, events)
-      Array(events).each do |event|
-        callbacks[[guard_plugin, event]] << listener
-      end
-    end
-
-    # Notify a callback.
-    #
-    # @param [Guard::Plugin] guard_plugin the Guard plugin to add the callback
-    # @param [Symbol] event the event to trigger
-    # @param [Array] args the arguments for the listener
-    #
-    def self.notify(guard_plugin, event, *args)
-      callbacks[[guard_plugin, event]].each do |listener|
-        listener.call(guard_plugin, event, *args)
-      end
-    end
-
-    # Reset all callbacks.
-    #
-    # TODO: remove (not used anywhere)
-    def self.reset_callbacks!
-      @callbacks = nil
-    end
-
-    # When event is a Symbol, {#hook} will generate a hook name
-    # by concatenating the method name from where {#hook} is called
-    # with the given Symbol.
-    #
-    # @example Add a hook with a Symbol
-    #
-    #   def run_all
-    #     hook :foo
-    #   end
-    #
-    # Here, when {Guard::Plugin#run_all} is called, {#hook} will notify
-    # callbacks registered for the "run_all_foo" event.
-    #
-    # When event is a String, {#hook} will directly turn the String
-    # into a Symbol.
-    #
-    # @example Add a hook with a String
-    #
-    #   def run_all
-    #     hook "foo_bar"
-    #   end
-    #
-    # When {Guard::Plugin::run_all} is called, {#hook} will notify
-    # callbacks registered for the "foo_bar" event.
-    #
-    # @param [Symbol, String] event the name of the Guard event
-    # @param [Array] args the parameters are passed as is to the callbacks
-    #   registered for the given event.
-    #
-    def hook(event, *args)
-      hook_name = if event.is_a? Symbol
-                    calling_method = caller[0][/`([^']*)'/, 1]
-                    "#{ calling_method }_#{ event }"
-                  else
-                    event
-                  end
-
-      UI.debug "Hook :#{ hook_name } executed for #{ self.class }"
-
-      self.class.notify(self, hook_name.to_sym, *args)
-    end
-
-    attr_accessor :group, :watchers, :callbacks, :options
-
-    # Returns the non-namespaced class name of the plugin
-    #
-    #
-    # @example Non-namespaced class name for Guard::RSpec
-    #   Guard::RSpec.non_namespaced_classname
-    #   #=> "RSpec"
-    #
-    # @return [String]
-    #
-    def self.non_namespaced_classname
-      to_s.sub("Guard::", "")
-    end
-
-    # Returns the non-namespaced name of the plugin
-    #
-    #
-    # @example Non-namespaced name for Guard::RSpec
-    #   Guard::RSpec.non_namespaced_name
-    #   #=> "rspec"
-    #
-    # @return [String]
-    #
-    def self.non_namespaced_name
-      non_namespaced_classname.downcase
-    end
-
-    # Specify the source for the Guardfile template.
-    # Each Guard plugin can redefine this method to add its own logic.
-    #
-    # @param [String] plugin_location the plugin location
-    #
-    def self.template(plugin_location)
-      File.read TEMPLATE_FORMAT % [plugin_location, non_namespaced_name]
-    end
-
-    # Called once when Guard starts. Please override initialize method to
-    # init stuff.
-    #
-    # @raise [:task_has_failed] when start has failed
-    # @return [Object] the task result
-    #
-    # @!method start
-
-    # Called when `stop|quit|exit|s|q|e + enter` is pressed (when Guard
-    # quits).
-    #
-    # @raise [:task_has_failed] when stop has failed
-    # @return [Object] the task result
-    #
-    # @!method stop
-
-    # Called when `reload|r|z + enter` is pressed.
-    # This method should be mainly used for "reload" (really!) actions like
-    # reloading passenger/spork/bundler/...
-    #
-    # @raise [:task_has_failed] when reload has failed
-    # @return [Object] the task result
-    #
-    # @!method reload
-
-    # Called when just `enter` is pressed
-    # This method should be principally used for long action like running all
-    # specs/tests/...
-    #
-    # @raise [:task_has_failed] when run_all has failed
-    # @return [Object] the task result
-    #
-    # @!method run_all
-
-    # Default behaviour on file(s) changes that the Guard plugin watches.
-    #
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_changes has failed
-    # @return [Object] the task result
-    #
-    # @!method run_on_changes(paths)
-
-    # Called on file(s) additions that the Guard plugin watches.
-    #
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_additions has failed
-    # @return [Object] the task result
-    #
-    # @!method run_on_additions(paths)
-
-    # Called on file(s) modifications that the Guard plugin watches.
-    #
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_modifications has failed
-    # @return [Object] the task result
-    #
-    # @!method run_on_modifications(paths)
-
-    # Called on file(s) removals that the Guard plugin watches.
-    #
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_removals has failed
-    # @return [Object] the task result
-    #
-    # @!method run_on_removals(paths)
-
-    # Returns the plugin's name (without "guard-").
-    #
-    # @example Name for Guard::RSpec
-    #   Guard::RSpec.new.name
-    #   #=> "rspec"
-    #
-    # @return [String]
-    #
-    def name
-      @name ||= self.class.non_namespaced_name
-    end
-
-    # Returns the plugin's class name without the Guard:: namespace.
-    #
-    # @example Title for Guard::RSpec
-    #   Guard::RSpec.new.title
-    #   #=> "RSpec"
-    #
-    # @return [String]
-    #
-    def title
-      @title ||= self.class.non_namespaced_classname
-    end
-
-    # String representation of the plugin.
-    #
-    # @example String representation of an instance of the Guard::RSpec plugin
-    #
-    #   Guard::RSpec.new.title
-    #   #=> "#<Guard::RSpec @name=rspec @group=#<Guard::Group @name=default
-    #   @options={}> @watchers=[] @callbacks=[] @options={all_after_pass:
-    #   true}>"
-    #
-    # @return [String] the string representation
-    #
-    def to_s
-      "#<#{self.class} @name=#{name} @group=#{group} @watchers=#{watchers}"\
-        " @callbacks=#{callbacks} @options=#{options}>"
-    end
-
-    private
-
-    # Initializes a Guard plugin.
-    # Don't do any work here, especially as Guard plugins get initialized even
-    # if they are not in an active group!
-    #
-    # @param [Hash] options the Guard plugin options
-    # @option options [Array<Guard::Watcher>] watchers the Guard plugin file
-    #   watchers
-    # @option options [Symbol] group the group this Guard plugin belongs to
-    # @option options [Boolean] any_return allow any object to be returned from
-    #   a watcher
-    #
-    def initialize(options = {})
-      group_name = options.delete(:group) { :default }
-      @group = Guard.state.session.groups.add(group_name)
-      @watchers = options.delete(:watchers) { [] }
-      @callbacks = options.delete(:callbacks) { [] }
-      @options = options
-      _register_callbacks
-    end
-
-    # Add all the Guard::Plugin's callbacks to the global @callbacks array
-    # that's used by Guard to know which callbacks to notify.
-    #
-    def _register_callbacks
-      callbacks.each do |callback|
-        self.class.add_callback(callback[:listener], self, callback[:events])
-      end
-    end
-  end
-end

data/path/gems/guard-2.13.0/lib/guard/plugin_util.rb

@@ -1,188 +0,0 @@
-require "guard/ui"
-
-module Guard
-  # This class contains useful methods to:
-  #
-  # * Fetch all the Guard plugins names;
-  # * Initialize a plugin, get its location;
-  # * Return its class name;
-  # * Add its template to the Guardfile.
-  #
-  class PluginUtil
-    ERROR_NO_GUARD_OR_CLASS = "Could not load 'guard/%s' or" \
-      " find class Guard::%s"
-
-    INFO_ADDED_GUARD_TO_GUARDFILE = "%s guard added to Guardfile,"\
-      " feel free to edit it"
-
-    attr_accessor :name
-
-    # Returns a list of Guard plugin Gem names installed locally.
-    #
-    # @return [Array<String>] a list of Guard plugin gem names
-    #
-    def self.plugin_names
-      valid = Gem::Specification.find_all.select do |gem|
-        _gem_valid?(gem)
-      end
-
-      valid.map { |x| x.name.sub(/^guard-/, "") }.uniq
-    end
-
-    # Initializes a new `Guard::PluginUtil` object.
-    #
-    # @param [String] name the name of the Guard plugin
-    #
-    def initialize(name)
-      @name = name.to_s.sub(/^guard-/, "")
-    end
-
-    # Initializes a new `Guard::Plugin` with the given `options` hash. This
-    # methods handles plugins that inherit from the deprecated `Guard::Guard`
-    # class as well as plugins that inherit from `Guard::Plugin`.
-    #
-    # @see Guard::Plugin
-    # @see https://github.com/guard/guard/wiki/Upgrading-to-Guard-2.0 How to
-    # upgrade for Guard 2.0
-    #
-    # @return [Guard::Plugin] the initialized plugin
-    # @return [Guard::Guard] the initialized plugin. This return type is
-    #   deprecated and the plugin's maintainer should update it to be
-    #   compatible with Guard 2.0. For more information on how to upgrade for
-    #   Guard 2.0, please head over to:
-    #   https://github.com/guard/guard/wiki/Upgrading-to-Guard-2.0
-    #
-    def initialize_plugin(options)
-      klass = plugin_class
-      fail "Could not load class: #{_constant_name.inspect}" unless klass
-      if klass.superclass.to_s == "Guard::Guard"
-        klass.new(options.delete(:watchers), options)
-      else
-        begin
-          klass.new(options)
-        rescue ArgumentError => e
-          fail "Failed to call #{klass}.new(options): #{e}"
-        end
-      end
-    end
-
-    # Locates a path to a Guard plugin gem.
-    #
-    # @return [String] the full path to the plugin gem
-    #
-    def plugin_location
-      @plugin_location ||= _full_gem_path("guard-#{name}")
-    rescue Gem::LoadError
-      UI.error "Could not find 'guard-#{ name }' gem path."
-    end
-
-    # Tries to load the Guard plugin main class. This transforms the supplied
-    # plugin name into a class name:
-    #
-    # * `guardname` will become `Guard::Guardname`
-    # * `dashed-guard-name` will become `Guard::DashedGuardName`
-    # * `underscore_guard_name` will become `Guard::UnderscoreGuardName`
-    #
-    # When no class is found with the strict case sensitive rules, another
-    # try is made to locate the class without matching case:
-    #
-    # * `rspec` will find a class `Guard::RSpec`
-    #
-    # @option options [Boolean] fail_gracefully whether error messages should
-    # not be printed
-    #
-    # @return [Class, nil] the loaded class
-    #
-    def plugin_class(options = {})
-      options = { fail_gracefully: false }.merge(options)
-
-      const = _plugin_constant
-      fail TypeError, "no constant: #{_constant_name}" unless const
-      @plugin_class ||= Guard.const_get(const)
-
-    rescue TypeError
-      begin
-        require "guard/#{ name.downcase }"
-        const = _plugin_constant
-        @plugin_class ||= Guard.const_get(const)
-
-      rescue TypeError => error
-        UI.error "Could not find class Guard::#{ _constant_name }"
-        UI.error error.backtrace.join("\n")
-        # TODO: return value or move exception higher
-      rescue LoadError => error
-        unless options[:fail_gracefully]
-          UI.error ERROR_NO_GUARD_OR_CLASS % [name.downcase, _constant_name]
-          UI.error "Error is: #{error}"
-          UI.error error.backtrace.join("\n")
-          # TODO: return value or move exception higher
-        end
-      end
-    end
-
-    # Adds a plugin's template to the Guardfile.
-    #
-    def add_to_guardfile
-      klass = plugin_class # call here to avoid failing later
-
-      require "guard/guardfile/evaluator"
-      # TODO: move this to Generator?
-      options = Guard.state.session.evaluator_options
-      evaluator = Guardfile::Evaluator.new(options)
-      begin
-        evaluator.evaluate
-      rescue Guard::Guardfile::Evaluator::NoPluginsError
-      end
-
-      if evaluator.guardfile_include?(name)
-        UI.info "Guardfile already includes #{ name } guard"
-      else
-        content = File.read("Guardfile")
-        File.open("Guardfile", "wb") do |f|
-          f.puts(content)
-          f.puts("")
-          f.puts(klass.template(plugin_location))
-        end
-
-        UI.info INFO_ADDED_GUARD_TO_GUARDFILE % name
-      end
-    end
-
-    private
-
-    # Returns the constant for the current plugin.
-    #
-    # @example Returns the constant for a plugin
-    #   > Guard::PluginUtil.new('rspec').send(:_plugin_constant)
-    #   => Guard::RSpec
-    #
-    def _plugin_constant
-      @_plugin_constant ||= Guard.constants.detect do |c|
-        c.to_s.downcase == _constant_name.downcase
-      end
-    end
-
-    # Guesses the most probable name for the current plugin based on its name.
-    #
-    # @example Returns the most probable name for a plugin
-    #   > Guard::PluginUtil.new('rspec').send(:_constant_name)
-    #   => "Rspec"
-    #
-    def _constant_name
-      @_constant_name ||= name.gsub(/\/(.?)/) { "::#{ $1.upcase }" }.
-                          gsub(/(?:^|[_-])(.)/) { $1.upcase }
-    end
-
-    def self._gem_valid?(gem)
-      return false if gem.name == "guard-compat"
-      return true if gem.name =~ /^guard-/
-      full_path = gem.full_gem_path
-      file = File.join(full_path, "lib", "guard", "#{gem.name}.rb")
-      File.exist?(file)
-    end
-
-    def _full_gem_path(name)
-      Gem::Specification.find_by_name(name).full_gem_path
-    end
-  end
-end