moco 0.1.0

data/src/reload.applescript

@@ -0,0 +1,135 @@
+on run argv
+  local browsers, urls
+  set {browsers, urls} to parse(argv)
+  if browsers contains "Canary"  then reloadCanary(urls)
+  if browsers contains "Chrome"  then reloadChrome(urls)
+  if browsers contains "Firefox" then reloadFirefox(urls)
+  if browsers contains "Opera"   then reloadOpera(urls)
+  if browsers contains "Safari"  then reloadSafari(urls)
+  if browsers contains "WebKit"  then reloadWebKit(urls)
+  return
+end
+
+on parse(argv)
+  set urls to {}
+  set browsers to {}
+  set allBrowsers to {"Canary", "Chrome", "Firefox", "Opera", "Safari", "WebKit"}
+
+  repeat with arg in argv
+    set arg to arg as string
+    if allBrowsers contains arg then
+      set browsers to browsers & arg
+    else
+      set urls to urls & arg
+    end
+  end
+
+  if browsers = {} then set browsers to allBrowsers
+
+  return {browsers, urls}
+end
+
+on shouldReload(_url, urls)
+  if _url = "" then return false
+  if urls = {} then return true
+  repeat with u in urls
+    if _url starts with u then return true
+  end
+  return false
+end
+
+on reloadSafari(urls)
+  reloadSafariWebKit("Safari", urls)
+end
+
+on reloadWebKit(urls)
+  reloadSafariWebKit("WebKit", urls)
+end
+
+on reloadSafariWebKit(browser, urls)
+  using terms from application "Safari"
+    tell application browser
+      if it is not running then return
+      if (windows where visible is true) = {} then return
+      if not (front document exists) then return
+
+      tell front document
+        if my shouldReload(URL as string, urls) then
+          do JavaScript "location.reload()"
+        end
+      end
+    end
+  end
+end
+
+on reloadChrome(urls)
+  reloadGoogleChrome("Google Chrome", urls)
+end
+
+on reloadCanary(urls)
+  reloadGoogleChrome("Google Chrome Canary", urls)
+end
+
+on reloadGoogleChrome(browser, urls)
+  using terms from application "Google Chrome"
+    tell application browser
+      if it is not running then return
+      if (windows where visible is true) = {} then return
+
+      tell active tab of front window
+        if my shouldReload(URL, urls) then reload
+      end
+    end
+  end
+end
+
+on reloadOpera(urls)
+  tell application "Opera"
+    if it is not running then return
+
+    if my shouldReload(URL of front document as string, urls) then
+      set URL of front document to "javascript:location.reload()"
+    end
+  end
+end
+
+on reloadFirefox(urls)
+  tell application "Firefox"
+    if it is not running then return
+    if (windows where visible is true) = {} then return
+
+    set frontApp to my findFrontApp()
+    activate
+    if my shouldReload(my copyUrl(), urls) then my doReload()
+    my resetFrontApp(frontApp)
+  end
+end
+
+on copyUrl()
+  set the clipboard to ""
+  tell application "System Events"
+    delay 0.01
+    keystroke "l" using {command down}
+    delay 0.01
+    keystroke "c" using {command down}
+    delay 0.1
+  end
+  return the clipboard as string
+end
+
+on doReload()
+  tell application "System Events"
+    delay 0.01
+    keystroke "r" using {command down}
+  end
+end
+
+on findFrontApp()
+  tell application "System Events"
+    return first process where frontmost is true
+  end
+end
+
+on resetFrontApp(frontApp)
+  tell frontApp to set frontmost to true
+end

