barista 0.6.1 → 0.7.0.pre2

data/lib/barista/compiler.rb

@@ -3,53 +3,151 @@ require 'digest/sha2'
 module Barista
   class Compiler
 
+    # TODO: Deprecate.
     class << self
-      attr_accessor :bin_path, :js_path
-    end
-    self.bin_path ||= "coffee"
-    self.js_path  ||= File.expand_path('../coffee-script/coffee-script-0.9.4.js', File.dirname(__FILE__))
 
-    def self.compilers
-      [Compilers::Native, Compilers::Node]
+      def js_path
+        CoffeeScript::Source.path
+      end
+
+      def js_path=(value)
+        CoffeeScript::Source.path = value
+      end
+      
+      def bin_path
+        CoffeeScript::Engines::Node.binary
+      end
+      
+      def bin_path=(path)
+        CoffeeScript::Engines::Node.binary = path
+      end
+      
+      def available?
+        CoffeeScript.engine.present? && CoffeeScript.engine.supported?
+      end
+
+      def check_availability!(silence = false)
+        available = available?        
+        if !available && Barista.exception_on_error? && !silence
+          raise CompilerUnavailableError, "No method of compiling cofffescript is currently available. Please install therubyracer or node."
+        end
+        available
+      end
+
+      def compile(content, options = {})
+        self.new(content, options).to_js
+      end
+
+      def autocompile_file(file, force = false, silence_error = false)
+        # Ensure we have a coffeescript compiler available.
+        if !check_availability!(silence_error)
+          Barista.debug "The coffeescript compiler at '#{Compiler.bin_path}' is currently unavailable."
+          return nil
+        end
+        # Expand the path from the framework.
+        origin_path, framework = Framework.full_path_for(file)
+        return if origin_path.nil?
+        destination_path = framework.output_path_for(file)
+        return File.read(destination_path) unless dirty?(origin_path, destination_path) || force
+        Barista.debug "Compiling #{file} from framework '#{framework.name}'"
+        compiler = new(origin_path, :silence_error => silence_error, :output_path => destination_path)
+        content = compiler.to_js
+        compiler.save
+        content
+      end
+      
+      def compile_as(file, type)
+        origin_path, framework = Framework.full_path_for(file)
+        return if origin_path.nil?
+        if type == :coffeescript
+          return File.read(origin_path), File.mtime(origin_path)
+        else
+          return autocompile_file(file), Time.now
+        end
+      end
+      
+      def dirty?(from, to)
+        File.exist?(from) && (!File.exist?(to) || File.mtime(to) < File.mtime(from))
+      end
+      
+      def setup_default_error_logger
+        Barista.on_compilation_error do |where, message|
+          if Barista.verbose?
+            Barista.debug "There was an error compiling coffeescript from #{where}:"
+            message.each_line { |line| Barista.debug line.rstrip }
+          end
+        end
+      end
+      
     end
     
-    def self.compiler=(value)
-      name = "Barista::Compilers::#{value.to_s.classify}".constantize
-      self.compiler_klass = name
-    rescue
-      self.compiler_klass = nil
+    def initialize(context, options = {})
+      @compiled = false
+      @options  = options
+      setup_compiler_context context
     end
-    
-    def self.compiler
-      compiler_klass.name.underscore.gsub("barista/compilers/", '').to_sym
+
+    def compile!
+      location          = @options.fetch(:origin, 'inline')
+      @compiled_content = compile(@context, location)
+      @compiled_content = preamble(location) + @compiled_content if Barista.add_preamble?
+      @compiled         = true
     end
-    
-    def self.compiler_klass
-      @compiler_klass ||= compilers.detect(&:available?)
+
+    def to_js
+      compile! unless defined?(@compiled) && @compiled
+      @compiled_content
     end
     
-    def self.compiler_klass=(value)
-      @compiler_klass = value.present? ? value : nil
+    def compile(script, where = 'inline')
+      Barista.invoke_hook :before_compilation, where
+      out = CoffeeScript.compile script, :bare => Barista.bare?
+      Barista.invoke_hook :compiled, where
+      out
+    rescue CoffeeScript::Error => e
+      Barista.invoke_hook :compilation_failed, where, e.message
+      if Barista.exception_on_error? && !@options[:silence]
+        raise CompilationError, "CoffeeScript encountered an error compiling #{where}: #{e.message}"
+      end
+      compilation_error_for where, e.message
     end
 
