guard-haml 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf3007a54edba5584940b2812d793e1e6bc3ecd1
-  data.tar.gz: a961d482a52ffb5a15c1a8f4a782be9fa653118e
+  metadata.gz: 13cf52ae3f88496081c0f7f37ff2d1697d61c803
+  data.tar.gz: ed755bd3436951a0118a97cc6aa1f57877b122aa
 SHA512:
-  metadata.gz: 3104170be4cfcba41ed1b2a6f984a3ea9461b2a4b0451e38f4ac98c712ac15b431680e0e83baa368afb24c78a7b71d4245115fadb7d60ade4b0269d2d68f8d6b
-  data.tar.gz: b2e3d6789f279448fdd064152f44152c69e83b07d1fb7ad0046b259e3b0cab5811d07bec076793827a4a2a6fac612760a0a080bafb48747e5ba7cde2df612095
+  metadata.gz: d0a370863ba296d0d830f2bcbf951858d4bbc259c7d8cc9d903578910eec613402c0690d81d20833b4f7f347ffd533c1f0275adf6af911a7d3f81986d20d1a2c
+  data.tar.gz: 8764f1887b544fbb2ee99261635c819e2ce962a654957879470792dd2c5b8e4e488b3c87d3afa64641323bc5bc3789c5fb749db4249b5195cffe8ce81556fe9e

data/README.md

@@ -27,9 +27,30 @@ $ guard init haml
 
 ## Options
 
+### Configuring the input folder + automatic watchers generation
+
+Use the `:input` option to define the folder where your HAML files are stored.
+This options also ensure the input folder won't be part of the output path.
+
+If you set the `:input` option and don't define any watchers, Guard::Haml will
+automatically generates watchers with the pattern
+`%r{^#{options[:input]}/(.+(\.html)?\.haml)$}`. For instance:
+
+```ruby
+guard :haml, input: 'markup'
+```
+
+is equivalent to:
+
+```ruby
+guard :haml, input: 'markup' do
+  watch %r{^markup/(.+(\.html)?\.haml)$}
+end
+```
+
 ### Configuring the output destination
 
-If you want to change the output directory use the `output` option in your
+If you want to change the output directory use the `:output` option in your
 Guardfile, e.g.:
 
 ```ruby
@@ -42,18 +63,20 @@ This output is relative to the Guardfile.
 
 ### Multiple output option
 
-This lets you compile to two (or more) html files from one haml file. This comes in handy if you want to compile to both a dev and prod build directory, for example:
+This lets you compile to two (or more) html files from one haml file. This
+comes in handy if you want to compile to both a dev and prod build directory,
+for instance:
 
 ```ruby
-guard :haml, { input: 'markup', output: ['public/dev', 'public/build'] } do
-  watch(%r{^.+(\.haml)$})
+guard :haml, input: 'markup', output: ['public/dev', 'public/build'] do
+  watch %r{^.+(\.haml)$}
 end
 ```
 
-If you maintain your haml files in a directory that should not be part of the output path, you can set the `input` option, e.g.:
+If you maintain your haml files in a directory that should not be part of the output path, you can set the `:input` option, e.g.:
 
 ```ruby
-guard :haml, output: 'public', input: 'src' do
+guard :haml, input: 'src', output: 'public' do
   watch %r{^src/.+(\.html\.haml)}
 end
 ```
@@ -62,7 +85,7 @@ it will be saved to `public/partials/_partial.html` without the `src`.
 
 ### File extensions
 
-The guard extension will try to add the correct extension based off the input file name. You can provide multiple extensions to control the file name.
+Guard::Haml will try to add the correct extension based on the input file name. You can provide multiple extensions to control the file name.
 
 ```ruby
 "foo.haml"     -> "foo.html"
@@ -71,7 +94,7 @@ The guard extension will try to add the correct extension based off the input fi
 "foo.php.haml" -> "foo.php"
 ```
 
-You can override the default extension (`html`) using the `default_ext` option:
+You can override the default extension (`html`) using the `:default_ext` option:
 
 ```ruby
 guard :haml, default_ext: 'txt' do
@@ -81,7 +104,7 @@ end
 
 ### Compile when starting guard
 
-If you want to compile haml files on guard start you can use `run_at_start` option.
+If you want to compile haml files when Guard starts you can use `:run_at_start` option.
 
 ```ruby
 guard :haml, output: 'public', input: 'src', run_at_start: true do
@@ -91,7 +114,7 @@ end
 
 ### Guard notifications
 
-Also you can configure guard notifications (to Growl/lib-notify/Notifu) by setting `notifications` option to `true`
+You can disable Guard notifications by setting `:notifications` option to `false`:
 
 ```ruby
 guard 'haml', output: 'public', input: 'src', notifications: true do
@@ -101,7 +124,7 @@ end
 
 ### Configuring HAML
 