data/test/ansi_escape_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module MoCo
+
+  describe AnsiEscape do
+
+    def stdout_tty(tty, &block)
+      $stdout = $stdout.dup
+      $stdout.define_singleton_method(:tty?) { tty }
+      yield
+    ensure
+      $stdout = STDOUT
+    end
+
+    it 'escapes the message when stdout points to a terminal' do
+      stdout_tty(true) do
+        assert_equal    "\e[1mHello\e[0m", AnsiEscape.bold('Hello')
+        assert_equal "\e[1;31mHello\e[0m", AnsiEscape.bold_red('Hello')
+      end
+    end
+
+    it 'leaves the message alone if stdout is redirected to a file' do
+      stdout_tty(false) do
+        assert_equal 'Hello', AnsiEscape.bold('Hello')
+        assert_equal 'Hello', AnsiEscape.bold_red('Hello')
+      end
+    end
+
+    describe 'unescape' do
+
+      let(:hello) { "\e[1mHello\e[0m \e[1;31mWorld\e[00m!" }
+
+      it 'removes ANSI escape sequences' do
+        assert_equal 'Hello World!', AnsiEscape.unescape(hello)
+      end
+
+      it 'can replace ANSI escape sequences' do
+        unescaped = AnsiEscape.unescape(hello) { |msg| "<b>#{msg}</b>" }
+        assert_equal '<b>Hello</b> <b>World</b>!', unescaped
+      end
+
+      it 'does not support nested escape sequences' do
+        nested = "\e[;31mNested \e[1mEscape\e[m\e[0m"
+        refute_equal 'Nested Escape',           AnsiEscape.unescape(nested)
+        assert_equal "Nested \e[1mEscape\e[0m", AnsiEscape.unescape(nested)
+      end
+
+    end
+
+  end
+
+end

data/test/application_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module MoCo
+
+  describe Application do
+
+    describe 'the compiled directory' do
+
+      def compiled_dir(file)
+        compiled_dirs = {
+          '/one'           => '/1',
+          '/one/two'       => nil,
+          '/one/two/three' => '/3',
+        }
+        Application.new(:compiled_dirs => compiled_dirs).compiled_dir(file)
+      end
+
+      before { Application.send(:public,  :compiled_dir) }
+      after  { Application.send(:private, :compiled_dir) }
+
+      it 'returns the directory that closest matches the filename' do
+        assert_equal '/1', compiled_dir('/one/file')
+        assert_equal '/3', compiled_dir('/one/two/three/file')
+      end
+
+      it 'keeps the nested directory structure' do
+        assert_equal '/1/nested', compiled_dir('/one/nested/file')
+        assert_equal '/3/nested', compiled_dir('/one/two/three/nested/file')
+      end
+
+      it 'returns nil when the compiled directory is unspecified' do
+        assert_nil compiled_dir('/one/two/file')
+        assert_nil compiled_dir('/one/two/nested/file')
+      end
+
+    end
+
+  end
+
+end

data/test/browser_error_test.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+module MoCo
+
+  describe BrowserError do
+
+    class BrowserError
+      define_method(:txmt_url_scheme?) { true }
+    end
+
+    let(:error) do
+      error = StandardError.new("\e[1;31m eval \e[0m error \\n&")
+      error.define_singleton_method(:line) { 2 }
+      error.define_singleton_method(:column) { 7 }
+      CompileError.new(error, File.expand_path('~') + '/file.txt')
+    end
+
+    describe 'the browser error message' do
+
+      let(:msg) { BrowserError.message(error) }
+
+      it 'contains the line number and filename' do
+        assert_match "\n\nLine: 2\nFile: file.txt", msg
+      end
+
+      it 'shortens the filename by replacing the home directory with ~' do
+        assert_match '>~/file.txt</a>', msg
+      end
+
+    end
+
+    describe 'the CSS error message' do
+
+      let(:msg) { CssError.message(error) }
+
+      it 'is CSS' do
+        assert_match 'body:before {', msg
+      end
+
+      it 'is escaped for CSS' do
+        assert_match 'error \\\\n&\\a \\a Line: 2', msg
+      end
+
+      it 'removes ansi color codes completely' do
+        refute_match '[1;31m', msg
+        refute_match '<span>', msg
+      end
+
+      it 'has no link' do
+        refute_match '<a href', msg
+      end
+
+    end
+
+    describe 'the JavaScript error message' do
+
+      let(:msg) { JsError.message(error) }
+
+      it 'is JavaScript' do
+        assert_match 'function() {', msg
+      end
+
+      it 'is escaped for Html' do
+        assert_match 'error \\\\n&amp;<br><br>Line: 2', msg
+      end
+
+      it 'replaces ansi color codes with a span element' do
+        refute_match '[1;31m', msg
+        assert_match '<span> eval </span>', msg
+      end
+
+      it 'has a TextMate link to the exact error location' do
+        link = "<a href='txmt://open/?url=file://~/file.txt&line=2&column=7'>"
+        assert_match link, msg
+      end
+
+      it 'has no link if the TextMate url scheme is unsupported' do
+        js_error = JsError.new(error)
+        js_error.define_singleton_method(:txmt_url_scheme?) { false }
+        refute_match '<a href', js_error.message
+      end
+
+    end
+
+    describe 'the HTML error message' do
+
+      let(:msg) { HtmlError.message(error) }
+
+      it 'is Html' do
+        assert_match '<!DOCTYPE html>', msg
+      end
+
+      it 'contains the JavaScript error message' do
+        assert_match JsError.message(error), msg
+      end
+
+    end
+
+  end
+
+end