-    def self.available?
-      compiler_klass.present?
+    def save(path = @options[:output_path])
+      return false unless path.is_a?(String) && !to_js.nil?
+      FileUtils.mkdir_p File.dirname(path)
+      File.open(path, "w+") { |f| f.write @compiled_content }
+      true
+    rescue Errno::EACCES
+      false
     end
 
-    def self.check_availability!(silence = false)
-      available?.tap do |available|
-        if !available && Barista.exception_on_error? && !silence
-          raise CompilerUnavailableError, "A coffee script compiler is currently unavailable. Please install therubyracer or coffee-script via node"
-        end
-      end
-    end
+    protected
 
-    def self.compile(path, options = {})
-      compiler_klass.new(path, options).to_js
+    def preamble(location)
+      "/* DO NOT MODIFY. This file was compiled #{Time.now.httpdate} from\n * #{location.strip}\n */\n\n"
     end
-
-    def self.dirty?(from, to)
-      compiler_klass.dirty?(from, to)
+        
+    def compilation_error_for(location, message)
+      details = "Compilation of '#{location}' failed:\n#{message}"
+      Barista.verbose? ?  "alert(#{details.to_json});" : nil
     end
+    
+    def setup_compiler_context(context)
+      if context.respond_to?(:read)
+        @context = context.read
+        @type    = :string
+        default_path = context.respond_to?(:path) ? context.path : 'inline'
+        @options[:origin] ||= default_path
+      elsif !context.include?("\n") && File.exist?(context)
+        @context = File.read(context)
+        @type    = :file
+        @options[:origin] ||= context
+      else
+        @context = context.to_s
+        @type    = :string
+        @options[:origin] ||= 'inline'
+      end
+    end
+    
   end
 end

data/lib/barista/extensions.rb

