moco 0.1.0

data/lib/moco/compiler_option.rb

@@ -0,0 +1,60 @@
+module MoCo
+
+  module CompilerOption
+
+    def self.convert(value)
+      case value
+      when nil, 'true'
+        true
+      when 'false'
+        false
+      when INTEGER
+        value.to_i
+      when FLOAT
+        value.to_f
+      when SYMBOL
+        value.delete(':').to_sym
+      when SINGLE_QUOTED, DOUBLE_QUOTED
+        strip_quotes(value)
+      when ARRAY
+        to_array(value)
+      else
+        value
+      end
+    end
+
+  private
+
+    INTEGER = /^[+-]?\d+$/
+    FLOAT   = /^[+-]?\d*\.\d+$/
+    SYMBOL  = /^:[^:]+$/
+    ARRAY   = /:/
+    SINGLE_QUOTED = /^'[^']*'$/
+    DOUBLE_QUOTED = /^"[^"]*"$/
+
+    def self.strip_quotes(value)
+      value[1..-2]
+    end
+
+    private_class_method :strip_quotes
+
+    def self.to_array(value)
+      values = value.split(':')
+      rejoin_symbols(values)
+      values.map { |value| convert(value) }
+    end
+
+    private_class_method :to_array
+
+    def self.rejoin_symbols(values)
+      values.each_cons(2) do |v1, v2|
+        v2.insert(0, ':') if v1.empty?
+      end
+      values.delete('')
+    end
+
+    private_class_method :rejoin_symbols
+
+  end
+
+end

data/lib/moco/compiler_register.rb

@@ -0,0 +1,29 @@
+require 'singleton'
+
+module MoCo
+
+  class CompilerRegister
+
+    include Singleton
+
+    def initialize
+      @compilers = {}
+    end
+
+    def register(compiler, extension)
+      extension = FileUtil.normalized_extension(extension)
+      @compilers[extension] = compiler
+    end
+
+    def compiler_for(file)
+      extension = FileUtil.normalized_extension(file)
+      @compilers[extension]
+    end
+
+    def compilers
+      @compilers.dup
+    end
+
+  end
+
+end

data/lib/moco/compilers/coffee_compiler.rb

@@ -0,0 +1,70 @@
+require 'uri'
+
+module MoCo
+
+  class CoffeeCompiler < JsCompiler
+
+    require_library 'runjs'
+    require_library 'coffee_script/source', 'coffee-script-source', '>= 1.6.2'
+    register 'coffee'
+
+    include SourceMap
+
+    def self.source_map_key
+      :sourceMap
+    end
+
+    def self.context
+      @context ||= RunJS.context(File.read(CoffeeScript::Source.bundled_path))
+    end
+
+    def compiled_text
+      compiled_text, @source_map_text = compile_coffee(options)
+      compiled_text
+    end
+
+    def options
+      options = super
+      options[:filename] = source_file
+      source_map_options(options)
+    end
+
+  private
+
+    def context
+      self.class.context
+    end
+
+    def compile_coffee(options)
+      fn = 'CoffeeScript.compile'
+      js = context.apply(fn, 'CoffeeScript', source_text, options)
+      if options[:sourceMap]
+        source_map = js['v3SourceMap']
+        js         = js['js'] + source_map_comment
+      end
+      [js, source_map]
+    rescue RunJS::JavaScriptError => e
+      raise e, pretty_error_message(e)
+    end
+
+    def source_map_comment
+      file = URI.escape(File.basename(source_map_file))
+      "\n/*\n//@ sourceMappingURL=#{file}\n*/\n"
+    end
+
+    def pretty_error_message(error)
+      return error.message unless error['location']
+      fn = 'CoffeeScript.helpers.prettyErrorMessage'
+      context.call(fn, error.error, source_file, source_text, true)
+    end
+
+    def source_map_options(options)
+      return options unless options[:sourceMap]
+      { :generatedFile => File.basename(compiled_file),
+        :sourceFiles => [FileUtil.relative_path(source_map_file, source_file)]
+      }.merge(options)
+    end
+
+  end
+
+end

