guard-haml-ext 0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c511c716e07156432d4acd997e324a962566214
+  data.tar.gz: ef7ddbc18f417cba46571264eb48ba761efeaf20
+SHA512:
+  metadata.gz: 81954ecbe85cf06ecf05a56ec8dd5a2805852b6db336d2a5c720afa4914dea354c53dc407f85e04a7854acb176529675fd7dd19221db47a0366e88de94a7353a
+  data.tar.gz: 81f47a0c8a3301049b8d2d1d57e4e638dc424451ca5d7b7cc1226df766a62a04d516737e0a2f443ae53ebd0d4e7ceea9b69c6039e7c9a3c0ab2ebae79ff8fe9b

data/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Immanuel Häussermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,100 @@
+# Guard::Haml
+
+Watches HAML files, compiles them to HTML on change.
+
+[![Build Status](https://secure.travis-ci.org/manufaktor/guard-haml.png?branch=development)](http://travis-ci.org/manufaktor/guard-haml)
+
+
+## Install
+
+As the gem name suggests this is a guard extension. Make sure you get [guard](https://github.com/guard/guard) first.
+
+Install the gem:
+
+    gem install guard-haml
+
+Add it to your Gemfile if you're using bundler (you should)
+
+    gem 'guard-haml'
+
+Add a basic guard setup:
+
+    guard init haml
+
+## Options
+
+### Configuring the output destination
+
+If you want to change the output directory use the `output` option in your
+Guardfile, e.g.:
+
+    guard 'haml', :output => 'public' do
+      watch %r{^src/.+(\.html\.haml)}
+    end
+
+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:
+
+    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.:
+
+    guard 'haml', :output => 'public', :input => 'src' do
+      watch %r{^src/.+(\.html\.haml)}
+    end
+
+So when you edit a file `src/partials/_partial.html.haml`
+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.
+
+   "foo.haml"     -> "foo.html"
+   "foo"          -> "foo.html"
+   "foo.txt"      -> "foo.txt.html"
+   "foo.php.haml" -> "foo.php"
+
+You can override the default extension (`html`) using the `default_ext` option:
+
+    guard 'haml', :default_ext => 'txt' do
+      watch %r{^src/.+(\.html\.haml)}
+    end
+
+### Compile when starting guard
+
+If you want to compile haml files on guard start you can use `run_at_start` option.
+
+    guard 'haml', :output => 'public', :input => 'src', :run_at_start => true do
+      watch %r{^src/.+(\.html\.haml)}
+    end
+
+### Guard notifications
+
+Also you can configure guard notifications (to Growl/lib-notify/Notifu) by setting `notifications` option to `true`
+
+    guard 'haml', :output => 'public', :input => 'src', :notifications => true do
+      watch %r{^src/.+(\.html\.haml)}
+    end
+
+### Configuring HAML
+
+If you want to pass options to the Haml engine, you can set the `haml_options` option, e.g.:
+
+    guard 'haml', :output => 'public', :input => 'src', :haml_options => { :ugly => true } do
+      watch %r{^src/.+(\.html\.haml)}
+    end
+
+This will produce compressed HTML. See [Haml Reference](http://haml.info/docs/yardoc/file.HAML_REFERENCE.html#options) for more details.
+
+## Development
+
+* Source is hosted on [Github: guard-haml](https://github.com/manufaktor/guard-haml)
+* Report issues/questions/feature requests on the [Github Issue tracker for guard-haml](https://github.com/manufaktor/guard-haml/issues)
+
+Pull requests are welcome. If you are adding something new that is worth documenting, please do not forget to note it in the README.

data/lib/guard/haml.rb

@@ -0,0 +1,125 @@
+require 'guard'
+require 'guard/guard'
+require 'guard/watcher'
+require 'haml'
+
+module Guard
+  class Haml < Guard
+    autoload :Notifier, 'guard/haml/notifier'
+
+    def initialize(watchers = [], options = {})
+      @options = {
+        :notifications => true,
+        :default_ext   => 'html'
+      }.merge options
+      super(watchers, @options)
+    end
+
+    def start
+      run_all if @options[:run_at_start]
+    end
+
+    def stop
+      true
+    end
+
+    def reload
+      run_all
+    end
+
+    def run_all
+      run_on_changes(Watcher.match_files(self, Dir.glob(File.join('**', '*.*'))))
+    end
+
+    def run_on_changes(paths)
+      paths.each do |file|
+        output_files = get_output(file)
+        compiled_haml = compile_haml(file)
+        output_files.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}/", '')
+        ::Guard::UI.info message
+        Notifier.notify( true, message ) if @options[:notifications]
+      end
+      notify paths
+    end
+
+    private
+
+    def compile_haml file
+      begin
+        content = File.new(file).read
+        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]
+        throw :task_has_failed
+      end
+    end
+
+    # Get the file path to output the html based on the file being
+    # built. The output path is relative to where guard is being run.
+    #
+    # @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)
+      input_file_dir = File.dirname(file)
+
+      file_name = get_file_name(file)
+
+      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
+        if input_file_dir == ''
+          [file_name]
+        else
+          [File.join(input_file_dir, file_name)]
+        end
+      end
+    end
+
+    # Generate a file name based on the provided file path.
+    # Provide a logical extension.
+    #
+    # Examples:
+    #   "path/foo.haml"     -> "foo.html"
+    #   "path/foo"          -> "foo.html"
+    #   "path/foo.bar"      -> "foo.bar.html"
+    #   "path/foo.bar.haml" -> "foo.bar"
+    #
+    # @param file String path to file
+    # @return String file name including extension
+    #
+    def get_file_name(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('.')
+        else
+          [base_name, extensions].flatten.join('.')
+        end
+      else
+        [base_name, extensions, @options[:default_ext]].flatten.join('.')
+      end
+    end
+
+    def notify(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?
+      end
+    end
+  end
+end

data/lib/guard/haml/notifier.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Guard
+  class Haml
+    class Notifier
+      class << self
+        def image result
+          result ? :success : :failed
+        end
+
+        def notify( result, message )
+          ::Guard::Notifier.notify( message, 
+                                    :title => 'Guard::Haml', 
+                                    :image => image( result ) 
+                                  )
+        end
+      end
+    end
+  end
+end

data/lib/guard/haml/templates/Guardfile

@@ -0,0 +1,11 @@
+# Sample guardfile block for Guard::Haml
+# You can use some options to change guard-haml configuration
+# :output => 'public'                   set output directory for compiled files
+# :input => 'src'                       set input directory with haml files
+# :run_at_start => true                 compile files when guard starts
+# :notifications => true                send notifictions to Growl/libnotify/Notifu
+# :haml_options => { :ugly => true }    pass options to the Haml engine
+
+guard 'haml' do
+  watch(/^.+(\.html\.haml)/)
+end

data/lib/guard/haml/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  class HamlVersion
+    VERSION = '0.6'
+  end
+end

data/spec/fixtures/fail_test.html.haml

@@ -0,0 +1,10 @@
+!!!
+%html(lang="en")
+  %head
+    %meta(charset="utf-8")
+    %title Guard::Haml
+  %body
+    .content
+      %h1 Welcome to Guard::Haml
+      %p Testing
+        = FAILED!

data/spec/fixtures/test.html.haml

@@ -0,0 +1,9 @@
+!!!
+%html(lang="en")
+  %head
+    %meta(charset="utf-8")
+    %title Guard::Haml
+  %body
+    .content
+      %h1 Welcome to Guard::Haml
+      %p Testing

data/spec/fixtures/test2.html.haml

@@ -0,0 +1,9 @@
+!!!
+%html(lang="en")
+  %head
+    %meta(charset="utf-8")
+    %title Guard::Haml
+  %body
+    .content
+      %h1 Welcome to Guard::Haml
+      %p Testing

data/spec/guard/haml/notifier_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Guard::Haml::Notifier do
+  subject { described_class }
+
+  describe '#image' do
+    context 'when recieves true' do
+      specify { subject.image(true).should be :success }
+    end
+
+    context 'when recieves false' do
+      specify { subject.image(false).should be :failed }
+    end
+  end
+
+  describe '#notify' do
+    context 'when recieves true with message' do
+      it 'should call Guard::Notifier with success image' do
+        ::Guard::Notifier.should_receive(:notify).with(
+            'Successful compilation!',
+            :title => 'Guard::Haml',
+            :image => :success
+            )
+        subject.notify(true, 'Successful compilation!')
+      end
+    end
+
+    context 'when recieves false with message' do
+      it 'should call Guard::Notifier with failed image' do
+        ::Guard::Notifier.should_receive(:notify).with(
+                'Compilation failed!',
+                :title => 'Guard::Haml',
+                :image => :failed
+                )
+        subject.notify(false, 'Compilation failed!')
+      end
+    end
+  end
+end

data/spec/guard/haml_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+describe Guard::Haml do
+  let(:subject_with_options) { described_class.new( [],
+                                :notifications => false,
+                                :run_at_start => true) }
+  let(:subject_notifiable) { described_class.new( [],
+                                :notifications => true ) }
+  let(:notifier) { Guard::Haml::Notifier }
+
+  describe "class" do
+    it 'should autoload Notifier class' do
+      expect { Guard::Haml::Notifier }.not_to raise_error
+    end
+  end
+
+  describe '#new' do
+    context 'notifications option by default' do
+      specify { subject.options[:notifications].should be_true }
+    end
+
+    context "when recieves options hash" do
+      it 'should merge it to @options instance variable' do
+        subject_with_options.options[:notifications].should be_false
+        subject_with_options.options[:run_at_start].should be_true
+      end
+    end
+  end
+
+  describe '#start' do
+    context 'by default' do
+      it 'should not call #run_all' do
+        subject.should_not_receive(:run_all).and_return(true)
+        subject.start
+      end
+    end
+
+    context 'when run_on_start option set to true' do
+      it 'should call #run_all' do
+        subject_with_options.should_receive(:run_all).and_return(true)
+        subject_with_options.start
+      end
+    end
+
+    context 'when run_on_start option set to false' do
+      before do
+        subject.options[:run_at_start] = false
+      end
+
+      it 'should not call #run_all' do
+        subject.should_not_receive(:run_all).and_return(true)
+        subject.start
+      end
+    end
+  end
+
+  describe '#stop' do
+    specify { subject.stop.should be_true }
+  end
+
+  describe '#reload' do
+    it 'should call #run_all' do
+      subject.should_receive(:run_all).and_return(true)
+      subject.reload
+    end
+  end
+
+  describe '#run_all' do
+    it 'should rebuild all files being watched' do
+      Guard::Haml.stub(:run_on_change).with([]).and_return([])
+      Guard.stub(:guards).and_return([subject])
+      subject.run_all
+    end
+  end
+
+  describe '#get_output' do
+    context 'by default' do
+      it 'should return test/index.html.haml as [test/index.html]' do
+        subject.send(:get_output, 'test/index.html.haml').
+                        should eq(['test/index.html'])
+      end
+
+      it 'should return test/index.htm.haml as [test/index.htm]' do
+        subject.send(:get_output, 'test/index.htm.haml').
+                        should eq(['test/index.htm'])
+      end
+
+      it 'should return test/index.haml as [test/index.html]' do
+        subject.send(:get_output, 'test/index.haml').
+                        should eq(['test/index.html'])
+      end
+    end
+
+    context 'when the output option is set to "demo/output"' do
+      before do
+        subject.options[:output] = 'demo/output'
+      end
+
+      it 'should return test/index.html.haml as [demo/output/test/index.html.haml]' do
+        subject.send(:get_output, 'test/index.html.haml').
+                  should eq(['demo/output/test/index.html'])
+      end
+    end
+
+    context 'when the output option is set to ["demo/output", "demo2/output"]' do
+      before do
+        subject.options[:output] = ['demo1/output', 'demo2/output']
+      end
+
+      it 'should return test/index.html.haml as [demo1/output/test/index.html.haml, demo2/output/test/index.html.haml]' do
+        subject.send(:get_output, 'test/index.html.haml').
+                  should eq(['demo1/output/test/index.html', 'demo2/output/test/index.html'])
+      end
+    end
+
+    context 'when the default extensions is set to "txt"' do
+      before do
+        subject.options[:default_ext] = 'txt'
+      end
+
+      it 'should return test/index.haml as test/index.txt' do
+        subject.send(:get_output, 'test/index.haml').
+                  should eq(['test/index.txt'])
+      end
+
+      it 'should return test/index.php.haml as test/index.php due to the second extension' do
+        subject.send(:get_output, 'test/index.php.haml').
+                  should eq(['test/index.php'])
+      end
+    end
+
+
+
+    context 'when the exclude_base_dir option is set to "test/ignore"' do
+      before do
+        subject.options[:input] = 'test/ignore'
+      end
+
+      it 'should return test/ignore/index.html.haml as [index.html]' do
+        subject.send(:get_output, 'test/ignore/index.html.haml').
+                                    should eq(['index.html'])
+      end
+
+      context 'when the output option is set to "demo/output"' do
+        before do
+          subject.options[:output] = 'demo/output'
+        end
+
+        it 'should return test/ignore/abc/index.html.haml as [demo/output/abc/index.html]' do
+          subject.send(:get_output, 'test/ignore/abc/index.html.haml').
+                          should eq(['demo/output/abc/index.html'])
+        end
+      end
+    end
+
+    context 'when the input file contains a second extension"' do
+      it 'should return test/index.php.haml as [test/index.php]' do
+        subject.send(:get_output, 'test/index.php.haml').
+                        should eq(['test/index.php'])
+      end
+    end
+  end
+
+  describe '#get_file_name' do
+    context 'by default (if a ".haml" extension has been defined)' do
+      it 'should return the file name with the default extension ".html"' do
+        subject.send(:get_file_name, 'test/index.haml').
+                     should eq('index.html')
+      end
+    end
+
+    context 'if no extension has been defined at all' do
+      it 'should return the file name with the default extension ".html"' do
+        subject.send(:get_file_name, 'test/index').
+                     should eq('index.html')
+      end
+    end
+
+    context 'if an extension other than ".haml" has been defined' do
+      it 'should return the file name with the default extension ".html"' do
+        subject.send(:get_file_name, 'test/index.foo').
+                     should eq('index.foo.html')
+      end
+    end
+
+    context 'if multiple extensions including ".haml" have been defined' do
+      it 'should return the file name with the extension second to last' do
+        subject.send(:get_file_name, 'test/index.foo.haml').
+                     should eq('index.foo')
+      end
+    end
+  end
+
+  describe '#run_on_changes' do
+    it 'should notify other guards upon completion' do
+      subject.should_receive(:notify).with([])
+      subject.run_on_changes([])
+    end
+
+    context 'when notifications option set to true' do
+      let(:success_message) { "Successfully compiled haml to html!\n" }
+
+      context 'with one output' do
+        after do
+          File.unlink "#{@fixture_path}/test.html"
+        end
+
+        it 'should call Notifier.notify with 1 output' do
+          message = success_message + "# spec/fixtures/test.html.haml -> spec/fixtures/test.html"
+          notifier.should_receive(:notify).with(true, message)
+          subject_notifiable.run_on_changes(["#{@fixture_path}/test.html.haml"])
+        end
+      end
+
+      it 'should call Notifier.notify' do
+        message = "Successfully compiled haml to html!\n"
+        message += "# spec/fixtures/test.html.haml -> spec/fixtures/test.html"
+        notifier.should_receive(:notify).with(true, message)
+        subject_notifiable.run_on_changes(["#{@fixture_path}/test.html.haml"])
+      end
+
+      context 'with two outputs' do
+        before do
+          subject_notifiable.stub(:get_output).and_return(["#{@fixture_path}/test.html", "#{@fixture_path}/test2.html"])
+        end
+
+        after do
+          File.unlink "#{@fixture_path}/test.html"
+          File.unlink "#{@fixture_path}/test2.html"
+        end
+
+        it 'should call Notifier.notify with 2 outputs' do
+          message = success_message + "# spec/fixtures/test.html.haml -> spec/fixtures/test.html, spec/fixtures/test2.html"
+          notifier.should_receive(:notify).with(true, message)
+          subject_notifiable.run_on_changes(["#{@fixture_path}/test.html.haml"])
+        end
+      end
+    end
+  end
+
+  describe '#compile_haml' do
+    it 'throws :task_has_failed when an error occurs' do
+      expect { subject.send(:compile_haml, "#{@fixture_path}/fail_test.html.haml") }.
+              to throw_symbol :task_has_failed
+    end
+
+    context 'when notifications option set to true' do
+      it 'should call Notifier.notify when an error occurs' do
+        message = "HAML compilation failed!\n"
+        message += "Error: Illegal nesting: content can't be both given on the same line as %p and nested within it."
+        notifier.should_receive(:notify).with(false, message)
+        catch(:task_has_failed) do
+          subject_notifiable.send(:compile_haml, "#{@fixture_path}/fail_test.html.haml")
+        end.should be_nil
+
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rspec'
+require 'guard/haml'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  
+  config.before(:each) do
+    ENV["GUARD_ENV"] = 'test'
+    @fixture_path = Pathname.new "#{Bundler.root}/spec/fixtures"
+    @lib_path = Pathname.new "#{Bundler.root}/lib"
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: guard-haml-ext
+version: !ruby/object:Gem::Version
+  version: '0.6'
+platform: ruby
+authors:
+- Immanuel Häussermann
+- Florian Plank
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fork of @manufaktor’s guard-haml with support for file extension detection.
+  Compiles file.html.haml into file.html
+email:
+- haeussermann@gmail.com
+- florian@polarblau.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/guard/haml/notifier.rb
+- lib/guard/haml/templates/Guardfile
+- lib/guard/haml/version.rb
+- lib/guard/haml.rb
+- LICENSE
+- README.md
+- Gemfile
+- spec/fixtures/fail_test.html.haml
+- spec/fixtures/test.html.haml
+- spec/fixtures/test2.html.haml
+- spec/guard/haml/notifier_spec.rb
+- spec/guard/haml_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: guard-haml-ext
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Guard gem for Haml
+test_files:
+- spec/fixtures/fail_test.html.haml
+- spec/fixtures/test.html.haml
+- spec/fixtures/test2.html.haml
+- spec/guard/haml/notifier_spec.rb
+- spec/guard/haml_spec.rb
+- spec/spec_helper.rb