moco 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bf216f6a4a3693e7fbe4208e2ce90c6c1381c18
+  data.tar.gz: 4ca98a5e6728548265487bdc3c310009fee3462b
+SHA512:
+  metadata.gz: 86b782cc69382beb4f4c2e9ea9408db2bd2d4f870966f83400de7bfe7feb57825abf15e31919d29212e9d8fa9a976a940a1195faecd631bbe36324b8cf720e74
+  data.tar.gz: c61aadfb6a5897fc065b160216fffed557624c2482ff119351c52290e37726f17db56cbfa36854a0baf7bd4abc3c66b297b41165b9c088435cd657651843ac61

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 AS Harbitz
+
+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.txt

@@ -0,0 +1,67 @@
+Usage:
+  moco [options] SOURCE ...
+  moco [options] SOURCE:COMPILED ...
+
+Description:
+  MoCo monitors web templates. On updates the templates are compiled and
+  the browser reloaded. MoCo currently supports CoffeeScript, Sass, LESS,
+  Markdown and Haml.
+
+Files and directories:
+  The given source files and directories will be monitored for updates.
+  Use the SOURCE:COMPILED format to save the compiled files to another
+  directory or to change the compiled filename:
+  moco .:/www sass:/www/css README.md:/www/index.html
+
+Options:
+      --monitor             Keep running until Ctrl-C is pressed [DEFAULT]
+      --no-monitor          Exit after the initial compilation
+
+  -c, --compile             Compile all the supported file types [DEFAULT]
+  -c, --compile EXT,EXT     Compile the given file types
+      --no-compile          Disable compilation
+                            moco -c coffee -c sass,scss .
+
+  -f, --force               Force recompilation at startup
+      --no-force            Do not compile up-to-date files [DEFAULT]
+
+  -m, --source-map          Make source maps if the compiler supports it
+      --no-source-map       Do not make source maps [DEFAULT]
+
+  -o, --option EXT:KEY:VAL  Set a compiler option
+                            moco -o coffee:header       # header = true
+                                 -o haml:ugly:false     # ugly   = false
+                                 -o haml:format::xhtml  # format = :xhtml
+                                 -o md:layout:md.html   # layout = 'md.html'
+                                 -o less:paths:css: .   # paths  = ['css']
+
+  -r, --reload              Reload after css/html/js file updates [DEFAULT]
+  -r, --reload EXT,EXT      Set the file types that triggers reloading
+      --no-reload           Disable reloading
+                            moco -r rb -r css,html,js .
+
+  -b, --browser BRO,BRO     The browsers to reload [all by DEFAULT]
+                            moco -b safari -b chrome,canary .
+
+  -u, --url all             Reload all active tabs
+  -u, --url localhost       Reload active tabs with localhost urls [DEFAULT]
+  -u, --url URL,URL         Reload active tabs where the url starts with URL
+                            moco -u localhost -u http://app.dev/ .
+
+      --require LIB         Require the library
+                            moco --require path/to/compiler.rb .
+
+  -q, --quiet               Log errors only
+      --no-quiet            Log errors and file updates [DEFAULT]
+
+  -l, --list                List the supported file types and browsers
+
+  -h, --help                Display this message
+
+The moco file:
+  MoCo looks for files named '.moco' and 'moco.rb' in the working directory
+  and in the home directory. The purpose of these files is to set options
+  and to define new compilers. The command line options have precedence.
+
+More information:
+  https://github.com/asharbitz/moco#readme