data/lib/moco/compilers/haml_compiler.rb

@@ -0,0 +1,21 @@
+module MoCo
+
+  class HamlCompiler < HtmlCompiler
+
+    require_library 'haml'
+    register 'haml'
+
+    def compiled_text
+      Haml::Engine.new(source_text, options).render
+    rescue => e
+      e.instance_eval { @line += 1 if @line }
+      raise
+    end
+
+    def options
+      super.merge(:filename => source_file)
+    end
+
+  end
+
+end

data/lib/moco/compilers/less_compiler.rb

@@ -0,0 +1,15 @@
+module MoCo
+
+  class LessCompiler < CssCompiler
+
+    require_library 'v8', 'therubyracer'
+    require_library 'less'
+    register 'less'
+
+    def compiled_text
+      Less::Parser.new(options).parse(source_text).to_css(options)
+    end
+
+  end
+
+end

data/lib/moco/compilers/markdown_compiler.rb

@@ -0,0 +1,139 @@
+module MoCo
+
+  class MarkdownCompiler < HtmlCompiler
+
+    if RUBY_VERSION < '1.9'
+      require_library 'redcarpet', 'redcarpet', '~> 2.0'
+    else
+      require_library 'redcarpet'
+    end
+
+    register 'markdown'
+    register 'md'
+
+    def self.set_option(key, value = true)
+      if key == :pygments
+        value = pygments_options(value)
+      end
+      super
+    end
+
+    def compiled_text
+      if options[:layout]
+        layout(toc, body)
+      else
+        toc + body
+      end
+    end
+
+  private
+
+    def self.pygments_options(value)
+      return unless value
+      unless Hash === value
+        key, *value = Array(value)
+        value = value.first if value.size < 2
+        value = true if value.nil?
+        value = { key => value }
+        value.delete(true)
+      end
+      options[:pygments] ? options[:pygments].merge(value) : value
+    end
+
+    private_class_method :pygments_options
+
+    def layout(toc, body)
+      layout = read_layout
+      layout = layout.gsub('{{TITLE}}', header(body) || file)
+      layout = layout.gsub('{{FILE}}', file)
+      if layout.include?('{{TOC}}')
+        layout.sub('{{TOC}}', toc.chop).sub('{{BODY}}', body)
+      else
+        layout.sub('{{BODY}}', toc + body)
+      end
+    end
+
+    def read_layout
+      File.read(options[:layout])
+    end
+
+    def header(body)
+      h1 = body[/<h1\b[^>]*>(.*?)<\/h1>/m, 1]
+      h1.gsub(/<[^>]+>/, '').gsub(/\s+/, ' ').strip if h1
+    end
+
+    def file
+      File.basename(source_file)
+    end
+
+    def toc
+      if options[:toc]
+        toc = render(Redcarpet::Render::HTML_TOC.new)
+        toc << "\n" unless toc.empty?
+      end
+      toc || ''
+    end
+
+    def body
+      if options[:pygments]
+        renderer = pygments_renderer(options[:pygments])
+      else
+        renderer = Redcarpet::Render::HTML
+      end
+      options = render_options
+      render(renderer.new(options), options)
+    end
+
+    def render(renderer, extensions = {})
+      renderer.extend(Redcarpet::Render::SmartyPants) if options[:smarty]
+      Redcarpet::Markdown.new(renderer, extensions).render(source_text)
+    end
+
+    def render_options
+      options = options().dup
+      options[:with_toc_data]      = true if options[:toc]
+      options[:fenced_code_blocks] = true if options[:pygments]
+      [:pygments, :smarty, :toc, :layout, :title].each do |key|
+        options.delete(key)
+      end
+      options
+    end
+
+    def pygments_renderer(options)
+
+      require_library('pygments', 'pygments.rb') unless defined? Pygments
+
+      Class.new(Redcarpet::Render::HTML) do
+
+        define_method(:options) do
+          options.dup
+        end
+
+        def block_code(code, language)
+          lexer = Pygments::Lexer.find(language) if language
+          if lexer
+            "\n" + lexer.highlight(code, :options => options) + "\n"
+          else
+            klass = %( class="#{escape_html(language)}") if language
+            "\n<pre><code#{klass}>#{escape_html(code)}</code></pre>\n"
+          end
+        end
+
+        def escape_html(text)
+          escaped = {
+            "'" => '&#39;',
+            '<' => '&lt;',
+            '&' => '&amp;',
+            '>' => '&gt;',
+            '"' => '&quot;'
+          }
+          text.gsub(/['<&>"]/) { |char| escaped[char] }
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/moco/compilers/sass_compiler.rb

@@ -0,0 +1,25 @@
+module MoCo
+
+  class SassCompiler < CssCompiler
+
+    require_library 'sass'
+    register 'sass'
+    register 'scss'
+
+    def compiled_text
+      Sass::Engine.new(source_text, options).render
+    rescue => e
+      e.instance_eval { alias :line :sass_line } if defined? e.sass_line
+      raise
+    end
+
+    def options
+      { :syntax     => (source_file =~ /\.sass$/) ? :sass : :scss,
+        :cache      => false,
+        :read_cache => false
+      }.merge(super)
+    end
+
+  end
+
+end

data/lib/moco/file_util.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+require 'pathname'
+
+module MoCo
+
+  class FileUtil < File
+
+    def self.normalized_extension(file)
+      file = file.to_s
+      extension = extname(file)
+      extension = basename(file) if extension.empty?
+      extension.delete('.').strip
+    end
+
+    def self.replace_extension(file, ext)
+      return file unless ext
+      file = file.chomp(extname(file))
+      unless ext.empty?
+        ext = '.' << ext unless ext.start_with?('.')
+        file << ext unless file.end_with?(ext)
+      end
+      file
+    end
+
+    def self.replace_directory(file, dir)
+      return file unless dir
+      file = basename(file)
+      file = join(dir, file) unless dir.empty?
+      file
+    end
+
+    def self.short_path(path)
+      home = File.expand_path('~')
+      path.sub(home, '~')
+    end
+
+    def self.relative_path(from_file, to_file)
+      from = Pathname.new(from_file)
+      to = Pathname.new(to_file)
+      to.relative_path_from(from.dirname).to_s
+    end
+
+    def self.up_to_date?(file, compared_to_file)
+      exist?(file) && mtime(file) >= mtime(compared_to_file)
+    end
+
+    def self.write(file, text)
+      FileUtils.makedirs(dirname(file))
+      open(file, 'w') { |f| f.write(text) }
+    end
+
+  end
+
+end

data/lib/moco/log.rb

@@ -0,0 +1,108 @@
+module MoCo
+
+  module Log
+
+    @quiet = false
+
+    def self.quiet=(quiet)
+      @quiet = quiet
+    end
+
+    def self.load(files)
+      files.each do |file|
+        log([:Loading, file, files])
+      end
+    end
+
+    def self.monitor
+      log
+      log('Press Ctrl-C to stop monitoring')
+    end
+
+    def self.compile(compiler)
+      log
+      log([:Compile, compiler.source_file, files(compiler)])
+    end
+
+    def self.update(compiler)
+      updated_files(compiler).each do |file|
+        log([:Updated, file, files(compiler)])
+      end
+    end
+
+    def self.error(e)
+      if @quiet
+        log(nil, true)
+        log([:Compile, e.file], true)
+      end
+      log(error_on_line(e), true)
+      log(error_message(e), true)
+    end
+
+  private
+
+    def self.log(status = nil, force = false)
+      return if @quiet && ! force
+      if Array === status
+        status, file, files = status
+        dir = FileUtil.short_path(File.dirname(file))
+        file = File.basename(file)
+        file = file.ljust(max_length(files)) if files
+        status = "#{status}: #{file} (#{dir})"
+      end
+      puts status || ''
+    end
+
+    private_class_method :log
+
+    def self.max_length(files)
+      files = files.map { |file| File.basename(file) }
+      files.max_by(&:length).length
+    end
+
+    private_class_method :max_length
+
+    def self.files(compiler)
+      [compiler.source_file] + compiled_files(compiler)
+    end
+
+    private_class_method :files
+
+    def self.compiled_files(compiler)
+      [compiler.compiled_file, source_map_file(compiler)].compact
+    end
+
+    private_class_method :compiled_files
+
+    def self.source_map_file(compiler)
+      klass = compiler.class
+      if klass < SourceMap && klass.options[klass.source_map_key]
+        compiler.source_map_file
+      end
+    end
+
+    private_class_method :source_map_file
+
+    def self.updated_files(compiler)
+      compiled_files(compiler).select do |file|
+        FileUtil.up_to_date?(file, compiler.source_file)
+      end
+    end
+
+    private_class_method :updated_files
+
+    def self.error_on_line(e)
+      AnsiEscape.bold_red(e.line ? "Error on line #{e.line}:" : 'Error:')
+    end
+
+    private_class_method :error_on_line
+
+    def self.error_message(e)
+      $stdout.tty? ? e.message : AnsiEscape.unescape(e.message)
+    end
+
+    private_class_method :error_message
+
+  end
+
+end

data/lib/moco/monitor.rb

@@ -0,0 +1,83 @@
+require 'rb-fsevent'
+require 'find'
+
+module MoCo
+
+  class Monitor
+
+    def initialize(files, directories, extensions)
+      @files = files
+      @pattern = pattern(directories, extensions)
+      @directories = directories + files.map { |file| File.dirname(file) }
+      @directories = delete_nested(@directories)
+    end
+
+    def files
+      set_timestamps
+      @timestamps.keys
+    end
+
+    def monitor(&callback)
+      set_timestamps
+      options = { :no_defer => true, :latency => 0.1 }
+      fsevent = FSEvent.new
+      fsevent.watch(@directories, options) do |updated_dirs|
+        on_update(updated_dirs, &callback)
+      end
+      fsevent.run
+    end
+
+  private
+
+    def pattern(dirs, exts)
+      return nil if dirs.empty? || exts.empty?
+      dirs = delete_nested(dirs.dup)
+      dirs = escape(dirs).join('|')
+      exts = escape(exts).join('|')
+      /^(#{dirs}).*\.(#{exts})$/
+    end
+
+    def escape(values)
+      values.map { |value| Regexp.escape(value.to_s) }
+    end
+
+    def delete_nested(dirs)
+      dirs.delete_if do |nested_dir|
+        dirs.any? do |dir|
+          nested_dir != dir && nested_dir.start_with?(dir)
+        end
+      end.uniq
+    end
+
+    def set_timestamps
+      @timestamps = {}
+      Find.find(*@directories) do |file|
+        store_timestamp(file) if monitor?(file)
+      end
+    end
+
+    def store_timestamp(file)
+      @timestamps[file] = File.mtime(file)
+    end
+
+    def monitor?(file)
+      @files.include?(file) || (@pattern && file =~ @pattern && File.file?(file))
+    end
+
+    def updated?(file)
+      @timestamps[file] != File.mtime(file)
+    end
+
+    def on_update(dirs, &callback)
+      dirs = delete_nested(dirs)
+      Find.find(*dirs) do |file|
+        if monitor?(file) && updated?(file)
+          store_timestamp(file)
+          yield file
+        end
+      end
+    end
+
+  end
+
+end