-If you want to pass options to the Haml engine, you can set the `haml_options` option, e.g.:
+If you want to pass options to the Haml engine, you can set the `:haml_options` option, e.g.:
 
 ```ruby
 guard :haml, output: 'public', input: 'src', haml_options: { ugly: true } do
@@ -111,6 +134,18 @@ end
 
 This will produce compressed HTML. See [Haml Reference](http://haml.info/docs/yardoc/file.HAML_REFERENCE.html#options) for more details.
 
+### List of available options
+
+``` ruby
+input: 'markup'                        # define the folder where your HAML files are stored
+output: ['public/dev', 'public/build'] # define the output folder where conpiled HAML files are saved
+default_ext: 'txt'                     # override the default extension (`html`)
+run_at_start: false                    # compile haml files when Guard starts, default: false
+notifications: false                   # enable/disable Guard notifications, default: true
+haml_options: { ugly: true }           # HAML options (passed directly to HAML), default: {}
+auto_append_file_ext: false            # automatically append `.html` to the generated files, default: true
+```
+
 ## Development
 
 * Documentation hosted at [RubyDoc](http://rubydoc.info/gems/guard-haml/frames).

data/lib/guard/haml.rb

@@ -7,18 +7,22 @@ module Guard
   class Haml < Plugin
     autoload :Notifier, 'guard/haml/notifier'
 
-    def initialize(options = {})
-      @options = {
+    def initialize(opts = {})
+      opts = {
         notifications:        true,
         default_ext:          'html',
         auto_append_file_ext: false
-      }.merge options
+      }.merge(opts)
 
-      super(@options)
+      super(opts)
+
+      if options[:input]
+        watchers << ::Guard::Watcher.new(%r{^#{options[:input]}/(.+(\.html)?\.haml)$})
+      end
     end
 
     def start
-      run_all if @options[:run_at_start]
+      run_all if options[:run_at_start]
     end
 
     def stop
@@ -35,31 +39,34 @@ module Guard
 
     def run_on_changes(paths)
       paths.each do |file|
-        output_files = get_output(file)
+        output_paths = _output_paths(file)
         compiled_haml = compile_haml(file)
-        output_files.each do |output_file|
+
+        output_paths.each do |output_file|
           FileUtils.mkdir_p File.dirname(output_file)
           File.open(output_file, 'w') { |f| f.write(compiled_haml) }
         end
+
         message = "Successfully compiled haml to html!\n"
-        message += "# #{file} -> #{output_files.join(', ')}".gsub("#{::Bundler.root.to_s}/", '')
+        message += "# #{file} -> #{output_paths.join(', ')}".gsub("#{::Bundler.root.to_s}/", '')
         ::Guard::UI.info message
-        Notifier.notify( true, message ) if @options[:notifications]
+        Notifier.notify(true, message) if options[:notifications]
       end
-      notify paths
+
+      _notify_other_guard_plugins(paths)
     end
 
     private
 
-    def compile_haml file
+    def compile_haml(file)
       begin
         content = File.new(file).read
-        engine  = ::Haml::Engine.new(content, (@options[:haml_options] || {}))
+        engine  = ::Haml::Engine.new(content, (options[:haml_options] || {}))
         engine.render
       rescue StandardError => error
         message = "HAML compilation failed!\nError: #{error.message}"
         ::Guard::UI.error message
-        Notifier.notify( false, message ) if @options[:notifications]
+        Notifier.notify(false, message) if options[:notifications]
         throw :task_has_failed
       end
     end
@@ -70,13 +77,14 @@ module Guard
     # @param file [String, Array<String>] path to file being built
     # @return [Array<String>] path(s) to file where output should be written
     #
-    def get_output(file)
+    def _output_paths(file)
       input_file_dir = File.dirname(file)
-      file_name = get_file_name(file)
-      file_name = "#{file_name}.html" if append_file_ext_to_output_path?(file_name)
-      input_file_dir = input_file_dir.gsub(Regexp.new("#{@options[:input]}(\/){0,1}"), '') if @options[:input]
-      if @options[:output]
-        Array(@options[:output]).map do |output_dir|
+      file_name = _output_filename(file)
+      file_name = "#{file_name}.html" if _append_html_ext_to_output_path?(file_name)
+      input_file_dir = input_file_dir.gsub(Regexp.new("#{options[:input]}(\/){0,1}"), '') if options[:input]
+
+      if options[:output]
+        Array(options[:output]).map do |output_dir|
           File.join(output_dir, input_file_dir, file_name)
         end
       else
@@ -100,31 +108,32 @@ module Guard
     # @param file String path to file
     # @return String file name including extension
     #
-    def get_file_name(file)
+    def _output_filename(file)
       sub_strings           = File.basename(file).split('.')
       base_name, extensions = sub_strings.first, sub_strings[1..-1]
 
       if extensions.last == 'haml'
         extensions.pop
         if extensions.empty?
-          [base_name, @options[:default_ext]].join('.')
+          [base_name, options[:default_ext]].join('.')
         else
           [base_name, extensions].flatten.join('.')
         end
       else
-        [base_name, extensions, @options[:default_ext]].flatten.join('.')
+        [base_name, extensions, options[:default_ext]].flatten.join('.')
       end
     end
 
-    def append_file_ext_to_output_path?(file_name)
-      return unless @options[:auto_append_file_ext]
-      file_name.match("\.html?").nil?
+    def _append_html_ext_to_output_path?(filename)
+      return unless options[:auto_append_file_ext]
+
+      filename.match("\.html?").nil?
     end
 
-    def notify(changed_files)
-      ::Guard.guards.reject{ |guard| guard == self }.each do |guard|
+    def _notify_other_guard_plugins(changed_files)
+      ::Guard.guards.reject { |guard| guard == self }.each do |guard|
         paths = Watcher.match_files(guard, changed_files)
-        guard.run_on_changes paths unless paths.empty?
+        guard.run_on_changes(paths) unless paths.empty?
       end
     end
   end

data/lib/guard/haml/templates/Guardfile

@@ -6,6 +6,6 @@
 # notifications: true                send notifictions to Growl/libnotify/Notifu
 # haml_options: { ugly: true }    pass options to the Haml engine
 
-guard 'haml' do
+guard :haml do
   watch(/^.+(\.html\.haml)$/)
 end

data/lib/guard/haml/version.rb

@@ -1,5 +1,5 @@
 module Guard
   class HamlVersion
-    VERSION = '1.0.0'
+    VERSION = '1.1.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: guard-haml
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Immanuel Häussermann
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-05 00:00:00.000000000 Z
+date: 2013-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard