moco 0.1.0

data/test/compiler_test.rb

@@ -0,0 +1,243 @@
+require 'test_helper'
+
+module MoCo
+
+  describe Compiler do
+
+    describe 'require libraries' do
+
+      $LOAD_PATH.unshift(fixtures_path)
+
+      it 'will not require the library at the time of registration' do
+        JsCompiler.require_library('js_lib')
+        refute defined? JsLib
+      end
+
+      it 'requires the library when the compiler is instantiated' do
+        CssCompiler.require_library('css_lib')
+        refute defined? CssLib
+        CssCompiler.new('')
+        assert defined? CssLib
+      end
+
+      it 'requires the superclass libraries' do
+        HtmlCompiler.require_library('html_lib')
+        refute defined? HtmlLib
+        Class.new(Class.new(HtmlCompiler)).new('')
+        assert defined? HtmlLib
+      end
+
+    end
+
+    describe 'require uninstalled libraries' do
+
+      class CorruptCompiler < HtmlCompiler
+        require_library 'not_installed', 'not-installed-gem', '~> 2'
+      end
+
+      it 'raises a LoadError with installation instructions' do
+        e = assert_raises(Gem::LoadError) { CorruptCompiler.new('') }
+        assert_match "gem install not-installed-gem -v '~> 2'", e.message
+      end
+
+    end
+
+    describe 'compiler options' do
+
+      after { reset_options(HtmlCompiler) }
+
+      it 'sets the option' do
+        HtmlCompiler.set_option(:format, :html5)
+        assert_equal :html5, HtmlCompiler.options[:format]
+        assert_equal :html5, HtmlCompiler.new('').options[:format]
+      end
+
+      specify 'the default value is true' do
+        HtmlCompiler.set_option(:ugly)
+        assert_equal true, HtmlCompiler.options[:ugly]
+      end
+
+      specify 'updating the options hash directly has no effect' do
+        HtmlCompiler.options[:format] = :xhtml
+        compiler = HtmlCompiler.new('')
+        compiler.options[:format] = :xhtml
+        assert_empty HtmlCompiler.options
+        assert_empty compiler.options
+      end
+
+    end
+
+    describe 'the compiled filename' do
+
+      it 'cannot be equal to the source filename' do
+        e = assert_raises(Error) do
+          HtmlCompiler.new('index.html', Dir.pwd + '/index.html')
+        end
+        assert_match 'validate_filenames', e.backtrace.first
+      end
+
+      it 'will keep the compiled filename unchanged, if provided' do
+        compiler = HtmlCompiler.new('source.md', 'compiled.xml', 'dir')
+        assert_equal 'compiled.xml', compiler.compiled_file
+      end
+
+    end
+
+    describe 'the compiled filename extension' do
+
+      def compiled_file(source_file)
+        JsCompiler.new(source_file).compiled_file
+      end
+
+      it 'has the compiled extension' do
+        assert_equal 'script.js', compiled_file('script.coffee')
+      end
+
+      specify 'the compiler must implement compiled_extension' do
+        e = assert_raises(NotImplementedError) { Compiler.new('') }
+        assert_match 'compiled_extension', e.backtrace.first
+      end
+
+      describe 'nested source extension' do
+
+        it 'will not duplicate the compiled extension' do
+          assert_equal 'script.js', compiled_file('script.js.coffee')
+        end
+
+        it 'will keep other extensions' do
+          assert_equal 'script.min.js', compiled_file('script.min.coffee')
+        end
+
+        specify 'not duplicate extension' do
+          assert_equal 'about_js.js', compiled_file('about_js.coffee')
+        end
+
+      end
+
+      describe 'nested compiled extension' do
+
+        class Minify < JsCompiler
+          define_singleton_method(:compiled_extension) { '.min.js' }
+        end
+
+        specify do
+          assert_equal 'script.min.js', Minify.new('script.js').compiled_file
+        end
+
+      end
+
+      describe 'no extensions' do
+
+        class Readme < Compiler
+          define_singleton_method(:compiled_extension) { '' }
+        end
+
+        specify 'the compiled extension is empty' do
+          assert_equal 'README', Readme.new('README.txt').compiled_file
+        end
+
+        specify 'the source file has no extension' do
+          assert_equal 'README.html', HtmlCompiler.new('README').compiled_file
+        end
+
+      end
+
+    end
+
+    describe 'the compiled filename directory' do
+
+      def compiled_file(source_file, compiled_dir = nil)
+        CssCompiler.new(source_file, nil, compiled_dir).compiled_file
+      end
+
+      it 'has the same directory as the source file by default' do
+        assert_equal 'css/style.css', compiled_file('css/style.sass')
+      end
+
+      it 'replaces the directory if one is provided' do
+        assert_equal 'css/style.css', compiled_file('style.scss', 'css')
+        assert_equal 'css/style.css', compiled_file('/sass/style.scss', 'css/')
+      end
+
+      it 'removes the source directory if compiled_dir is empty' do
+        assert_equal 'style.css', compiled_file('templates/style.scss', '')
+      end
+
+    end
+
+    describe 'compile' do
+
+      class GoodCompiler < Compiler
+        define_method(:compiled_text) { 'The compiled text' }
+      end
+
+      let(:compiler) do
+        GoodCompiler.new(fixtures_path('source.txt'), tmp_dir + '/dir/out.txt')
+      end
+
+      it 'reads the source file' do
+        assert_equal 'The source text', compiler.source_text
+      end
+
+      it 'makes the necessary directories for the compiled file' do
+        compiler.compile
+        assert File.directory?(File.dirname(compiler.compiled_file))
+      end
+
+      it 'writes the compiled text to the compiled file' do
+        compiler.compile
+        assert_equal 'The compiled text', File.read(compiler.compiled_file)
+      end
+
+    end
+
+    describe 'failed compilation' do
+
+      class BadCompiler < Compiler
+        define_method(:compiled_text) { raise 'The error text' }
+      end
+
+      let(:compiler) { BadCompiler.new('', tmp_dir + '/dir/out.txt') }
+
+      it 'raises a CompileError' do
+        assert_raises(CompileError) { compiler.compile }
+      end
+
+      it 'writes the error message to the compiled file' do
+        compiler.compile rescue
+        assert_equal 'The error text', File.read(compiler.compiled_file)
+      end
+
+      specify 'the compiler must implement compiled_text' do
+        e = assert_raises(NotImplementedError) { JsCompiler.new('').compile }
+        assert_match 'compiled_text', e.backtrace.first
+      end
+
+    end
+
+    describe 'should_compile?' do
+
+      let(:compiler) { JsCompiler.new(tmp_dir + '/script.coffee') }
+
+      it 'is true if the compiled file does not exist' do
+        touch(compiler.source_file)
+        assert compiler.should_compile?
+      end
+
+      it 'is true when the source file is updated' do
+        touch(compiler.compiled_file, :mtime => 0)
+        touch(compiler.source_file,   :mtime => 1)
+        assert compiler.should_compile?
+      end
+
+      it 'is false if the compiled file is up to date' do
+        touch(compiler.source_file)
+        touch(compiler.compiled_file)
+        refute compiler.should_compile?
+      end
+
+    end
+
+  end
+
+end

