guard 2.9.0 → 2.9.1

data/lib/guard/interactor.rb

@@ -68,10 +68,12 @@ module Guard
         scopes  = { plugins: [], groups: [] }
         unknown = []
 
+        session = Guard.state.session
+
         entries.each do |entry|
-          if plugin = ::Guard.plugin(entry)
+          if plugin = session.plugins.all(entry).first
             scopes[:plugins] << plugin
-          elsif group = ::Guard.group(entry)
+          elsif group = session.groups.all(entry).first
             scopes[:groups] << group
           else
             unknown << entry

data/lib/guard/internals/groups.rb

@@ -0,0 +1,40 @@
+require "guard/group"
+
+module Guard
+  # @private api
+  module Internals
+    class Groups
+      DEFAULT_GROUPS = [:common, :default]
+
+      def initialize
+        @groups = DEFAULT_GROUPS.map { |name| Group.new(name) }
+      end
+
+      def all(filter = nil)
+        return @groups if filter.nil?
+        matcher = matcher_for(filter)
+        @groups.select { |group| matcher.call(group) }
+      end
+
+      def add(name, options = {})
+        all(name).first || Group.new(name, options).tap do |group|
+          fail if name == :specs && options.empty?
+          @groups << group
+        end
+      end
+
+      private
+
+      def matcher_for(filter)
+        case filter
+        when String, Symbol
+          lambda { |group| group.name == filter.to_sym }
+        when Regexp
+          lambda { |group| group.name.to_s =~ filter }
+        else
+          fail "Invalid filter: #{filter.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/guard/internals/plugins.rb

@@ -0,0 +1,51 @@
+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.gsub("-", "")
+          lambda { |plugin| plugin.name == shortname }
+        when Regexp
+          lambda { |plugin| plugin.name =~ filter }
+        when Hash
+          lambda do |plugin|
+            filter.all? do |k, v|
+              case k
+              when :name
+                plugin.name == v.to_s.downcase.gsub("-", "")
+              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,50 @@
+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,110 @@
+module Guard
+  # @private api
+  module Internals
+    class Scope
+      def initialize
+        @interactor_plugin_scope = []
+        @interactor_group_scope = []
+      end
+
+      def to_hash
+        {
+          plugins: _build_scope(:plugin),
+          groups: _build_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
+        return hash[:plugins].map(&:title) unless hash[:plugins].empty?
+        return hash[:groups].map(&:title) unless hash[: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 _build_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: should already be instantiated
+        Array(items).map do |name|
+          (type == :group ? _groups : _plugins).all(name).first
+        end
+      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,135 @@
+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
+
+      # TODO: not tested
+      def clear?
+        @clear
+      end
+
+      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/internals/state.rb

@@ -0,0 +1,33 @@
+require "guard/group"
+
+require "guard/plugin_util"
+require "guard/internals/session"
+require "guard/internals/scope"
+
+module Guard
+  module Internals
+    class State
+      # Minimal setup for non-interactive commands (list, init, show, etc.)
+      def initialize(cmdline_opts)
+        # NOTE: this is reset during reevaluation
+        @session = Session.new(cmdline_opts)
+
+        # NOTE: this should persist across reevaluate() calls
+        @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
+
+      # @private api
+      # used to clear instance variables during reevaluation
+      def reset_session
+        options = @session.options.dup
+        @session = Session.new(options)
+      end
+    end
+  end
+end

data/lib/guard/jobs/pry_wrapper.rb

@@ -14,22 +14,22 @@ module Guard
     class TerminalSettings
       def initialize
         @settings = nil
-        @works = ::Guard::Sheller.run("hash", "stty") || false
+        @works = Sheller.run("hash", "stty") || false
       end
 
       def restore
         return unless configurable? && @settings
-        ::Guard::Sheller.run("stty #{ @setting } 2>#{IO::NULL}")
+        Sheller.run("stty #{ @setting } 2>#{IO::NULL}")
       end
 
       def save
         return unless configurable?
-        @settings = ::Guard::Sheller.stdout("stty -g 2>#{IO::NULL}").chomp
+        @settings = Sheller.stdout("stty -g 2>#{IO::NULL}").chomp
       end
 
       def echo
         return unless configurable?
-        ::Guard::Sheller.run("stty echo 2>#{IO::NULL}")
+        Sheller.run("stty echo 2>#{IO::NULL}")
       end
 
       def configurable?
@@ -69,17 +69,15 @@ module Guard
       end
 
       def foreground
-        ::Guard::UI.debug "Start interactor"
+        UI.debug "Start interactor"
         @terminal_settings.save
 
-        _start_pry
-        @thread.join
-        thread = @thread
+        _switch_to_pry
         # TODO: rename :stopped to continue
-        thread.nil? ? :stopped : :exit
+        _killed? ? :stopped : :exit
       ensure
-        ::Guard::UI.reset_line
-        ::Guard::UI.debug "Interactor was stopped or killed"
+        UI.reset_line
+        UI.debug "Interactor was stopped or killed"
         @terminal_settings.restore
       end
 
@@ -97,13 +95,24 @@ module Guard
 
       attr_reader :thread
 
-      def _start_pry
+      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
@@ -123,13 +132,13 @@ module Guard
 
         _add_hooks(options)
 
-        ::Guard::Commands::All.import
-        ::Guard::Commands::Change.import
-        ::Guard::Commands::Notification.import
-        ::Guard::Commands::Pause.import
-        ::Guard::Commands::Reload.import
-        ::Guard::Commands::Show.import
-        ::Guard::Commands::Scope.import
+        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
@@ -215,7 +224,7 @@ module Guard
       # `rspec` is created that runs `all rspec`.
       #
       def _create_guard_commands
-        ::Guard.plugins.each do |guard_plugin|
+        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"
@@ -233,7 +242,7 @@ module Guard
       # `frontend` is created that runs `all frontend`.
       #
       def _create_group_commands
-        ::Guard.groups.each do |group|
+        Guard.state.session.groups.all.each do |group|
           next if group.name == :default
 
           cmd = "Run all #{ group.title }"
@@ -258,16 +267,8 @@ module Guard
       # prompt.
       #
       def _scope_for_prompt
-        scope_name = [:plugins, :groups].detect do |name|
-          ! ::Guard.scope[name].empty?
-        end
-        scope_name ? "#{_join_scope_for_prompt(scope_name)} " : ""
-      end
-
-      # Joins the scope corresponding to the given scope name with commas.
-      #
-      def _join_scope_for_prompt(scope_name)
-        ::Guard.scope[scope_name].map(&:title).join(",")
+        titles = Guard.state.scope.titles.join(",")
+        titles == "all" ? "" : titles + " "
       end
 
       # Returns a proc that will return itself a string ending with the given
@@ -276,7 +277,7 @@ module Guard
       def _prompt(ending_char)
         proc do |target_self, nest_level, pry|
           history = pry.input_array.size
-          process = ::Guard.listener.paused? ? "pause" : "guard"
+          process = Guard.listener.paused? ? "pause" : "guard"
           level   = ":#{ nest_level }" unless nest_level.zero?
 
           "[#{ history }] #{ _scope_for_prompt }#{ process }"\