data/test/browser_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module MoCo
+
+  describe Browser do
+
+    describe 'urls' do
+
+      def urls(*urls)
+        Browser.new([], [], urls).instance_variable_get(:@args)
+      end
+
+      it "expands 'localhost' into all the localhost urls" do
+        assert_equal Browser.localhost, urls('localhost')
+      end
+
+      it "empties the urls if it contains 'all'" do
+        assert_empty urls('localhost', 'all')
+      end
+
+      it 'removes duplicates' do
+        assert_equal 1, urls('file:///', 'file:///').size
+      end
+
+    end
+
+  end
+
+end

data/test/compile_error_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+module MoCo
+
+  describe CompileError do
+
+    describe 'the error message' do
+
+      let(:error) do
+        message = 'script.coffee:4:8: Error: syntax error'
+        CompileError.new(StandardError.new(message), 'script.coffee')
+      end
+
+      it 'removes the filename and line number' do
+        refute_match 'script.coffee', error.message
+        refute_match /\d/, error.message
+      end
+
+      it 'removes error: from the start of the message' do
+        refute_match 'Error:', error.message
+      end
+
+      it 'capitalizes the first letter' do
+        assert_equal 'Syntax error', error.message
+      end
+
+    end
+
+    describe 'the line number' do
+
+      def line_from(options)
+        error = StandardError.new(options[:message])
+        error.define_singleton_method(:line) { options[:line_method] }
+        error.set_backtrace(options[:backtrace])
+        CompileError.new(error, 'index.haml').line
+      end
+
+      it 'uses the line method of the original error' do
+        assert_equal 2, line_from(:line_method => 2)
+      end
+
+      it 'finds the line number in the error message' do
+        assert_equal 42, line_from(:message => 'index.haml:42 ...')
+      end
+
+      it 'finds the line number in the backtrace' do
+        assert_equal 4, line_from(:backtrace => 'index.haml:4:2: ...')
+      end
+
+      it 'ignores line numbers from other files' do
+        assert_nil line_from(:backtrace => 'about.haml:2: ...')
+      end
+
+      it 'works with filenames containing special characters' do
+        file = 'index( |*).haml'
+        error = CompileError.new(StandardError.new(file + ':7:'), file)
+        assert_equal 7, error.line
+      end
+
+    end
+
+    describe 'the column' do
+
+      def column_from(options)
+        error = StandardError.new(options[:message])
+        error.define_singleton_method(:column) { options[:column_method] }
+        CompileError.new(error, 'index.haml').column
+      end
+
+      it 'uses the column method of the original error' do
+        assert_equal 4, column_from(:column_method => 4)
+      end
+
+      it 'finds the column in the error message' do
+        assert_equal 2, column_from(:message => 'index.haml:4:2: ...')
+      end
+
+    end
+
+  end
+
+end