data/test/compilers/coffee_compiler_test.rb

@@ -0,0 +1,117 @@
+require 'test_helper'
+
+module MoCo
+
+  describe CoffeeCompiler do
+
+    let(:compiler) { mock_compiler(CoffeeCompiler, 'alert yes') }
+    let(:compiled_text) { compiler.compiled_text }
+
+    it 'is registered for coffee files' do
+      assert_equal CoffeeCompiler, MoCo.compiler_for('coffee')
+    end
+
+    it 'is a JavaScript compiler' do
+      assert CoffeeCompiler < JsCompiler
+      assert_equal 'js', CoffeeCompiler.compiled_extension
+    end
+
+    it 'compiles CoffeeScript into JavaScript' do
+      assert_match 'alert(true);', compiled_text
+    end
+
+    describe 'options' do
+
+      after { reset_options(CoffeeCompiler) }
+
+      it 'has a function wrapper by default' do
+        assert compiled_text.start_with?('(function() {')
+        assert compiled_text.strip.end_with?('}).call(this);')
+      end
+
+      specify 'the bare option disables the function wrapper' do
+        CoffeeCompiler.set_option(:bare)
+        assert_equal 'alert(true);', compiled_text.strip
+      end
+
+      specify 'the header includes the version number' do
+        CoffeeCompiler.set_option(:header)
+        version = CoffeeCompiler.context.run('return CoffeeScript.VERSION;')
+        assert_match "// Generated by CoffeeScript #{version}", compiled_text
+      end
+
+    end
+
+    describe 'source maps' do
+
+      before { CoffeeCompiler.set_option(:sourceMap) }
+      after  { reset_options(CoffeeCompiler) }
+
+      let(:compiler) do
+        mock_compiler(CoffeeCompiler, 'alert', 'app.coffee', 'dir/the app.js')
+      end
+
+      it 'produces a source map with relative paths' do
+        compiler.compile
+        map = JSON.load(compiler.source_map_text)
+        assert_equal 3,               map['version']
+        assert_equal 'the app.js',    map['file']
+        assert_equal '../app.coffee', map['sources'].first
+        assert_match 'AAA',           map['mappings']
+      end
+
+      it 'adds a comment, with the source map URI, to the compiled text' do
+        assert_match '//@ sourceMappingURL=the%20app.js.map', compiled_text
+      end
+
+      it 'will be saved to the same directory as the compiled file' do
+        assert_equal File.dirname(compiler.source_map_file),
+                     File.dirname(compiler.compiled_file)
+      end
+
+      it 'writes the source map file' do
+        compiler = CoffeeCompiler.new('/script.coffee', nil, tmp_dir)
+        compiler.define_singleton_method(:source_text) { 'alert' }
+        compiler.compile
+        assert_equal compiler.source_map_text, File.read(compiler.source_map_file)
+      end
+
+    end
+
+    describe 'compile error' do
+
+      let(:compiler) { mock_compiler(CoffeeCompiler, 'evil = (eval) ->') }
+      let(:error) { compiler.compile rescue $! }
+
+      it 'raises a CompileError' do
+        assert_raises(CompileError) { compiler.compile }
+      end
+
+      it 'captures the error location' do
+        assert_equal 1, error.line
+        assert_equal 9, error.column
+      end
+
+      describe 'the error message' do
+
+        it 'removes the filename and location from the original message' do
+          message = error.error.message
+          assert message.start_with?('mock.coffee:1:9: error: parameter name')
+
+          message = error.message
+          assert message.start_with?('Parameter name')
+        end
+
+        it 'marks the erroneous code with red (using ANSI escape codes)' do
+          message = error.message.split("\n")
+          assert_equal "evil = (\e[1;31meval\e[0m) ->", message[-2]
+          assert_equal "\e[1;31m        ^^^^\e[0m"    , message[-1]
+        end
+
+      end
+
+    end
+
+  end if run_compiler_tests?(CoffeeCompiler)
+
+end

