moco 0.1.0

data/lib/moco/options.rb

@@ -0,0 +1,336 @@
+require 'optparse'
+require 'shellwords'
+
+module MoCo
+
+  class Options
+
+    def self.moco_files
+      files = ['~/.moco', '~/moco.rb', './.moco', './moco.rb']
+      files = files.map { |file| File.expand_path(file) }
+      files.select { |file| File.file?(file) }
+    end
+
+    def self.args(args)
+      @args ||= []
+      @args += args.shellsplit
+    end
+
+    def self.parse(args)
+      new.parse(args)
+    end
+
+    def parse(command_line_args)
+      @options = {}
+      args = moco_file_args + command_line_args
+      display_help if args.empty?
+      option_parser.order(args) { |option| path(option) }
+      validate_options
+      default_options.merge(@options)
+    rescue OptionParser::ParseError => e
+      raise OptionError.new(e)
+    end
+
+    def option_parser
+      OptionParser.new do |op|
+        op.version = MoCo::VERSION
+        op.on(      '--[no-]monitor',           method(:monitor))
+        op.on('-c', '--[no-]compile [EXT,EXT]', method(:compile), Array)
+        op.on('-f', '--[no-]force',             method(:force))
+        op.on('-m', '--[no-]source-map',        method(:source_map))
+        op.on('-o', '--option EXT:KEY:VAL',     method(:compiler_option))
+        op.on('-r', '--[no-]reload [EXT,EXT]',  method(:reload), Array)
+        op.on('-b', '--browser BRO,BRO',        method(:browsers), Array)
+        op.on('-u', '--url URL,URL',            method(:urls), Array)
+        op.on(      '--require LIB',            method(:require_lib))
+        op.on('-q', '--[no-]quiet',             method(:quiet))
+        op.on('-l', '--list',                   method(:display_list))
+        op.on('-h', '--help',                   method(:display_help))
+      end
+    end
+
+    def default_options
+      {
+        :monitor        => true,
+        :compile        => true,
+        :compile_exts   => MoCo.compilers.keys.sort,
+        :force          => false,
+        :source_map     => false,
+        :reload         => true,
+        :reload_exts    => Browser.extensions,
+        :browsers       => Browser.browsers,
+        :urls           => Browser.localhost,
+        :quiet          => false,
+        :source_files   => [],
+        :source_dirs    => [],
+        :compiled_files => {},
+        :compiled_dirs  => {}
+      }
+    end
+
+    def help
+      <<-EOF.gsub(/^ {8}/, '').gsub(/`(.+?)`/, AnsiEscape.green('\1'))
+        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
+      EOF
+    end
+
+  private
+
+    def moco_file_args
+      load_moco_files
+      Options.instance_variable_get(:@args) || []
+    end
+
+    def load_moco_files
+      Options.moco_files.each do |file|
+        load file
+      end
+    end
+
+    [:monitor, :force, :browsers, :urls].each do |key|
+      define_method(key) do |option|
+        set_option(key, option)
+      end
+    end
+
+    [:compile, :reload].each do |key|
+      define_method(key) do |option|
+        case option
+        when Array
+          option.map! { |ext| FileUtil.normalized_extension(ext) }
+          set_option("#{key}_exts".to_sym, option)
+          set_option(key, true)
+        when nil
+          set_option(key, true)
+        else
+          set_option(key, option)
+        end
+      end
+    end
+
+    def set_option(key, option)
+      case option
+      when Array
+        @options[key] ||= []
+        @options[key] += option
+        @options[key].uniq!
+      when Hash
+        @options[key] ||= {}
+        @options[key].merge!(option)
+      else
+        @options[key] = option
+      end
+    end
+
+    def compiler_option(option)
+      ext, key, value = option.split(':', 3)
+      compiler = MoCo.compiler_for(ext)
+      raise OptionError.new(:missing_option_key) unless key
+      raise OptionError.new(:invalid_extension, ext) unless compiler
+      key, value = compiler.convert_option(key, value)
+      compiler.set_option(key, value)
+    end
+
+    def source_map(option)
+      MoCo.compilers.each_value do |compiler|
+        if compiler < SourceMap
+          compiler.set_option(compiler.source_map_key, option)
+        end
+      end
+    end
+
+    def require_lib(option)
+      require option
+    rescue LoadError
+      require File.expand_path(option)
+    end
+
+    def quiet(option)
+      set_option(:quiet, option)
+      SassCompiler.set_option(:quiet, option)
+    end
+
+    def display_list(option)
+      display(list)
+    end
+
+    def display_help(option = nil)
+      display(help)
+    end
+
+    def display(text)
+      puts
+      puts text
+      puts
+      exit 0
+    end
+
+    def list
+      [ ['Compile:',   :compile_exts],
+        ['Reload:',    :reload_exts],
+        ['Browsers:',  :browsers],
+        ['Localhost:', :urls]
+      ].map do |header, key|
+        [header, *default_options[key]].join("\n  ")
+      end.join("\n\n")
+    end
+
+    def path(option)
+      source, compiled = option.split(':')
+      source   = File.expand_path(source)
+      compiled = File.expand_path(compiled) if compiled
+      if File.directory?(source)
+        set_option(:source_dirs, [source])
+        set_option(:compiled_dirs, source => compiled)
+      elsif File.file?(source)
+        set_option(:source_files, [source])
+        set_option(:compiled_files, source => compiled)
+      else
+        raise OptionError.new(:invalid_file, source)
+      end
+    end
+
+    def validate_options
+      validate_files
+      validate_compilers
+      validate_browsers
+    end
+
+    def validate_files
+      unless @options[:source_dirs] || @options[:source_files]
+        raise OptionError.new(:missing_file)
+      end
+      (@options[:compiled_dirs] || {}).each_value do |dir|
+        if dir && File.file?(dir)
+          raise OptionError.new(:dir_expected, dir)
+        end
+      end
+      (@options[:compiled_files] || {}).each_value do |file|
+         if file && File.directory?(file)
+           raise OptionError.new(:file_expected, file)
+         end
+      end
+    end
+
+    def validate_compilers
+      (@options[:compile_exts] || []).each do |ext|
+        unless MoCo.compiler_for(ext)
+          raise OptionError.new(:invalid_extension, ext)
+        end
+      end
+    end
+
+    def validate_browsers
+      supported_browsers = Browser.browsers.map(&:downcase)
+      (@options[:browsers] || []).each do |browser|
+        unless supported_browsers.include?(browser.downcase)
+          raise OptionError.new(:invalid_browser, browser)
+        end
+      end
+    end
+
+  end
+
+  class OptionError < Error
+
+    def initialize(error, *args)
+      super(error_message(error) % args)
+    end
+
+  private
+
+    def error_message(error)
+      case error
+      when :missing_file
+        [ 'No directory or file provided. ' +
+          'To monitor files in the current directory:',
+          'moco .' ]
+      when :invalid_file
+        [ "No such file or directory: '%s'" ]
+      when :dir_expected
+        [ "Expected a directory, but got a filename: '%s'" ]
+      when :file_expected
+        [ "Expected a filename, but got a directory: '%s'" ]
+      when :invalid_extension
+        [ "No compiler registered for '%s' files. The supported file types are:",
+          MoCo.compilers.keys.sort.join(' ') ]
+      when :missing_option_key
+        [ 'The option key is missing. Set compiler options like this:',
+          '-o coffee:header -o haml:format::xhtml' ]
+      when :invalid_browser
+        [ "Unknown browser '%s'. The supported browsers are:",
+          Browser.browsers.join(' ') ]
+      when Exception
+        [ error.message ]
+      end.join("\n")
+    end
+
+  end
+
+end

data/lib/moco/source_map.rb

@@ -0,0 +1,22 @@
+module MoCo
+
+  module SourceMap
+
+    def self.source_map_key
+      raise NotImplementedError
+    end
+
+    attr_reader :source_map_text
+
+    def compile
+      super
+      write_file(source_map_file, source_map_text) if source_map_text
+    end
+
+    def source_map_file
+      compiled_file + '.map'
+    end
+
+  end
+
+end

data/lib/moco/support/error/error.css

@@ -0,0 +1,22 @@
+body:before {
+  content: "%s";
+  white-space: pre-wrap;
+  font-family: Menlo, Monaco, monospace;
+  font-size: 14px;
+  line-height: 1.5;
+  background: white;
+  border: 3px solid red;
+  border-radius: 5px;
+  box-shadow: 5px 5px 15px #CCC;
+  display: block;
+  position: fixed;
+  top: 0;
+  left: 0;
+  padding: 20px;
+  margin: 20px;
+  z-index: 10000;
+}
+
+body:hover:before {
+  z-index: 10001;
+}

data/lib/moco/support/error/error.html

@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Error</title>
+    <script type='text/javascript'>%s</script>
+  </head>
+</html>

data/lib/moco/support/error/error.js

@@ -0,0 +1,58 @@
+// Generated by CoffeeScript 1.6.2
+(function() {
+  var MoCo;
+
+  MoCo = {};
+
+  MoCo.errorMessage = "%s";
+
+  MoCo.css = '\
+  .moco-compile-error {\
+    white-space: pre-wrap;\
+    font-family: Menlo, Monaco, monospace;\
+    font-size: 14px;\
+    line-height: 1.5;\
+    color: black;\
+    background: white;\
+    border: 3px solid red;\
+    border-radius: 5px;\
+    box-shadow: 5px 5px 15px #CCC;\
+    display: block;\
+    position: fixed;\
+    top: 0;\
+    left: 0;\
+    padding: 20px;\
+    margin: 20px;\
+    z-index: 10000;\
+  }\
+  .moco-compile-error:hover {\
+    z-index: 10001;\
+  }\
+  .moco-compile-error span {\
+    color: red;\
+  }\
+  .moco-compile-error a, .moco-compile-error a:visited {\
+    color: black;\
+    text-decoration: none;\
+  }\
+  .moco-compile-error a:hover, .moco-compile-error a:active {\
+    color: red;\
+    text-decoration: none;\
+  }\
+';
+
+  MoCo.appendErrorElement = function() {
+    var pre, style;
+
+    style = document.createElement('style');
+    style.innerHTML = MoCo.css;
+    pre = document.createElement('pre');
+    pre.innerHTML = MoCo.errorMessage;
+    pre.className = 'moco-compile-error';
+    document.body.appendChild(style);
+    return document.body.appendChild(pre);
+  };
+
+  window.addEventListener('load', MoCo.appendErrorElement, false);
+
+}).call(this);

