guard 2.10.2 → 2.10.3

data/lib/guard/internals/environment.rb

@@ -1,93 +0,0 @@
-module Guard
-  # @private api
-  module Internals
-    class Environment
-      class Error < ArgumentError
-      end
-
-      class MethodError < Error
-        def initialize(meth)
-          @meth = meth
-        end
-      end
-
-      class NoMethodError < MethodError
-        def message
-          format("No such method %s", @meth.inspect)
-        end
-      end
-
-      class AlreadyExistsError < MethodError
-        def message
-          format("Method %s already exists", @meth.inspect)
-        end
-      end
-
-      class Loader
-        def initialize(meth)
-          @bool = meth.to_s.end_with?("?")
-        end
-
-        def load(raw_value, &callback)
-          return callback.call(raw_value) if callback
-          @bool ? _to_bool(raw_value) : raw_value
-        end
-
-        private
-
-        def _to_bool(raw_value)
-          case raw_value
-          when nil
-            nil
-          when ""
-            fail ArgumentError, "Can't convert empty string into Bool"
-          when "0", "false"
-            false
-          else
-            true
-          end
-        end
-      end
-
-      class Dumper
-        def initialize
-        end
-
-        def dump(raw_value, &callback)
-          return callback.call(raw_value) if callback
-          raw_value.nil? ? nil : raw_value.to_s
-        end
-      end
-
-      def initialize(namespace)
-        @namespace = namespace
-        @methods = {}
-      end
-
-      def create_method(meth, &block)
-        fail AlreadyExistsError, meth if @methods.key?(meth)
-        @methods[meth] = block
-      end
-
-      def method_missing(*args)
-        meth, raw_value = *args
-        fail NoMethodError, meth unless @methods.key?(meth)
-
-        callback = @methods[meth]
-        env_name = format("%s_%s", @namespace, _sanitize(meth))
-
-        if args.size == 2
-          ENV[env_name] = Dumper.new.dump(raw_value, &callback)
-        else
-          Loader.new(meth).load(ENV[env_name], &callback)
-        end
-      end
-
-      private
-
-      def _sanitize(meth)
-        meth[/^([^=?]*)[=?]?$/, 1].upcase
-      end
-    end
-  end
-end

data/lib/guard/internals/session.rb.orig

@@ -1,148 +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
-    # This class contains variables set during
-    # evaluation of the guardfile (and are reset
-    # before reevaluation)
-    class Session
-      attr_reader :options
-      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 = Internals::Plugins.new
-        @groups = Internals::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 = []
-      end
-
-      def guardfile_scope(scope)
-        opts = scope.dup
-        @guardfile_plugin_scope = Array(opts.delete(:plugins))
-        @guardfile_group_scope = Array(opts.delete(:groups))
-        fail "Unknown options: #{opts.inspect}" unless opts.empty?
-      end
-
-      attr_reader :guardfile_group_scope
-      attr_reader :guardfile_plugin_scope
-
-      def guardfile_ignore
-        fail NotImplementedError
-      end
-
-      def guardfile_ignore_bang
-        fail NotImplementedError
-      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
-        { notify: @options[:notify] }
-      end
-
-      def interactor_name
-        @interactor_name
-      end
-    end
-  end
-end

data/lib/guard/plugin_util.rb.orig

@@ -1,182 +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
-      ::Guard::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")
-      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")
-        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)
-      evaluator.evaluate
-      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

data/lib/guard/reevaluator.rb

@@ -1,61 +0,0 @@
-require "guard/plugin"
-require "guard/guardfile/evaluator"
-require "guard/runner"
-require "guard/internals/helpers"
-
-module Guard
-  class Reevaluator < Plugin
-    include Internals::Helpers
-
-    def run_on_modifications(files)
-      # TODO: this is messed up, because reevaluator adds itself
-      # anyway, so it know what the path is
-      evaluator = _evaluator
-      path = evaluator.path
-      return unless files.any? { |file| path == Pathname(file) }
-      reevaluate
-    rescue Dsl::Error, Guardfile::Evaluator::Error => e
-      UI.warning("Failed to reevaluate file: #{e}")
-      _add_self_to_plugins
-      throw :task_has_failed
-    end
-
-    def reevaluate
-      evaluator = _evaluator
-      return if evaluator.inline?
-
-      Runner.new.run(:stop)
-
-      Guard.state.reset_session
-
-      Notifier.disconnect
-      evaluator.evaluate
-      Notifier.connect(Guard.state.session.notify_options)
-
-      if Guard.send(:_pluginless_guardfile?)
-        Notifier.notify(
-          "No plugins found in Guardfile, please add at least one.",
-          title: "Guard re-evaluate",
-          image: :failed)
-      else
-        msg = "Guardfile has been re-evaluated."
-        UI.info(msg)
-        Notifier.notify(msg, title: "Guard re-evaluate")
-        Runner.new.run(:start)
-      end
-    end
-
-    private
-
-    def _evaluator
-      Guardfile::Evaluator.new(Guard.state.session.evaluator_options)
-    end
-
-    def _add_self_to_plugins
-      # TODO: do this on reload as well
-      pattern = _relative_pathname(_evaluator.path).to_s
-      options = { watchers: [Watcher.new(pattern)], group: :common }
-      Guard.state.session.plugins.add(:reevaluator, options)
-    end
-  end
-end