data/test/compilers/haml_compiler_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+module MoCo
+
+  describe HamlCompiler do
+
+    let(:compiler) { mock_compiler(HamlCompiler, '#haml= 2 + 2') }
+
+    it 'is registered for haml files' do
+      assert_equal HamlCompiler, MoCo.compiler_for('haml')
+    end
+
+    it 'is a Html compiler' do
+      assert HamlCompiler < HtmlCompiler
+      assert_equal 'html', HamlCompiler.compiled_extension
+    end
+
+    it 'compiles haml into html' do
+      assert_equal "<div id='haml'>4</div>", compiler.compiled_text.strip
+    end
+
+    specify 'options are passed on to the haml compiler' do
+      HamlCompiler.set_option(:attr_wrapper, '@')
+      assert_match '<div id=@haml@>', compiler.compiled_text
+      reset_options(HamlCompiler)
+    end
+
+    describe 'compile error' do
+
+      def compile(haml)
+        mock_compiler(HamlCompiler, haml, 'mock.haml').compile
+      rescue CompileError => error
+        error
+      end
+
+      it 'removes the filename and line number from the error message' do
+        error = compile('.haml= [}')
+        refute_match 'mock.haml', error.message
+        refute_match /[:\d]/, error.message
+
+        # The original error
+        assert_match 'mock.haml:1:', error.error.message
+        assert_match 'mock.haml:2:', error.error.message
+      end
+
+      describe 'the line number' do
+
+        specify 'line numbers fetched from @line start at 1' do
+          error = compile(' %p')
+          assert_equal 1, error.line
+
+          # The original error
+          assert error.error.line
+        end
+
+        it 'finds the line number in the backtrace' do
+          error = compile("\n.time= Date.tomorrow")
+          assert_equal 2, error.line
+
+          # The original error
+          refute defined? error.error.line
+          assert_match 'mock.haml:2:', error.error.backtrace.first
+        end
+
+        it 'finds the line number in the error message' do
+          error = compile("\n\n.unbalanced= [}")
+          assert_equal 3, error.line
+
+          # The original error
+          assert_nil error.error.line
+          refute_match ':3:', error.error.backtrace.to_s
+          assert_match 'mock.haml:3:', error.error.message
+        end
+
+        specify 'line can be nil' do
+          error = compile("%p= eval '2 *** 10'")
+          assert_nil error.line
+        end
+
+      end
+
+    end
+
+  end if run_compiler_tests?(HamlCompiler)
+
+end

data/test/compilers/less_compiler_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+module MoCo
+
+  describe LessCompiler do
+
+    it 'is registered for less files' do
+      assert_equal LessCompiler, MoCo.compiler_for('less')
+    end
+
+    it 'is a CSS compiler' do
+      assert LessCompiler < CssCompiler
+      assert_equal 'css', LessCompiler.compiled_extension
+    end
+
+    describe 'compile' do
+
+      css = <<-EOF
+        .less {
+          color: #d9eef2;
+        }
+      EOF
+
+      less = <<-EOF
+        @blue: #D9EEF2;
+        .less {
+          color: @blue;
+        }
+      EOF
+
+      import = <<-EOF
+        @import 'color';
+        .less {
+          color: @blue;
+        }
+      EOF
+
+      [css, less, import].each { |style| style.gsub!(/^ {8}/, '') }
+
+      it 'compiles less into css' do
+        compiler = mock_compiler(LessCompiler, less)
+        assert_equal css, compiler.compiled_text
+      end
+
+      it 'handles the @import directive' do
+        LessCompiler.set_option(:paths, [fixtures_path])
+        compiler = mock_compiler(LessCompiler, import)
+        assert_equal css, compiler.compiled_text
+        reset_options(LessCompiler)
+      end
+
+    end
+
+    describe 'compile error' do
+
+      let(:compiler) do
+        mock_compiler(LessCompiler, '.less { color: @pink; }')
+      end
+
+      it 'raises a CompileError' do
+        assert_raises(CompileError) { compiler.compile }
+      end
+
+      it 'has a line number' do
+        assert_equal 1, (compiler.compile rescue $!).line
+      end
+
+    end
+
+  end if run_compiler_tests?(LessCompiler)
+
+end