guard 1.4.0 → 2.18.0

data/lib/guard/internals/plugins.rb

@@ -0,0 +1,53 @@
+require "guard/plugin_util"
+require "guard/group"
+require "guard/plugin"
+
+module Guard
+  # @private api
+  module Internals
+    class Plugins
+      def initialize
+        @plugins = []
+      end
+
+      def all(filter = nil)
+        return @plugins if filter.nil?
+        matcher = matcher_for(filter)
+        @plugins.select { |plugin| matcher.call(plugin) }
+      end
+
+      def remove(plugin)
+        @plugins.delete(plugin)
+      end
+
+      # TODO: should it allow duplicates? (probably yes because of different
+      # configs or groups)
+      def add(name, options)
+        @plugins << PluginUtil.new(name).initialize_plugin(options)
+      end
+
+      private
+
+      def matcher_for(filter)
+        case filter
+        when String, Symbol
+          shortname = filter.to_s.downcase.delete("-")
+          ->(plugin) { plugin.name == shortname }
+        when Regexp
+          ->(plugin) { plugin.name =~ filter }
+        when Hash
+          lambda do |plugin|
+            filter.all? do |k, v|
+              case k
+              when :name
+                plugin.name == v.to_s.downcase.delete("-")
+              when :group
+                plugin.group.name == v.to_sym
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/guard/internals/queue.rb

@@ -0,0 +1,51 @@
+module Guard
+  module Internals
+    class Queue
+      def initialize(commander)
+        @commander = commander
+        @queue = ::Queue.new
+      end
+
+      # Process the change queue, running tasks within the main Guard thread
+      def process
+        actions = []
+        changes = { modified: [], added: [], removed: [] }
+
+        while pending?
+          if (item = @queue.pop).first.is_a?(Symbol)
+            actions << item
+          else
+            item.each { |key, value| changes[key] += value }
+          end
+        end
+
+        _run_actions(actions)
+        return if changes.values.all?(&:empty?)
+        Runner.new.run_on_changes(*changes.values)
+      end
+
+      def pending?
+        !@queue.empty?
+      end
+
+      def <<(changes)
+        @queue << changes
+      end
+
+      private
+
+      def _run_actions(actions)
+        actions.each do |action_args|
+          args = action_args.dup
+          namespaced_action = args.shift
+          action = namespaced_action.to_s.sub(/^guard_/, "")
+          if @commander.respond_to?(action)
+            @commander.send(action, *args)
+          else
+            fail "Unknown action: #{action.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/guard/internals/scope.rb

@@ -0,0 +1,121 @@
+require "guard"
+
+module Guard
+  # @private api
+  module Internals
+    class Scope
+      def initialize
+        @interactor_plugin_scope = []
+        @interactor_group_scope = []
+      end
+
+      def to_hash
+        {
+          plugins: _hashify_scope(:plugin),
+          groups: _hashify_scope(:group)
+        }.dup.freeze
+      end
+
+      # TODO: refactor
+      def grouped_plugins(scope = { plugins: [], groups: [] })
+        items = nil
+        plugins = _find_non_empty_scope(:plugins, scope)
+        if plugins
+          items = Array(plugins).map { |plugin| _instantiate(:plugin, plugin) }
+        end
+
+        unless items
+          # TODO: no coverage here!!
+          found = _find_non_empty_scope(:groups, scope)
+          found ||= Guard.state.session.groups.all
+          groups = Array(found).map { |group| _instantiate(:group, group) }
+          if groups.any? { |g| g.name == :common }
+            items = groups
+          else
+            items = ([_instantiate(:group, :common)] + Array(found)).compact
+          end
+        end
+
+        items.map do |plugin_or_group|
+          group = nil
+          plugins = [plugin_or_group]
+          if plugin_or_group.is_a?(Group)
+            # TODO: no coverage here!
+            group = plugin_or_group
+            plugins = Guard.state.session.plugins.all(group: group.name)
+          end
+          [group, plugins]
+        end
+      end
+
+      def from_interactor(scope)
+        @interactor_plugin_scope = Array(scope[:plugins])
+        @interactor_group_scope = Array(scope[:groups])
+      end
+
+      def titles(scope = nil)
+        hash = scope || to_hash
+        plugins = hash[:plugins]
+        groups = hash[:groups]
+        return plugins.map(&:title) unless plugins.nil? || plugins.empty?
+        return hash[:groups].map(&:title) unless groups.nil? || groups.empty?
+        ["all"]
+      end
+
+      private
+
+      # TODO: move to session
+      def _scope_names(new_scope, name)
+        items = Array(new_scope[:"#{name}s"] || new_scope[name]) if items.empty?
+
+        # Convert objects to names
+        items.map { |p| p.respond_to?(:name) ? p.name : p }
+      end
+
+      # TODO: let the Plugins and Groups classes handle this?
+      # TODO: why even instantiate?? just to check if it exists?
+      def _hashify_scope(type)
+        # TODO: get cmdline passed to initialize above?
+        cmdline = Array(Guard.state.session.send("cmdline_#{type}s"))
+        guardfile = Guard.state.session.send(:"guardfile_#{type}_scope")
+        interactor = instance_variable_get(:"@interactor_#{type}_scope")
+
+        # TODO: session should decide whether to use cmdline or guardfile -
+        # since it has access to both variables
+        items = [interactor, cmdline, guardfile].detect do |source|
+          !source.empty?
+        end
+
+        # TODO: not tested when groups/plugins given don't exist
+
+        # TODO: should already be instantiated
+        Array(items).map do |obj|
+          if obj.respond_to?(:name)
+            obj
+          else
+            name = obj
+            (type == :group ? _groups : _plugins).all(name).first
+          end
+        end.compact
+      end
+
+      def _instantiate(meth, obj)
+        # TODO: no coverage
+        return obj unless obj.is_a?(Symbol) || obj.is_a?(String)
+        Guard.state.session.send("#{meth}s".to_sym).all(obj).first
+      end
+
+      def _find_non_empty_scope(type, local_scope)
+        [Array(local_scope[type]), to_hash[type]].map(&:compact).detect(&:any?)
+      end
+
+      def _groups
+        Guard.state.session.groups
+      end
+
+      def _plugins
+        Guard.state.session.plugins
+      end
+    end
+  end
+end

data/lib/guard/internals/session.rb

@@ -0,0 +1,180 @@
+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
+
+      attr_reader :interactor_name
+
+      # 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/lib/guard/internals/state.rb

@@ -0,0 +1,25 @@
+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/lib/guard/internals/tracing.rb

@@ -0,0 +1,33 @@
+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/lib/guard/internals/traps.rb

@@ -0,0 +1,10 @@
+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/lib/guard/jobs/base.rb

@@ -0,0 +1,21 @@
+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