guard 1.8.3 → 2.0.0.pre

data/lib/guard/guardfile/evaluator.rb

@@ -0,0 +1,245 @@
+module Guard
+  module Guardfile
+
+    # This class is responsible for evaluating the Guardfile. It delegates
+    # to Guard::Dsl for the actual objects generation from the Guardfile content.
+    #
+    # @see Guard::Dsl
+    #
+    class Evaluator
+
+      attr_reader :options
+
+      # Initializes a new Guard::Guardfile::Evaluator object.
+      #
+      # @option opts [String] guardfile the path to a valid Guardfile
+      # @option opts [String] guardfile_contents a string representing the content of a valid Guardfile
+      #
+      def initialize(opts = {})
+        @options = ::Guard::Options.new([:guardfile, :guardfile_contents].reduce({}) { |h, key| h[key] = opts[key]; h })
+      end
+
+      # Evaluates the DSL methods in the `Guardfile`.
+      #
+      # @example Programmatically evaluate a Guardfile
+      #   Guard::Guardfile::Evaluator.new.evaluate_guardfile
+      #
+      # @example Programmatically evaluate a Guardfile with a custom Guardfile path
+      #   Guard::Guardfile::Evaluator.new(guardfile: '/Users/guardfile/MyAwesomeGuardfile').evaluate_guardfile
+      #
+      # @example Programmatically evaluate a Guardfile with an inline Guardfile
+      #   Guard::Guardfile::Evaluator.new(guardfile_contents: 'guard :rspec').evaluate_guardfile
+      #
+      def evaluate_guardfile
+        _fetch_guardfile_contents
+        _instance_eval_guardfile(guardfile_contents)
+      end
+
+      # Re-evaluates the `Guardfile` to update
+      # the current Guard configuration.
+      #
+      def reevaluate_guardfile
+        _before_reevaluate_guardfile
+        evaluate_guardfile
+        _after_reevaluate_guardfile
+      end
+
+      # Tests if the current `Guardfile` contains a specific Guard plugin.
+      #
+      # @example Programmatically test if a Guardfile contains a specific Guard plugin
+      #   File.read('Guardfile')
+      #   #=> "guard :rspec"
+      #
+      #   Guard::Guardfile::Evaluator.new.guardfile_include?('rspec)
+      #   #=> true
+      #
+      # @param [String] plugin_name the name of the Guard
+      # @return [Boolean] whether the Guard plugin has been declared
+      #
+      def guardfile_include?(plugin_name)
+        _guardfile_contents_without_user_config.match(/^guard\s*\(?\s*['":]#{ plugin_name }['"]?/)
+      end
+
+      # Gets the file path to the project `Guardfile`.
+      #
+      # @example Gets the path of the currently evaluated Guardfile
+      #   Dir.pwd
+      #   #=> "/Users/remy/Code/github/guard"
+      #
+      #   evaluator = Guard::Guardfile::Evaluator.new
+      #   evaluator.evaluate_guardfile
+      #   #=> nil
+      #
+      #   evaluator.guardfile_path
+      #   #=> "/Users/remy/Code/github/guard/Guardfile"
+      #
+      # @example Gets the "path" of an inline Guardfile
+      #   > Guard::Guardfile::Evaluator.new(guardfile_contents: 'guard :rspec').evaluate_guardfile
+      #   => nil
+      #
+      #   > Guard::Guardfile::Evaluator.new.guardfile_path
+      #   => "Inline Guardfile"
+      #
+      # @return [String] the path to the Guardfile or 'Inline Guardfile' if
+      #   the Guardfile has been specified via the `:guardfile_contents` option.
+      #
+      def guardfile_path
+        options.guardfile_path || ''
+      end
+
+      # Gets the content of the `Guardfile` concatenated with the global
+      # user configuration file.
+      #
+      # @example Programmatically get the content of the current Guardfile
+      #   Guard::Guardfile::Evaluator.new.guardfile_contents
+      #   #=> "guard :rspec"
+      #
+      # @return [String] the Guardfile content
+      #
+      def guardfile_contents
+        config = File.read(_user_config_path) if File.exist?(_user_config_path)
+        [_guardfile_contents_without_user_config, config].compact.join("\n")
+      end
+
+      private
+
+      # Gets the default path of the `Guardfile`. This returns the `Guardfile`
+      # from the current directory when existing, or the global `~/.Guardfile`.
+      #
+      # @return [String] the path to the Guardfile
+      #
+      def _guardfile_default_path
+        File.exist?(_local_guardfile_path) ? _local_guardfile_path : _home_guardfile_path
+      end
+
+      # Gets the content of the `Guardfile`.
+      #
+      # @return [String] the Guardfile content
+      #
+      def _guardfile_contents_without_user_config
+        options.guardfile_contents || ''
+      end
+
+      # Evaluates the content of the `Guardfile`.
+      #
+      # @param [String] contents the content to evaluate.
+      #
+      def _instance_eval_guardfile(contents)
+        ::Guard::Dsl.new.instance_eval(contents, options.guardfile_path, 1)
+      rescue => ex
+        ::Guard::UI.error "Invalid Guardfile, original error is:\n#{ $! }"
+        raise ex
+      end
+
+      # Gets the content to evaluate and stores it into
+      # the options as `:guardfile_contents`.
+      #
+      def _fetch_guardfile_contents
+        if options.guardfile_contents
+          ::Guard::UI.info 'Using inline Guardfile.'
+          options.guardfile_path = 'Inline Guardfile'
+
+        elsif options.guardfile
+          if File.exist?(options.guardfile)
+            _read_guardfile(options.guardfile)
+            ::Guard::UI.info "Using Guardfile at #{ options.guardfile }."
+          else
+            ::Guard::UI.error "No Guardfile exists at #{ options.guardfile }."
+            exit 1
+          end
+
+        else
+          if File.exist?(_guardfile_default_path)
+            _read_guardfile(_guardfile_default_path)
+          else
+            ::Guard::UI.error 'No Guardfile found, please create one with `guard init`.'
+            exit 1
+          end
+        end
+
+        unless _guardfile_contents_usable?
+          ::Guard::UI.error 'No Guard plugins found in Guardfile, please add at least one.'
+        end
+      end
+
+      # Reads the current `Guardfile` content.
+      #
+      # @param [String] guardfile_path the path to the Guardfile
+      #
+      def _read_guardfile(guardfile_path)
+        options.guardfile_path     = guardfile_path
+        options.guardfile_contents = File.read(guardfile_path)
+      rescue => ex
+        ::Guard::UI.error ex.inspect
+        ::Guard::UI.error("Error reading file #{ guardfile_path }")
+        exit 1
+      end
+
+      # Stops Guard and clear internal state
+      # before the Guardfile will be re-evaluated.
+      #
+      def _before_reevaluate_guardfile
+        ::Guard.runner.run(:stop)
+        ::Guard.reset_groups
+        ::Guard.reset_plugins
+        ::Guard::Notifier.clear_notifiers
+
+        options.guardfile_contents
+      end
+
+      # Starts Guard and notification and show a message
+      # after the Guardfile has been re-evaluated.
+      #
+      def _after_reevaluate_guardfile
+        ::Guard::Notifier.turn_on if ::Guard::Notifier.enabled?
+
+        if ::Guard.plugins.empty?
+          ::Guard::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.'
+          ::Guard::UI.info(msg)
+          ::Guard::Notifier.notify(msg, title: 'Guard re-evaluate')
+
+          ::Guard.runner.run(:start)
+        end
+      end
+
+      # Tests if the current `Guardfile` content is usable.
+      #
+      # @return [Boolean] if the Guardfile is usable
+      #
+      def _guardfile_contents_usable?
+        guardfile_contents && guardfile_contents =~ /guard/m
+      end
+
+      # The path to the `Guardfile` that is located at
+      # the directory, where Guard has been started from.
+      #
+      # @return [String] the path to the local Guardfile
+      #
+      def _local_guardfile_path
+        File.join(Dir.pwd, 'Guardfile')
+      end
+
+      # The path to the `.Guardfile` that is located at
+      # the users home directory.
+      #
+      # @return [String] the path to `~/.Guardfile`
+      #
+      def _home_guardfile_path
+        File.expand_path(File.join('~', '.Guardfile'))
+      end
+
+      # The path to the user configuration `.guard.rb`
+      # that is located at the users home directory.
+      #
+      # @return [String] the path to `~/.guard.rb`
+      #
+      def _user_config_path
+        File.expand_path(File.join('~', '.guard.rb'))
+      end
+
+    end
+
+  end
+end

data/lib/guard/guardfile/generator.rb

@@ -0,0 +1,89 @@
+module Guard
+  module Guardfile
+
+    # This class is responsible for generating the Guardfile and adding Guard'
+    # plugins' templates into it.
+    #
+    # @see Guard::CLI
+    #
+    class Generator
+
+      require 'guard'
+      require 'guard/ui'
+
+      attr_reader :options
+
+      # The Guardfile template for `guard init`
+      GUARDFILE_TEMPLATE = File.expand_path('../../../guard/templates/Guardfile', __FILE__)
+
+      # The location of user defined templates
+      HOME_TEMPLATES = File.expand_path('~/.guard/templates')
+
+      # Initialize a new `Guard::Guardfile::Generator` object.
+      #
+      # @param [Hash] options The options for creating a Guardfile
+      # @option options [Boolean] :abort_on_existence Whether to abort or not
+      #   when a Guardfile already exists
+      #
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Creates the initial Guardfile template when it does not
+      # already exist.
+      #
+      # @see Guard::CLI#init
+      #
+      def create_guardfile
+        if !File.exist?('Guardfile')
+          ::Guard::UI.info "Writing new Guardfile to #{ Dir.pwd }/Guardfile"
+          FileUtils.cp(GUARDFILE_TEMPLATE, 'Guardfile')
+        elsif options[:abort_on_existence]
+          ::Guard::UI.error "Guardfile already exists at #{ Dir.pwd }/Guardfile"
+          abort
+        end
+      end
+
+      # Adds the Guardfile template of a Guard plugin to an existing Guardfile.
+      #
+      # @see Guard::CLI#init
+      #
+      # @param [String] plugin_name the name of the Guard plugin or template to
+      #   initialize
+      #
+      def initialize_template(plugin_name)
+        plugin_util = ::Guard::PluginUtil.new(plugin_name)
+        if plugin_util.plugin_class(fail_gracefully: true)
+          plugin_util.add_to_guardfile
+
+          @options[:guardfile] = File.read('Guardfile') if File.exists?('Guardfile')
+
+        elsif File.exist?(File.join(HOME_TEMPLATES, plugin_name))
+          content = File.read('Guardfile')
+
+          File.open('Guardfile', 'wb') do |f|
+            f.puts(content)
+            f.puts('')
+            f.puts(File.read(File.join(HOME_TEMPLATES, plugin_name)))
+          end
+
+          ::Guard::UI.info "#{ plugin_name } template added to Guardfile, feel free to edit it"
+        else
+          const_name = plugin_name.downcase.gsub('-', '')
+          UI.error "Could not load 'guard/#{ plugin_name.downcase }' or '~/.guard/templates/#{ plugin_name.downcase }' or find class Guard::#{ const_name.capitalize }"
+        end
+      end
+
+      # Adds the templates of all installed Guard implementations to an
+      # existing Guardfile.
+      #
+      # @see Guard::CLI#init
+      #
+      def initialize_all_templates
+        ::Guard::PluginUtil.plugin_names.each { |g| initialize_template(g) }
+      end
+
+    end
+
+  end
+end

data/lib/guard/interactor.rb

@@ -1,3 +1,14 @@
+require 'pry'
+
+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 'guard/ui'
+
 module Guard
 
   # The Guard interactor is a Pry REPL with a Guard
@@ -5,80 +16,86 @@ module Guard
   #
   class Interactor
 
-    require 'pry'
-
-    require 'guard'
-    require 'guard/ui'
-
-    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'
-
     # The default Ruby script to configure Guard Pry if the option `:guard_rc` is not defined.
-    GUARD_RC     = '~/.guardrc'
+    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'
+      help:         'h',
+      all:          'a',
+      reload:       'r',
+      change:       'c',
+      show:         's',
+      scope:        'o',
+      notification: 'n',
+      pause:        'p',
+      exit:         'e',
+      quit:         'q'
     }
 
     attr_accessor :thread
 
-    class << self
+    # Get the interactor options
+    #
+    # @return [Hash] the options
+    #
+    def self.options
+      @options ||= {}
+    end
 
-      # Get the interactor options
-      #
-      # @return [Hash] the options
-      #
-      def options
-        @options ||= { }
-      end
+    # Set the interactor options
+    #
+    # @param [Hash] options the interactor options
+    # @option options [String] :guard_rc the Ruby script to configure Guard Pry
+    # @option options [String] :history_file the file to write the Pry history to
+    #
+    def self.options=(options)
+      @options = options
+    end
 
-      # Set the interactor options
-      #
-      # @param [Hash] options the interactor options
-      # @option options [String] :guard_rc the Ruby script to configure Guard Pry
-      # @option options [String] :history_file the file to write the Pry history to
-      #
-      def options=(options)
-        @options = options
-      end
+    # Is the interactor enabled?
+    #
+    # @return [Boolean] true if enabled
+    #
+    def self.enabled
+      @enabled || @enabled.nil?
+    end
 
-      # Is the interactor enabled?
-      #
-      # @return [Boolean] true if enabled
-      #
-      def enabled
-        @enabled.nil? ? true : @enabled
-      end
+    # Set the enabled status for the interactor
+    #
+    # @param [Boolean] status true if enabled
+    #
+    def self.enabled=(status)
+      @enabled = status
+    end
+
+    # Converts and validates a plain text scope
+    # to a valid plugin or group scope.
+    #
+    # @param [Array<String>] entries the text scope
+    # @return [Hash, Array<String>] the plugin or group scope, the unknown entries
+    #
+    def self.convert_scope(entries)
+      scopes  = { plugins: [], groups: [] }
+      unknown = []
 
-      # Set the enabled status for the interactor
-      #
-      # @param [Boolean] status true if enabled
-      #
-      def enabled=(status)
-        @enabled = status
+      entries.each do |entry|
+        if plugin = ::Guard.plugin(entry)
+          scopes[:plugins] << plugin
+        elsif group = ::Guard.group(entry)
+          scopes[:groups] << group
+        else
+          unknown << entry
+        end
       end
 
+      [scopes, unknown]
     end
 
-    # Initialize the interactor. This configures
+    # Initializes the interactor. This configures
     # Pry and creates some custom commands and aliases
     # for Guard.
     #
@@ -90,24 +107,58 @@ module Guard
       Pry.config.history.file         = File.expand_path(self.class.options[:history_file] || HISTORY_FILE)
 
       @stty_exists = nil
-      add_hooks
+      _add_hooks
+
+      _replace_reset_command
+      _create_run_all_command
+      _create_command_aliases
+      _create_guard_commands
+      _create_group_commands
+
+      _configure_prompt
+    end
+
+    # Start the line reader in its own thread and
+    # stop Guard on Ctrl-D.
+    #
+    def start
+      return if ENV['GUARD_ENV'] == 'test'
+
+      _store_terminal_settings if _stty_exists?
+
+      if !@thread || !['sleep', 'run'].include?(@thread.status)
+        ::Guard::UI.debug 'Start interactor'
+
+        @thread = Thread.new do
+          Pry.start
+          ::Guard.stop
+        end
+      end
+    end
+
+    # Kill interactor thread if not current
+    #
+    def stop
+      return if !@thread || ENV['GUARD_ENV'] == 'test'
 
-      replace_reset_command
-      create_run_all_command
-      create_command_aliases
-      create_guard_commands
-      create_group_commands
+      unless Thread.current == @thread
+        ::Guard::UI.reset_line
+        ::Guard::UI.debug 'Stop interactor'
+        @thread.kill
+      end
 
-      configure_prompt
+      _restore_terminal_settings if _stty_exists?
     end
 
+    private
+
     # 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
+    def _add_hooks
       Pry.config.hooks.add_hook :when_started, :load_guard_rc do
         (self.class.options[:guard_rc] || GUARD_RC).tap do |p|
           load p if File.exist?(File.expand_path(p))
@@ -119,7 +170,7 @@ module Guard
         load project_guard_rc if File.exist?(project_guard_rc)
       end
 
-      if stty_exists?
+      if _stty_exists?
         Pry.config.hooks.add_hook :after_eval, :restore_visibility do
           system("stty echo 2>#{ DEV_NULL }")
         end
@@ -128,8 +179,8 @@ module Guard
 
     # Replaces reset defined inside of Pry with a reset that
     # instead restarts guard.
-
-    def replace_reset_command
+    #
+    def _replace_reset_command
       Pry.commands.command "reset", "Reset the Guard to a clean state." do
         output.puts "Guard reset."
         exec "guard"
@@ -140,7 +191,7 @@ module Guard
     # when the command is empty (just pressing enter on the
     # beginning of a line).
     #
-    def create_run_all_command
+    def _create_run_all_command
       Pry.commands.block_command /^$/, 'Hit enter to run all' do
         Pry.run_command 'all'
       end
@@ -150,7 +201,7 @@ module Guard
     # `help`, `reload`, `change`, `scope`, `notification`, `pause`, `exit` and `quit`,
     # which will be the first letter of the command.
     #
-    def create_command_aliases
+    def _create_command_aliases
       SHORTCUTS.each do |command, shortcut|
         Pry.commands.alias_command shortcut, command.to_s
       end
@@ -161,11 +212,9 @@ module Guard
     # when guard-rspec is available, then a command
     # `rspec` is created that runs `all rspec`.
     #
-    def create_guard_commands
-      ::Guard.guards.each do |guard|
-        name = guard.class.to_s.downcase.sub('guard::', '')
-
-        Pry.commands.create_command name, "Run all #{ name }" do
+    def _create_guard_commands
+      ::Guard.plugins.each do |guard_plugin|
+        Pry.commands.create_command guard_plugin.name, "Run all #{ guard_plugin.title }" do
           group 'Guard'
 
           def process
@@ -180,12 +229,11 @@ module Guard
     # when you have a group `frontend`, then a command
     # `frontend` is created that runs `all frontend`.
     #
-    def create_group_commands
+    def _create_group_commands
       ::Guard.groups.each do |group|
-        name = group.name.to_s
-        next if name == 'default'
+        next if group.name == :default
 
-        Pry.commands.create_command name, "Run all #{ name }" do
+        Pry.commands.create_command group.name.to_s, "Run all #{ group.title }" do
           group 'Guard'
 
           def process
@@ -198,71 +246,29 @@ module Guard
     # Configure the pry prompt to see `guard` instead of
     # `pry`.
     #
-    def configure_prompt
-      Pry.config.prompt = [
-        proc do |target_self, nest_level, pry|
-          history = pry.input_array.size
-          process = ::Guard.listener.paused? ? 'pause' : 'guard'
-          clip    = Pry.view_clip(target_self)
-          level = ":#{ nest_level }" unless nest_level.zero?
-          scope = if !::Guard.scope[:plugins].empty?
-                    "{#{ ::Guard.scope[:plugins].join(',') }} "
-                  elsif !::Guard.scope[:groups].empty?
-                    "{#{ ::Guard.scope[:groups].join(',') }} "
-                  else
-                    ''
-                  end
-
-          "[#{ history }] #{ scope }#{ process }(#{ clip })#{ level }> "
-        end,
-        proc do |target_self, nest_level, pry|
-          history = pry.input_array.size
-          process = ::Guard.listener.paused? ? 'pause' : 'guard'
-          clip    = Pry.view_clip(target_self)
-          level = ":#{ nest_level }" unless nest_level.zero?
-          scope = if !::Guard.scope[:plugins].empty?
-                    "{#{ ::Guard.scope[:plugins].join }} "
-                  elsif !::Guard.scope[:groups].empty?
-                    "{#{ ::Guard.scope[:groups].join }} "
-                  else
-                    ''
-                  end
-
-          "[#{ history }] #{ scope }#{ process }(#{ clip })#{ level }* "
-        end
-      ]
-    end
-
-    # Start the line reader in its own thread and
-    # stop Guard on Ctrl-D.
-    #
-    def start
-      return if ENV['GUARD_ENV'] == 'test'
-
-      store_terminal_settings if stty_exists?
-
-      if !@thread || !['sleep', 'run'].include?(@thread.status)
-        ::Guard::UI.debug 'Start interactor'
-
-        @thread = Thread.new do
-          Pry.start
-          ::Guard.stop
-        end
-      end
+    def _configure_prompt
+      Pry.config.prompt = [_prompt('>'), _prompt('*')]
     end
 
-    # Kill interactor thread if not current
+    # Returns a proc that will return itself a string ending with the given
+    # `ending_char` when called.
     #
-    def stop
-      return if !@thread || ENV['GUARD_ENV'] == 'test'
-
-      unless Thread.current == @thread
-        ::Guard::UI.reset_line
-        ::Guard::UI.debug 'Stop interactor'
-        @thread.kill
+    def _prompt(ending_char)
+      proc do |target_self, nest_level, pry|
+        history = pry.input_array.size
+        process = ::Guard.listener.paused? ? 'pause' : 'guard'
+        clip    = Pry.view_clip(target_self)
+        level = ":#{ nest_level }" unless nest_level.zero?
+        scope = if !::Guard.scope[:plugins].empty?
+                  "{#{ ::Guard.scope[:plugins].map(&:title).join(',') }} "
+                elsif !::Guard.scope[:groups].empty?
+                  "{#{ ::Guard.scope[:groups].map(&:title).join(',') }} "
+                else
+                  ''
+                end
+
+        "[#{ history }] #{ scope }#{ process }(#{ clip })#{ level }#{ending_char} "
       end
-
-      restore_terminal_settings if stty_exists?
     end
 
     # Detects whether or not the stty command exists
@@ -270,7 +276,7 @@ module Guard
     #
     # @return [Boolean] the status of stty
     #
-    def stty_exists?
+    def _stty_exists?
       @stty_exists ||= system('hash', 'stty') ? true : false if @stty_exists.nil?
       @stty_exists
     end
@@ -278,37 +284,15 @@ module Guard
     # Stores the terminal settings so we can resore them
     # when stopping.
     #
-    def store_terminal_settings
+    def _store_terminal_settings
       @stty_save = `stty -g 2>#{ DEV_NULL }`.chomp
     end
 
     # Restore terminal settings
     #
-    def restore_terminal_settings
+    def _restore_terminal_settings
       system("stty #{ @stty_save } 2>#{ DEV_NULL }") if @stty_save
     end
 
-    # Converts and validates a plain text scope
-    # to a valid plugin or group scope.
-    #
-    # @param [Array<String>] entries the text scope
-    # @return [Hash, Array<String>] the plugin or group scope, the unknown entries
-    #
-    def self.convert_scope(entries)
-      scopes  = { :plugins => [], :groups => [] }
-      unknown = []
-
-      entries.each do |entry|
-        if plugin = ::Guard.guards(entry)
-          scopes[:plugins] << plugin
-        elsif group = ::Guard.groups(entry)
-          scopes[:groups] << group
-        else
-          unknown << entry
-        end
-      end
-
-      [scopes, unknown]
-    end
   end
 end