moco 0.1.0

data/test/compilers/markdown_compiler_test.rb

@@ -0,0 +1,211 @@
+require 'test_helper'
+
+module MoCo
+
+  describe MarkdownCompiler do
+
+    after { reset_options(MarkdownCompiler) }
+
+    let(:markdown) { '#Title' }
+    let(:compiler) { mock_compiler(MarkdownCompiler, markdown) }
+    let(:compiled_text) { compiler.compiled_text.strip }
+
+    it 'is registered for md and markdown files' do
+      assert_equal MarkdownCompiler, MoCo.compiler_for('md')
+      assert_equal MarkdownCompiler, MoCo.compiler_for('markdown')
+    end
+
+    it 'is a Html compiler' do
+      assert MarkdownCompiler < HtmlCompiler
+      assert_equal 'html', MarkdownCompiler.compiled_extension
+    end
+
+    it 'compiles markdown into html' do
+      assert_equal '<h1>Title</h1>', compiled_text
+    end
+
+    specify 'the options are used to specify markdown extensions' do
+      MarkdownCompiler.set_option(:space_after_headers)
+      assert_equal '<p>#Title</p>', compiled_text
+    end
+
+    specify 'the options are passed on to the html renderer' do
+      MarkdownCompiler.set_option(:with_toc_data)
+      assert_equal '<h1 id="toc_0">Title</h1>', compiled_text
+    end
+
+    describe 'the :smarty option' do
+
+      before { MarkdownCompiler.set_option(:smarty) }
+
+      let(:markdown) { '# ...' }
+
+      it 'performs SmartyPants substitutions' do
+        assert_equal '<h1>&hellip;</h1>', compiled_text
+      end
+
+      it 'works with the Pygments renderer' do
+        MarkdownCompiler.set_option(:pygments)
+        assert_equal '<h1>&hellip;</h1>', compiled_text
+      end
+
+      it 'works with the table of contents renderer' do
+        MarkdownCompiler.set_option(:toc)
+        assert_match '<a href="#toc_0">&hellip;</a>', compiled_text
+      end
+
+    end
+
+    describe 'the :toc option' do
+
+      before { MarkdownCompiler.set_option(:toc) }
+
+      it 'produces a table of contents' do
+        assert_match '<a href="#toc_0">Title</a>', compiled_text
+        assert_match '<h1 id="toc_0">Title</h1>',  compiled_text
+      end
+
+    end
+
+    describe 'the :layout option' do
+
+      before { MarkdownCompiler.set_option(:layout, layout_file) }
+
+      let(:layout_file) { fixtures_path('layout.html') }
+      let(:layout) { File.read(layout_file) }
+
+      it 'replaces {{BODY}} with the rendered markdown' do
+        assert_match '<article>{{BODY}}</article>',         layout
+        assert_match "<article><h1>Title</h1>\n</article>", compiled_text
+      end
+
+      describe '{{TOC}}' do
+
+        before { MarkdownCompiler.set_option(:toc) }
+
+        it 'replaces {{TOC}} with the table of contents' do
+          assert_match '<nav>{{TOC}}</nav>',       layout
+          assert_match "<nav><ul>\n<li>\n<a href", compiled_text
+        end
+
+        it 'removes {{TOC}} if there is no table of contents' do
+          MarkdownCompiler.set_option(:toc, false)
+          assert_match '<nav></nav>', compiled_text
+        end
+
+        it 'adds the toc to the {{BODY}} if there is no {{TOC}} tag' do
+          layout_file = tmp_dir + '/layout.html'
+          FileUtil.write(layout_file, layout.sub('{{TOC}}', ''))
+
+          MarkdownCompiler.set_option(:layout, layout_file)
+          assert_match "<article><ul>\n<li>\n<a href=", compiled_text
+          assert_match "Title</h1>\n</article>",        compiled_text
+        end
+
+      end
+
+      describe '{{TITLE}}' do
+
+        it 'replaces {{TITLE}} with the first h1 element' do
+          assert_match '<title>{{TITLE}}</title>', layout
+          assert_match '<title>Title</title>',     compiled_text
+        end
+
+        it 'accepts an h1 element with attributes' do
+          MarkdownCompiler.set_option(:toc)
+          assert_match '<title>Title</title>', compiled_text
+        end
+
+        it 'removes nested tags from the title' do
+          markdown = '# The [![Home](logo.png)](/index.html) Title'
+          compiler = mock_compiler(MarkdownCompiler, markdown)
+          assert_match '<title>The Title</title>', compiler.compiled_text
+        end
+
+        it 'replaces {{TITLE}} with the filename if there are no h1 elements' do
+          compiler = mock_compiler(MarkdownCompiler, '## h2')
+          assert_match '<title>mock.md</title>', compiler.compiled_text
+        end
+
+      end
+
+      it 'replaces {{FILE}} with the filename' do
+        assert_match '<span>{{FILE}}</span>', layout
+        assert_match '<span>mock.md</span>',  compiled_text
+      end
+
+    end
+
+    describe 'the :pygments option' do
+
+      before { MarkdownCompiler.set_option(:pygments) }
+
+      def code_block(statement, language)
+        code_block = "```#{language}\n#{statement}\n```"
+        mock_compiler(MarkdownCompiler, code_block).compiled_text.strip
+      end
+
+      it 'adds syntax highlighting hooks to fenced code blocks' do
+        expected = '<div class="highlight"><pre><span class="nb">puts</span>'
+        assert_match expected, code_block('puts', 'RUBY')
+      end
+
+      it 'ignores code blocks with no language specified' do
+        expected = "<pre><code>puts\n</code></pre>"
+        assert_equal expected, code_block('puts', nil)
+      end
+
+      it 'adds a class for unknown languages' do
+        expected = "<pre><code class=\"dummy\">puts\n</code></pre>"
+        assert_equal expected, code_block('puts', 'dummy')
+      end
+
+      it 'escapes the html' do
+        expected = '&quot;&#39;&lt;&amp;&gt;'
+        assert_match expected, code_block(%("'<&>'"), 'ruby')
+        assert_match expected, code_block(%("'<&>'"), nil)
+      end
+
+      describe 'the :pygments options are passed on to Pygments' do
+
+        let(:markdown) { "```ruby\nputs\nputs\nputs\nputs\n\n```" }
+
+        it 'accepts a Hash' do
+          MarkdownCompiler.set_option(:pygments, :linenos => 'inline')
+          assert_equal 'inline', MarkdownCompiler.options[:pygments][:linenos]
+          assert_match '<span class="lineno">1</span>', compiled_text
+        end
+
+        it 'accepts an Array' do
+          MarkdownCompiler.set_option(:pygments, [:hl_lines, 2, 3])
+          assert_equal [2, 3], MarkdownCompiler.options[:pygments][:hl_lines]
+          compiled_text.split(/\n/).each_with_index do |line, index|
+            if [2, 3].include?(index + 1)
+              assert_match '<span class="hll">', line
+            else
+              refute_match '<span class="hll">', line
+            end
+          end
+        end
+
+        it 'can set an option to false' do
+          MarkdownCompiler.set_option(:pygments, ['stripnl', false])
+          assert_equal false, MarkdownCompiler.options[:pygments]['stripnl']
+          assert_match "\n\n</pre></div>", compiled_text
+        end
+
+        it 'can be repeated' do
+          MarkdownCompiler.set_option(:pygments, 'noclasses')
+          MarkdownCompiler.set_option(:pygments, ['style', 'vim'])
+          assert_equal true,  MarkdownCompiler.options[:pygments]['noclasses']
+          assert_equal 'vim', MarkdownCompiler.options[:pygments]['style']
+          assert_match '<span style="color: #cd00cd">puts', compiled_text
+        end
+
+      end
+
+    end
+
+  end if run_compiler_tests?(MarkdownCompiler)
+
+end