data/test/compiler_option_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+module MoCo
+
+  describe CompilerOption do
+
+    def convert(option)
+      value = option.split(':', 3)[2]
+      CompilerOption.convert(value)
+    end
+
+    specify 'convert booleans' do
+      assert_equal true,  convert('ext:key:true')
+      assert_equal false, convert('ext:key:false')
+    end
+
+    specify 'the default option value is true' do
+      assert_equal true, convert('ext:key')
+    end
+
+    specify 'convert integers' do
+      assert_equal 100, convert('ext:key:100')
+      assert_equal -10, convert('ext:key:-10')
+      assert_equal   7, convert('ext:key:+007')
+    end
+
+    specify 'convert floats' do
+      assert_equal  0.5, convert('ext:key:.5')
+      assert_equal  0.5, convert('ext:key:+0.5')
+      assert_equal -0.5, convert('ext:key:-.5')
+    end
+
+    specify 'exponential notation is unsupported' do
+      assert_equal '1e2', convert('ext:key:1e2')
+    end
+
+    describe 'convert symbols' do
+
+      specify do
+        assert_equal :html5, convert('ext:key::html5')
+        assert_equal :false, convert('ext:key::false')
+        assert_equal :'007', convert('ext:key::007')
+      end
+
+      specify 'do not quote symbols' do
+        assert_equal :'"dir/file"', convert('ext:key::"dir/file"')
+        assert_equal :'dir/file',   convert('ext:key::dir/file')
+      end
+
+      specify 'symbols with colons are unsupported' do
+        assert_equal [:'"foo', 'bar"'], convert('ext:key::"foo:bar"')
+        assert_equal [:'foo\\', 'bar'], convert('ext:key::foo\\:bar')
+      end
+
+    end
+
+    describe 'convert strings' do
+
+      specify do
+        assert_equal 'value', convert('ext:key:value')
+        assert_equal 'v a l', convert('ext:key:v a l')
+        assert_equal "cat's", convert("ext:key:cat's")
+      end
+
+      specify 'quoted strings' do
+        assert_equal '007',   convert('ext:key:"007"')
+        assert_equal 'true',  convert("ext:key:'true'")
+        assert_equal 'a:b:c', convert('ext:key:"a:b:c"')
+      end
+
+      specify 'double quoted strings can include single quotes and vice versa' do
+        assert_equal ":cat's", convert(%(ext:key:":cat's"))
+        assert_equal "'cat'",  convert(%(ext:key:"'cat'"))
+        assert_equal '"cat"',  convert(%(ext:key:'"cat"'))
+      end
+
+      specify 'quoted strings cannot include the same quote character' do
+        assert_equal ["'", "cat's'"], convert(%(ext:key:':cat's'))
+        assert_equal "''cat''",       convert(%(ext:key:''cat''))
+        assert_equal '""cat""',       convert(%(ext:key:""cat""))
+      end
+
+      specify 'single and double quotes cannot be mixed' do
+        assert_equal ["'not", 'quoted"'], convert(%(ext:key:'not:quoted"))
+      end
+
+    end
+
+    specify 'convert empty strings and arrays' do
+      assert_equal '',   convert('ext:key:')
+      assert_equal [],   convert('ext:key::')
+      assert_equal [''], convert('ext:key:"":')
+    end
+
+    describe 'convert arrays' do
+
+      specify 'string arrays' do
+        assert_equal ['one', 'two'], convert('ext:key:one:two')
+        assert_equal ['one'],        convert('ext:key:one:')
+      end
+
+      specify 'symbol arrays' do
+        assert_equal [:one, :two], convert('ext:key::one::two')
+        assert_equal [:one],       convert('ext:key::one:')
+      end
+
+      specify 'array with mixed types' do
+        assert_equal ["Cat's toy", true, :html5, -0.1, "007"],
+          convert('ext:key:"Cat\'s toy":true::html5:-.1:"007"')
+      end
+
+      specify 'array values cannot include colons' do
+        assert_equal ['"Title', ' MoCo"'], convert('ext:key:"Title: MoCo":')
+        assert_equal ["'", "not_symbol'"], convert("ext:key:':not_symbol':")
+      end
+
+    end
+
+  end
+
+end

data/test/compiler_register_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module MoCo
+
+  describe CompilerRegister do
+
+    before { Singleton.__init__(CompilerRegister) }
+    after  { reset_register }
+
+    it 'registers the compiler class for the source extension' do
+      HtmlCompiler.register('haml')
+      assert_equal HtmlCompiler, MoCo.compiler_for('haml')
+    end
+
+    describe 'compiler lookup' do
+
+      before do
+        MoCo.register(CssCompiler, 'sass')
+        MoCo.register(CssCompiler, 'scss')
+        MoCo.register(HtmlCompiler, 'md')
+      end
+
+      it 'works when more than one compiler is registered' do
+        assert_equal CssCompiler,  MoCo.compiler_for('scss')
+        assert_equal HtmlCompiler, MoCo.compiler_for('md')
+        assert_equal CssCompiler,  MoCo.compiler_for('sass')
+      end
+
+      it 'accepts a filename' do
+        assert_equal CssCompiler, MoCo.compiler_for('/dir/a style.css.sass')
+      end
+
+      it 'returns nil when the extension is unregistered' do
+        assert_nil MoCo.compiler_for('dummy')
+      end
+
+    end
+
+  end
+
+end