@@ -0,0 +1,92 @@
+module Barista
+  module Extensions
+    
+    def self.included(parent)
+      parent.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+    
+    module ClassMethods
+      
+      def has_boolean_options(*names)
+        source = []
+        names.each do |name|
+          source << <<-EOM
+            
+            def #{name}!
+              @#{name} = true
+            end
+            
+            def #{name}?
+              defined?(@#{name}) ? @#{name} : default_for_#{name}
+            end
+            
+            def #{name}=(value)
+              @#{name} = !!value
+            end
+            
+            def default_for_#{name}
+              false
+            end
+            
+          EOM
+        end
+        class_eval source.join("\n"), __FILE__, __LINE__
+      end
+      
+      def has_hook_method(options)
+        source = []
+        options.each_pair do |name, event|
+          source << <<-EOM
+            def #{name}(&blk)
+              on_hook #{event.to_sym.inspect}, &blk
+            end
+          EOM
+        end
+        class_eval source.join("\n"), __FILE__, __LINE__
+      end
+
+      def has_delegate_methods(delegate, *args)
+        source = []
+        args.each do |method|
+          source << <<-EOM
+
+            def #{method}(*args, &blk)
+              #{delegate}.send(:#{method}, *args, &blk)
+            end
+
+          EOM
+        end
+        class_eval source.join("\n"), __FILE__, __LINE__
+      end
+      
+      def has_deprecated_methods(*args)
+        source = []
+        args.each do |method|
+          source << <<-EOM
+
+            def #{method}(*args, &blk)
+              Barista.deprecate!(self, :#{method})
+              nil
+            end
+
+          EOM
+        end
+        class_eval source.join("\n"), __FILE__, __LINE__
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      def deprecate!(object, method, other = nil)
+        klass_prefix = (object.is_a?(Class) || object.is_a?(Module)) ? "#{object.name}." : "#{object.class.name}#"
+        warn "#{klass_prefix}#{method} is deprecated and will be removed in 1.0. #{other}".strip
+      end
+      
+    end
+    
+  end
+end

data/lib/barista/filter.rb

@@ -1,10 +1,20 @@
 module Barista
   class Filter
 
-    def self.filter(controller)
-      Rails.logger.debug "[Barista] Compiling all scripts"
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      Barista.debug 'Compiling all scripts for barista'
       Barista.compile_all!
+      # Now, actually call the app.
+      @app.call env
     end
 
   end
-end
+end

data/lib/barista/framework.rb

@@ -10,9 +10,9 @@ module Barista
     end
 
     def self.all(include_default = false)
-      all = (@all ||= [])
-      all = [default_framework] + all if include_default
-      all
+      (@all ||= []).dup.tap do |all|
+        all.unshift default_framework if include_default
+      end
     end
 
     def self.exposed_coffeescripts
@@ -20,6 +20,10 @@ module Barista
         collection + fw.exposed_coffeescripts
       end.uniq.sort_by { |f| f.length }
     end
+    
+    def self.coffeescript_glob_paths
+      all(true).map { |fw| fw.coffeescript_glob_path }
+    end
 
     def self.full_path_for(script)
       script = script.to_s.gsub(/\.js$/, '.coffee').gsub(/^\/+/, '')
@@ -31,7 +35,7 @@ module Barista
     end
 
     def self.register(name, root)
-      (@all ||= []) << self.new(name, root)
+      (@all ||= []) << self.new(:name => name, :root => root)
     end
 
     def self.[](name)
@@ -41,19 +45,34 @@ module Barista
 
     attr_reader :name, :framework_root, :output_prefix
 
-    def initialize(name, root, output_prefix = nil)
-      @name           = name.to_s
-      @output_prefix  = nil
-      @framework_root = File.expand_path(root)
+    def initialize(options, root = nil, output_prefix = nil)
+      unless options.is_a?(Hash)
+        Barista.deprecate! self, "initialize(name, root = nil, output_prefix = nil)", "Please use the option syntax instead."
+        options = {
+          :name          => options,
+          :root          => root,
+          :output_prefix => output_prefix
+        }
+      end
+      # actually setup the framework.
+      check_options! options, :name, :root
+      @name           = options[:name].to_s
+      @output_prefix  = options[:output_prefix]
+      @framework_root = File.expand_path(options[:root].to_s)
+      @output_root    = options[:output_root] && Pathname(options[:output_root])
     end
 
     def coffeescripts
-      Dir[File.join(@framework_root, "**", "*.coffee")]
+      Dir[coffeescript_glob_path]
+    end
+    
+    def coffeescript_glob_path
+      @coffeescript_glob_path ||= File.join(@framework_root, "**", "*.coffee")
     end
 
     def short_name(script)
       short_name = remove_prefix script, @framework_root
-      File.join *[@output_prefix, short_name].compact
+      File.join(*[@output_prefix, short_name].compact)
     end
 
     def exposed_coffeescripts
@@ -61,8 +80,8 @@ module Barista
     end
 
     def output_prefix=(value)
-      value = value.to_s.gsub /(^\/|\/$)/, ''
-      @output_prefix = value.blank? ? nil : value
+      value = value.to_s.gsub(/(^\/|\/$)/, '').strip
+      @output_prefix = value.empty? ? nil : value
     end
 
     def full_path_for(name)
@@ -70,10 +89,26 @@ module Barista
       File.exist?(full_path) ? full_path : nil
     end
 
+    def output_root
+      @output_root || Barista.output_root
+    end
+
+    def output_path_for(file, format = 'js')
+      # Strip the leading slashes
+      file = file.to_s.gsub(/^\/+/, '')
+      output_root.join(file).to_s.gsub(/\.[^\.]+$/, ".#{format}")
+    end
+
     protected
 
     def remove_prefix(path, prefix)
-      path.to_s.gsub /^#{Regexp.escape(prefix.to_s)}\/?/, ''
+      path.to_s.gsub(/^#{Regexp.escape(prefix.to_s)}\/?/, '')
+    end
+
+    def check_options!(options, *keys)
+      keys.each do |option|
+        raise ArgumentError, "#{option.inspect} is a required options." if options[option].nil?
+      end
     end
 
   end

data/lib/barista/haml_filter.rb

@@ -0,0 +1,42 @@
+module Barista
+  module HamlFilter
+    module CoffeeScript
+      
+      def render_with_options(text, options)
+        type = render_type
+        case type
+        when :coffeescript
+          content_type  = 'text/coffeescript'
+          cdata_wrapper = '#%s'
+          inner         = text
+        when :javascript
+          content_type  = 'text/javascript'
+          cdata_wrapper = '//%s'
+          inner         = Barista::Compiler.compile(text)
+        end
+        output = []
+        output << "<script type=#{options[:attr_wrapper]}#{content_type(type)}#{options[:attr_wrapper]}>"
+        output << "  #{cdata_wrapper % '<![CDATA['}"
+        output << "  #{inner}".rstrip.gsub("\n", "\n  ")
+        output << "  #{cdata_wrapper % ']]>'}"
+        output << "</script>"
+        output.join("\n")
+      end
+     
+      def render_type
+        Barista.embedded_interpreter? ? :coffeescript : :javascript
+      end
+      
+      def content_type(render_type)
+        Barista::Server::CONTENT_TYPE_MAPPING[render_type]
+      end
+        
+    end
+    
+    def self.setup
+      if defined?(Haml)
+        CoffeeScript.module_eval { include Haml::Filters::Base }
+      end
+    end
+  end
+end