data/Rakefile

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+
+require 'moco'
+require 'rake/testtask'
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/*_test.rb'
+end
+
+desc 'Compile files'
+task :compile do
+  args = %w[--force --no-monitor --no-reload]
+  MoCo::Application.monitor_compile_and_reload(args)
+end

data/bin/moco

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems' unless defined? Gem
+require 'moco'
+
+MoCo::Application.monitor_compile_and_reload(ARGV)

data/lib/moco/ansi_escape.rb

@@ -0,0 +1,37 @@
+module MoCo
+
+  module AnsiEscape
+
+    def self.bold(text)
+      escape(text, '1')
+    end
+
+    def self.bold_red(text)
+      escape(text, '1;31')
+    end
+
+    def self.green(text)
+      escape(text, '32')
+    end
+
+    def self.unescape(text)
+      text.gsub(/\e\[[\d;]+m(.*?)\e\[0*m/) do
+        block_given? ? yield($1) : $1
+      end
+    end
+
+  private
+
+    def self.escape(text, code)
+      if $stdout.tty?
+        "\e[#{code}m#{text}\e[0m"
+      else
+        text
+      end
+    end
+
+    private_class_method :escape
+
+  end
+
+end

data/lib/moco/application.rb

@@ -0,0 +1,109 @@
+module MoCo
+
+  class Application
+
+    def self.monitor_compile_and_reload(args)
+      options = parse_options(args)
+      new(options).monitor_compile_and_reload
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def monitor_compile_and_reload
+      monitor = monitor_instance
+      monitor.files.each { |file| compile(file, @options[:force]) }
+      reload
+      if @options[:monitor]
+        Log.monitor
+        monitor.monitor { |file| compile_and_reload(file) }
+        puts
+      end
+    end
+
+  private
+
+    def self.parse_options(args)
+      options = Options.parse(args)
+      Log.quiet = options[:quiet]
+      Log.load(Options.moco_files)
+      options
+    rescue OptionError, LoadError => e
+      Log.load(Options.moco_files)
+      abort e.message
+    end
+
+    private_class_method :parse_options
+
+    def monitor_instance
+      exts = []
+      exts += @options[:compile_exts] if @options[:compile]
+      exts += @options[:reload_exts]  if @options[:reload]
+      Monitor.new(@options[:source_files], @options[:source_dirs], exts.uniq)
+    end
+
+    def compile_and_reload(file)
+      if compiler = compile(file, true)
+        reload(compiler.compiled_file)
+      end
+      reload(file)
+    end
+
+    def compile(file, force)
+      if @options[:compile]
+        compiler = compiler_for(file)
+        if compiler && (force || compiler.should_compile?)
+          do_compile(compiler)
+          compiler
+        end
+      end
+    end
+
+    def compiler_for(file)
+      if compiler = MoCo.compiler_for(file)
+        compiler.new(file, compiled_file(file), compiled_dir(file))
+      end
+    rescue LoadError => e
+      abort e.message
+    end
+
+    def compiled_file(file)
+      @options[:compiled_files][file]
+    end
+
+    def compiled_dir(file)
+      @options[:compiled_dirs].keys.sort.reverse.each do |source_dir|
+        if file.start_with?(source_dir)
+          compiled_dir = @options[:compiled_dirs][source_dir]
+          if compiled_dir
+            compiled_dir = File.dirname(file).sub(source_dir, compiled_dir)
+          end
+          return compiled_dir
+        end
+      end
+      nil
+    end
+
+    def do_compile(compiler)
+      Log.compile(compiler)
+      compiler.compile
+      Log.update(compiler)
+    rescue CompileError => e
+      Log.error(e)
+    end
+
+    def reload(file = nil)
+      if @options[:reload]
+        @browser ||= browser_instance
+        @browser.reload if file.nil? || @browser.should_reload?(file)
+      end
+    end
+
+    def browser_instance
+      Browser.new(@options[:reload_exts], @options[:browsers], @options[:urls])
+    end
+
+  end
+
+end

data/lib/moco/browser.rb

@@ -0,0 +1,64 @@
+module MoCo
+
+  class Browser
+
+    def self.extensions
+      %w[css html js]
+    end
+
+    def self.browsers
+      %w[Canary Chrome Firefox Opera Safari WebKit]
+    end
+
+    def self.localhost
+      %w[
+        file:///
+        file://localhost/
+        http://localhost/
+        http://localhost:
+        http://127.0.0.1/
+        http://127.0.0.1:
+        http://0.0.0.0/
+        http://0.0.0.0:
+      ]
+    end
+
+    def initialize(extensions, browsers, urls)
+      @extensions = extensions
+      @args = browsers + urls(urls)
+      @reload = false
+      at_exit { do_reload }
+    end
+
+    def should_reload?(file)
+      @extensions.include?(FileUtil.normalized_extension(file))
+    end
+
+    def reload
+      return if @reload
+      @reload = true
+      Thread.new do
+        sleep 0.2
+        do_reload
+      end
+    end
+
+  private
+
+    SCRIPT = File.expand_path('../support/reload.scpt', __FILE__)
+
+    def urls(urls)
+      return [] if urls.include?('all')
+      urls += Browser.localhost if urls.delete('localhost')
+      urls.uniq
+    end
+
+    def do_reload
+      return unless @reload
+      @reload = false
+      system('osascript', SCRIPT, *@args)
+    end
+
+  end
+
+end

data/lib/moco/browser_error.rb

@@ -0,0 +1,105 @@
+require 'cgi'
+
+module MoCo
+
+  class BrowserError
+
+    def self.message(error)
+      new(error).message
+    end
+
+    def initialize(error)
+      @message = error.message
+      @file    = file(error)
+      @line    = error.line
+      @column  = error.column
+    end
+
+    def message
+      escaped_message + on_line + in_file
+    end
+
+  private
+
+    def file(error)
+      FileUtil.short_path(error.file)
+    end
+
+    def read_file(file)
+      File.read(File.expand_path('../support/error/' + file, __FILE__))
+    end
+
+    def escaped_message(message = @message)
+      message = remove_ansi_color(message)
+      message = message.gsub('\\') { '\\\\' }.gsub('"', '\"')
+      message + "\n\n"
+    end
+
+    def remove_ansi_color(message)
+      AnsiEscape.unescape(message) do |escaped|
+        html_allowed? ? "<span>#{escaped}</span>" : escaped
+      end
+    end
+
+    def html_allowed?
+      true
+    end
+
+    def on_line
+      @line ? "Line: #{@line}\n" : ''
+    end
+
+    def in_file
+      "File: #{File.basename(@file)} (#{edit_link || @file})"
+    end
+
+    def edit_link
+      if html_allowed? && txmt_url_scheme?
+        href = "txmt://open/?url=file://#{@file}"
+        href << "&line=#{@line}" if @line
+        href << "&column=#{@column}" if @column
+        "<a href='#{href}'>#{@file}</a>"
+      end
+    end
+
+    def txmt_url_scheme?
+      return @@txmt if defined? @@txmt
+      @@txmt = `defaults read com.apple.LaunchServices` =~
+               /LSHandlerURLScheme["\s]*=["\s]*txmt["\s]*;/
+    end
+
+  end
+
+  class CssError < BrowserError
+
+    def message
+      read_file('error.css') % super.gsub(/\n/, '\a ')
+    end
+
+    def html_allowed?
+      false
+    end
+
+  end
+
+  class JsError < BrowserError
+
+    def message
+      read_file('error.js') % super.gsub(/\n/, '<br>')
+    end
+
+    def escaped_message
+      super(CGI.escapeHTML(@message))
+    end
+
+  end
+
+  class HtmlError < JsError
+
+    def message
+      read_file('error.html') % super
+    end
+
+  end
+
+end

data/lib/moco/compile_error.rb

@@ -0,0 +1,66 @@
+module MoCo
+
+  class CompileError < Error
+
+    attr_reader :error
+    attr_reader :file
+    attr_reader :line
+    attr_reader :column
+
+    def initialize(error, file)
+      @error  = error
+      @file   = file
+      @line   = get_line
+      @column = get_column
+      super(get_message)
+    end
+
+  private
+
+    def get_line
+      line = line_from_method || line_from_message || line_from_backtrace
+      line.to_i if line
+    end
+
+    def line_from_method
+      @error.line if @error.respond_to?(:line)
+    end
+
+    def line_from_message
+      @error.message[source_pattern, 1]
+    end
+
+    def line_from_backtrace
+      if @error.backtrace && @error.backtrace[0]
+        @error.backtrace[0][source_pattern, 1]
+      end
+    end
+
+    def get_column
+      column = column_from_method || column_from_message
+      column.to_i if column
+    end
+
+    def column_from_method
+      @error.column if @error.respond_to?(:column)
+    end
+
+    def column_from_message
+      @error.message[source_pattern, 2]
+    end
+
+    def source_pattern
+      file = Regexp.escape(@file)
+      /^#{file}:(\d+):?(\d+)?[:\s]*/
+    end
+
+    def get_message
+      message = @error.message.gsub(source_pattern, '')
+      message = message.sub(/\Aerror: /i, '')
+      message[0, 1] = message[0, 1].upcase
+      message
+    end
+
+  end
+
+end