data/lib/moco.rb

@@ -0,0 +1,44 @@
+module MoCo
+
+  VERSION = '0.1.0'
+
+  class Error < StandardError
+  end
+
+  def self.compilers
+    CompilerRegister.instance.compilers
+  end
+
+  def self.register(compiler, extension)
+    CompilerRegister.instance.register(compiler, extension)
+  end
+
+  def self.compiler_for(file)
+    CompilerRegister.instance.compiler_for(file)
+  end
+
+  def self.args(args)
+    Options.args(args)
+  end
+
+end
+
+require 'moco/ansi_escape'
+require 'moco/application'
+require 'moco/browser_error'
+require 'moco/browser'
+require 'moco/compile_error'
+require 'moco/compiler_option'
+require 'moco/compiler_register'
+require 'moco/compiler'
+require 'moco/file_util'
+require 'moco/log'
+require 'moco/monitor'
+require 'moco/options'
+require 'moco/source_map'
+
+require 'moco/compilers/coffee_compiler'
+require 'moco/compilers/haml_compiler'
+require 'moco/compilers/less_compiler'
+require 'moco/compilers/markdown_compiler'
+require 'moco/compilers/sass_compiler'

data/moco.gemspec

@@ -0,0 +1,35 @@
+Gem::Specification.new do |spec|
+  spec.name        = 'moco'
+  spec.version     = '0.1.0'
+  spec.license     = 'MIT'
+
+  spec.author      = 'AS Harbitz'
+  spec.email       = 'asharbitz@gmail.com'
+  spec.homepage    = 'https://github.com/asharbitz/moco'
+
+  spec.summary     = 'Monitors and compiles web templates. Reloads the browser.'
+  spec.description = 'MoCo monitors web templates. On updates the templates ' +
+                     'are compiled and the browser reloaded. MoCo currently ' +
+                     'supports CoffeeScript, Sass, LESS, Markdown and Haml. ' +
+                     'Mac OS X only.'
+
+  spec.files       = Dir['LICENSE', 'moco.gemspec', 'moco.rb', 'Rakefile',
+                         'README.txt', '{lib,src}/**/*.*']
+  spec.test_files  = Dir['test/**/*.*']
+  spec.executables << 'moco'
+
+  spec.add_dependency             'rb-fsevent',           '~> 0.9'
+
+  spec.add_development_dependency 'minitest',             '~> 4.0'
+  spec.add_development_dependency 'coffee-script-source', '>= 1.6.2'
+  spec.add_development_dependency 'runjs'
+  spec.add_development_dependency 'haml'
+  spec.add_development_dependency 'less'
+  spec.add_development_dependency 'therubyracer'
+  spec.add_development_dependency 'redcarpet'
+  spec.add_development_dependency 'pygments.rb'
+  spec.add_development_dependency 'sass'
+
+  spec.required_ruby_version = '>= 1.8.7'
+  spec.requirements         << 'Mac OS X'
+end