data/test/compilers/sass_compiler_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+module MoCo
+
+  describe SassCompiler do
+
+    it 'is registered for sass and scss files' do
+      assert_equal SassCompiler, MoCo.compiler_for('sass')
+      assert_equal SassCompiler, MoCo.compiler_for('scss')
+    end
+
+    it 'is a CSS compiler' do
+      assert SassCompiler < CssCompiler
+      assert_equal 'css', SassCompiler.compiled_extension
+    end
+
+    it 'selects the correct syntax' do
+      assert_equal :sass, SassCompiler.new('style.sass').options[:syntax]
+      assert_equal :scss, SassCompiler.new('style.scss').options[:syntax]
+    end
+
+    describe 'compile' do
+
+      css = <<-EOF
+        .sass {
+          color: #ce4dd6; }
+      EOF
+
+      sass = <<-EOF
+        $pink: #CE4DD6
+        .sass
+          color: $pink
+      EOF
+
+      scss = <<-EOF
+        $pink: #CE4DD6;
+        .sass { color: $pink; }
+      EOF
+
+      import = <<-EOF
+        @import 'color';
+        .sass { color: $pink; }
+      EOF
+
+      [css, sass, scss, import].each { |style| style.gsub!(/^ {8}/, '') }
+
+      it 'compiles sass into css' do
+        compiler = mock_compiler(SassCompiler, sass, 'style.sass')
+        assert_equal css, compiler.compiled_text
+      end
+
+      it 'compiles scss into css' do
+        compiler = mock_compiler(SassCompiler, scss, 'style.scss')
+        assert_equal css, compiler.compiled_text
+      end
+
+      it 'handles the @import directive' do
+        SassCompiler.set_option(:load_paths, [fixtures_path])
+        compiler = mock_compiler(SassCompiler, import, 'style.scss')
+        assert_equal css, compiler.compiled_text
+        reset_options(SassCompiler)
+      end
+
+    end
+
+    describe 'compile error' do
+
+      let(:compiler) do
+        mock_compiler(SassCompiler, '.sass { color: $blue; }', 'style.scss')
+      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?(SassCompiler)
+
+end

data/test/file_util_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module MoCo
+
+  describe FileUtil do
+
+    describe 'normalized extension' do
+
+      specify do
+        assert_equal 'less', FileUtil.normalized_extension('less')
+      end
+
+      it 'removes the period' do
+        assert_equal 'less', FileUtil.normalized_extension('.less')
+      end
+
+      it 'accepts a symbol' do
+        assert_equal 'less', FileUtil.normalized_extension(:less)
+      end
+
+      it 'accepts a filename' do
+        assert_equal 'sass', FileUtil.normalized_extension('/dir/file.sass')
+      end
+
+      it 'works with spaces' do
+        assert_equal 'sass', FileUtil.normalized_extension(' file with spaces .sass ')
+      end
+
+      it 'works with nested extensions' do
+        assert_equal 'sass', FileUtil.normalized_extension('file.css.sass')
+      end
+
+    end
+
+  end
+
+end

data/test/fixtures/_color.scss

@@ -0,0 +1 @@
+$pink: #CE4DD6;

data/test/fixtures/color.less

@@ -0,0 +1 @@
+@blue: #D9EEF2;

data/test/fixtures/css_lib.rb

@@ -0,0 +1,2 @@
+class CssLib
+end

data/test/fixtures/html_lib.rb

@@ -0,0 +1,2 @@
+class HtmlLib
+end

data/test/fixtures/js_lib.rb

@@ -0,0 +1,2 @@
+class JsLib
+end

data/test/fixtures/layout.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>{{TITLE}}</title>
+    <link rel="stylesheet" href="style.css" />
+  </head>
+  <body>
+    <span>{{FILE}}</span>
+    <nav>{{TOC}}</nav>
+    <article>{{BODY}}</article>
+  </body>
+</html>

data/test/fixtures/moco.rb

@@ -0,0 +1,8 @@
+MoCo.args '--no-reload -o txt:preserve:pre: .'
+
+class TextCompiler < MoCo::HtmlCompiler
+  register 'txt'
+  set_option :ugly
+end
+
+TextCompiler.set_option(:format, :html5)

data/test/fixtures/options_lib.rb

@@ -0,0 +1,2 @@
+class OptionsLib
+end

data/test/fixtures/source.txt

@@ -0,0 +1 @@
+The source text

data/test/monitor_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+module MoCo
+
+  describe Monitor do
+
+    before { skip unless __FILE__ == $0 }
+
+    def tmp
+      Pathname.new(tmp_dir).realpath().to_s
+    end
+
+    def updated(&block)
+      updated = []
+      thread = Thread.new do
+        monitor.monitor { |file| updated << file }
+      end
+      sleep 0.05
+      yield
+      sleep 0.5
+      thread.kill
+      updated.sort
+    end
+
+    let(:dirs) { [tmp, tmp].sort }
+    let(:files) { %W[#{dirs[0]}/file.haml #{dirs[1]}/nested/dir/file.sass] }
+    let(:txt_file) { "#{dirs[1]}/file.txt" }
+
+    describe 'monitor directories' do
+
+      let(:monitor) { Monitor.new([], dirs, [:sass, :haml]) }
+
+      it 'captures new files' do
+        assert_equal files, updated { touch(files) }
+      end
+
+      it 'captures file updates' do
+        touch(files, :mtime => 0)
+        assert_equal files, updated { touch(files) }
+      end
+
+      it 'ignores files with other extensions' do
+        assert_empty updated { touch(txt_file) }
+      end
+
+      it 'lists all the files currently being monitored' do
+        Dir.mkdir("#{dirs[0]}/dir.sass")
+        assert_empty monitor.files
+        touch(files + [txt_file])
+        assert_equal files, monitor.files.sort
+      end
+
+    end
+
+    describe 'monitor files' do
+
+      let(:monitor) { Monitor.new(files, [], []) }
+
+      it 'captures file updates' do
+        touch(files, :mtime => 0)
+        assert_equal files, updated { touch(files + [txt_file]) }
+      end
+
+    end
+
+  end
+
+end

data/test/options_test.rb

@@ -0,0 +1,177 @@
+require 'test_helper'
+
+module MoCo
+
+  describe Options do
+
+    class MockOptions < Options
+      define_method(:load_moco_files) {}
+      define_method(:validate_files) {}
+      define_method(:display_help) {}
+    end
+
+    def parse(args = '')
+      MockOptions.parse(args.shellsplit)
+    end
+
+    describe 'parse command line options' do
+
+      it 'sets the default options' do
+        assert_equal Options.new.default_options, parse
+      end
+
+      it 'sets boolean options' do
+        assert_equal true,  parse('--force')[:force]
+        assert_equal false, parse('--no-force')[:force]
+      end
+
+      it 'sets array options' do
+        assert_equal %w[Chrome],       parse('-b Chrome')[:browsers]
+        assert_equal %w[Chrome],       parse('-b Chrome,Chrome')[:browsers]
+        assert_equal %w[Chrome Opera], parse('-b Chrome,Opera')[:browsers]
+        assert_equal %w[Chrome Opera], parse('-b Chrome -b Opera')[:browsers]
+      end
+
+      describe 'the compile option' do
+
+        it 'sets the compile flag' do
+          assert_equal true,  parse('-c sass')[:compile]
+          assert_equal true,  parse('--compile')[:compile]
+          assert_equal false, parse('--no-compile')[:compile]
+        end
+
+        it 'sets the compile extensions' do
+          assert_equal ['sass'], parse('--compile .sass')[:compile_exts]
+        end
+
+        it 'raises an OptionError if an extension is unregistered' do
+          assert_raises(OptionError) { parse('-c cofe') }
+        end
+
+      end
+
+      describe 'setting compiler options' do
+
+        it 'sets the options' do
+          parse('--option haml:ugly -o haml:preserve:pre:code')
+          assert_equal true,         HamlCompiler.options[:ugly]
+          assert_equal %w[pre code], HamlCompiler.options[:preserve]
+          reset_options(HamlCompiler)
+        end
+
+        it 'raises an OptionError if the option key is missing' do
+          assert_raises(OptionError) { parse('-o haml') }
+        end
+
+        it 'raises an OptionError if the extension is unregistered' do
+          assert_raises(OptionError) { parse('-o aml:ugly') }
+        end
+
+      end
+
+      it 'sets the source map flag' do
+        parse('--source-map')
+        assert_equal true, CoffeeCompiler.options[:sourceMap]
+        reset_options(CoffeeCompiler)
+      end
+
+      it 'requires the library' do
+        refute defined? OptionsLib
+        parse('--require ' + fixtures_path('options_lib'))
+        assert defined? OptionsLib
+      end
+
+    end
+
+    describe 'parse command line path arguments' do
+
+      before { MockOptions.send(:define_method, :validate_files) { super() } }
+      after  { MockOptions.send(:define_method, :validate_files) {} }
+
+      let(:dir)  { fixtures_path }
+      let(:file) { fixtures_path('moco.rb') }
+
+      it 'sets the source files and directories' do
+        assert_equal [file], parse("#{dir} #{file}")[:source_files]
+        assert_equal [dir],  parse("#{dir} #{file}")[:source_dirs]
+      end
+
+      it 'sets the compiled files and directories' do
+        assert_equal '/file', parse("#{file}:/file")[:compiled_files][file]
+        assert_equal '/dir',  parse("#{dir}:/dir")[:compiled_dirs][dir]
+      end
+
+      it 'raises an OptionError if no path is provided' do
+        assert_raises(OptionError) { parse }
+      end
+
+      it 'raises an OptionError if the path does not exists' do
+        assert_raises(OptionError) { parse('no_such_file') }
+      end
+
+      it 'raises an OptionError if the compiled file is a directory' do
+        assert_raises(OptionError) { parse("#{file}:#{dir}") }
+      end
+
+      it 'raises an OptionError if the compiled directory is a file' do
+        assert_raises(OptionError) { parse("#{dir}:#{file}") }
+      end
+
+    end
+
+    describe 'the moco file' do
+
+      before do
+        moco_file = fixtures_path('moco.rb')
+        MockOptions.send(:define_method, :load_moco_files) { load moco_file }
+      end
+
+      after do
+        MockOptions.send(:define_method, :load_moco_files) {}
+        Options.instance_variable_set(:@args, nil)
+        reset_register
+      end
+
+      it 'can register new compilers' do
+        parse
+        assert_equal TextCompiler, MoCo.compiler_for('txt')
+      end
+
+      it 'sets compiler options' do
+        parse
+        assert_equal ['pre'], TextCompiler.options[:preserve]
+        assert_equal :html5,  TextCompiler.options[:format]
+        assert_equal true,    TextCompiler.options[:ugly]
+      end
+
+      it 'sets general options' do
+        assert_equal false, parse[:reload]
+      end
+
+      specify 'the command line options have precedence' do
+        assert_equal true,  parse('-r -o txt:format:xml')[:reload]
+        assert_equal 'xml', TextCompiler.options[:format]
+      end
+
+      specify 'MoCo.args expects a shell escaped string' do
+        MoCo.args(%(-o txt:foo:'The "Quote"'))
+        MoCo.args(%(-o txt:bar:The\\ \\"Quote\\"))
+        parse
+        assert_equal 'The "Quote"', TextCompiler.options[:foo]
+        assert_equal 'The "Quote"', TextCompiler.options[:bar]
+      end
+
+      it 'finds the moco files in the current working directory' do
+        current_dir = Dir.pwd
+        Dir.chdir(tmp_dir)
+        touch([Dir.pwd + '/moco.rb', Dir.pwd + '/.moco'])
+        assert_includes Options.moco_files, Dir.pwd + '/moco.rb'
+        assert_includes Options.moco_files, Dir.pwd + '/.moco'
+        Dir.chdir(current_dir)
+      end
+
+    end
+
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../../lib/moco', __FILE__)
+require 'minitest/autorun'
+require 'tmpdir'
+
+COMPILERS = MoCo.compilers
+TMP_DIR   = Dir.mktmpdir('MoCo')
+
+MiniTest::Unit.after_tests do
+  FileUtils.rm_rf(TMP_DIR)
+end
+
+def tmp_dir
+  Dir.mktmpdir(nil, TMP_DIR)
+end
+
+def fixtures_path(file = nil)
+  fixtures_dir = File.expand_path('../fixtures', __FILE__)
+  file ? File.join(fixtures_dir, file) : fixtures_dir
+end
+
+def touch(files, options = {})
+  Array(files).each do |file|
+    FileUtils.makedirs(File.dirname(file))
+    FileUtils.touch(file, options)
+  end
+end
+
+def reset_register
+  register = MoCo::CompilerRegister.instance
+  register.instance_variable_set(:@compilers, COMPILERS.dup)
+end
+
+def reset_options(klass)
+  klass.instance_variable_set(:@options, {})
+end
+
+def run_compiler_tests?(klass)
+  klass.new('')
+rescue LoadError => e
+  warn "Skipping #{klass} tests (#{e.message.split("\n").first})"
+end
+
+def mock_compiler(klass, source_text, source_file = nil, compiled_file = nil)
+  source_file ||= "mock.#{MoCo.compilers.invert[klass]}"
+  mock = klass.new(source_file, compiled_file)
+  mock.define_singleton_method(:source_text) { source_text }
+  mock.define_singleton_method(:write_file) { |filename, text| }
+  mock
+end
+
+unless respond_to?(:define_singleton_method)
+  Object.send(:define_method, :define_singleton_method) do |name, &block|
+    singleton = class << self; self end
+    singleton.send(:define_method, name, &block)
+  end
+  Object.send(:public, :define_singleton_method)
+end