data/lib/moco/compiler.rb

@@ -0,0 +1,151 @@
+module MoCo
+
+  class Compiler
+
+    def self.register(source_extension)
+      MoCo.register(self, source_extension)
+    end
+
+    def self.require_library(lib, gem_name = lib, version = nil)
+      @libraries ||= []
+      @libraries << [lib, gem_name, version]
+    end
+
+    def self.set_option(key, value = true)
+      @options ||= {}
+      @options[key] = value
+    end
+
+    def self.options
+      (@options || {}).dup
+    end
+
+    def self.convert_option(key, value)
+      [key.to_sym, CompilerOption.convert(value)]
+    end
+
+    def self.compiled_extension
+      raise NotImplementedError
+    end
+
+    attr_reader :source_file
+    attr_reader :compiled_file
+
+    def initialize(source_file, compiled_file = nil, compiled_dir = nil)
+      @source_file = source_file
+      @compiled_file = compiled_file || compiled_filename(compiled_dir)
+      validate_filenames
+      require_libraries
+    end
+
+    def should_compile?
+      ! FileUtil.up_to_date?(@compiled_file, @source_file)
+    end
+
+    def compile
+      write_compiled(compiled_text)
+    rescue SyntaxError, StandardError => e
+      error = CompileError.new(e, @source_file)
+      error.set_backtrace(e.backtrace)
+      write_compiled(error_text(error))
+      raise error
+    end
+
+    def options
+      self.class.options
+    end
+
+    def source_text
+      File.read(@source_file)
+    end
+
+    def compiled_text
+      raise NotImplementedError
+    end
+
+  private
+
+    def compiled_filename(compiled_dir)
+      compiled_ext = self.class.compiled_extension
+      compiled_file = FileUtil.replace_extension(@source_file, compiled_ext)
+      FileUtil.replace_directory(compiled_file, compiled_dir)
+    end
+
+    def validate_filenames
+      if File.expand_path(@source_file) == File.expand_path(@compiled_file)
+        raise Error, 'The source and compiled filenames are identical'
+      end
+    end
+
+    def require_libraries
+      self.class.ancestors.each do |klass|
+        if libs = klass.instance_variable_get(:@libraries)
+          libs.each { |lib| require_library(*lib) }
+          libs.clear
+        end
+      end
+    end
+
+    def require_library(lib, gem_name = lib, version = nil)
+      gem gem_name, version if version
+      require lib
+    rescue LoadError => e
+      if e.message !~ /\b(#{lib}|#{gem_name})\b/
+        raise  # Another library failed to load
+      else
+        version = " -v '#{version}'" if version
+        raise e, "#{e.message}\nTry: gem install #{gem_name}#{version}"
+      end
+    end
+
+    def write_compiled(text)
+      write_file(@compiled_file, text)
+    end
+
+    def write_file(filename, text)
+      FileUtil.write(filename, text)
+    end
+
+    def error_text(error)
+      error.message
+    end
+
+  end
+
+  class HtmlCompiler < Compiler
+
+    def self.compiled_extension
+      'html'
+    end
+
+    def error_text(error)
+      HtmlError.message(error)
+    end
+
+  end
+
+  class CssCompiler < Compiler
+
+    def self.compiled_extension
+      'css'
+    end
+
+    def error_text(error)
+      CssError.message(error)
+    end
+
+  end
+
+  class JsCompiler < Compiler
+
+    def self.compiled_extension
+      'js'
+    end
+
+    def error_text(error)
+      JsError.message(error)
+    end
+
+  end
+
+end