data/moco.rb

@@ -0,0 +1,35 @@
+MoCo.args '--option coffee:header src:lib/moco/support'
+
+class AppleScriptCompiler < MoCo::Compiler
+
+  require_library 'open3'
+  register 'applescript'
+
+  def self.compiled_extension
+    'scpt'
+  end
+
+  def compile
+    cmd = ['osacompile', '-o', compiled_file, source_file]
+    message = Open3.popen3(*cmd) { |_, _, stderr| stderr.read.strip }
+    unless message.empty?
+      error = StandardError.new(message)
+      error = MoCo::CompileError.new(error, source_file)
+      write_compiled(error_text(error))
+      raise error
+    end
+  end
+
+  def error_text(error)
+    applescript = <<-EOF
+      tell application "AppleScript Runner"
+      	display alert "%s" giving up after 10
+      	return
+      end
+    EOF
+    message = "File: #{error.file}\n\nLine: #{error.line}\n\n#{error.message}"
+    message = message.gsub('\\') { '\\\\' }.gsub('"', '\"')
+    applescript % message
+  end
+
+end

data/src/error/error.coffee

@@ -0,0 +1,49 @@
+MoCo = {}
+
+MoCo.errorMessage = "%s"
+
+MoCo.css = '
+  .moco-compile-error {
+    white-space: pre-wrap;
+    font-family: Menlo, Monaco, monospace;
+    font-size: 14px;
+    line-height: 1.5;
+    color: black;
+    background: white;
+    border: 3px solid red;
+    border-radius: 5px;
+    box-shadow: 5px 5px 15px #CCC;
+    display: block;
+    position: fixed;
+    top: 0;
+    left: 0;
+    padding: 20px;
+    margin: 20px;
+    z-index: 10000;
+  }
+  .moco-compile-error:hover {
+    z-index: 10001;
+  }
+  .moco-compile-error span {
+    color: red;
+  }
+  .moco-compile-error a, .moco-compile-error a:visited {
+    color: black;
+    text-decoration: none;
+  }
+  .moco-compile-error a:hover, .moco-compile-error a:active {
+    color: red;
+    text-decoration: none;
+  }
+'
+
+MoCo.appendErrorElement = ->
+  style = document.createElement('style')
+  style.innerHTML = MoCo.css
+  pre = document.createElement('pre')
+  pre.innerHTML = MoCo.errorMessage
+  pre.className = 'moco-compile-error'
+  document.body.appendChild(style)
+  document.body.appendChild(pre)
+
+window.addEventListener('load', MoCo.appendErrorElement, false)