closure 1.1.692

data/lib/closure/compiler.rb

@@ -0,0 +1,184 @@
+# Copyright 2011 The Closure Script Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Closure
+  
+  class Compiler
+    
+    # Java won't let you change working directories and the Closure Compiler
+    # doesn't allow setting a base path.  No problem, we can do it.
+    
+    # These are filename options and will be expanded to a new base.
+    # If supplied as arguments, output options are available as instance
+    # variables and attributes that have been expanded to the new base.
+    OUTPUT_OPTIONS = %w{
+      --create_source_map
+      --js_output_file
+      --output_manifest
+      --property_map_output_file
+      --variable_map_output_file
+    }
+    
+    # These are filename options and will be expanded to a new base.
+    # These will have their modification times checked against js_output_file.
+    INPUT_OPTIONS = %w{
+      --js
+      --externs
+      --property_map_input_file
+      --variable_map_input_file
+    }
+    
+    # Instantiating will perform compilation.  It will check file modification times
+    # but does not support namespaces like {Goog#compile} does.
+    # @param (Array) args Arguments for the compiler.
+    # @param (Array) dependencies Any other files to check mtime on, like makefiles.
+    # @param (String) base All filenames will be expanded to this location.
+    # @param (Hash) env Rack environment.  Supply if you want a response that is cacheable
+    #  and for {Templates} errors to be processed.
+    # @param (Exception) exception Ruby Exception that prevents compilation.  Ruby exceptions
+    #  generated by tools like {Sources} can be displayed in console.log.  This unusual parameter
+    #  is the smallest wrinkle I could get when smoothing together compiler.jar and Ruby errors.
+    def initialize(args, dependencies = [], base = nil, env = {}, exception = nil)
+      @env = env
+      return if @exception = exception # =
+      args = Array.new args
+      files = []
+      # Scan to expand paths and extend self with output options
+      args_index = 0
+      while args_index < args.length
+        option, value = args[args_index, 2]
+        value = File.expand_path(value, base) if base
+        if INPUT_OPTIONS.include?(option)
+          files << args[args_index+1] = value
+        end
+        if OUTPUT_OPTIONS.include?(option)
+          var_name = option.sub(/^--/, '')
+          instance_variable_set "@#{var_name}", args[args_index+1] = value
+          eval "def self.#{var_name}; @#{var_name}; end"
+        end
+        args_index = args_index + 2
+      end
+      # We don't bother compiling if we can detect that no sources were modified
+      if @js_output_file
+        js_mtime = File.mtime @js_output_file rescue Errno::ENOENT
+        compiled = !!File.size?(@js_output_file) # catches empty files too
+        (files + dependencies).each do |filename|
+          break unless compiled
+          mtime = File.mtime filename
+          compiled = false if !mtime or mtime > js_mtime
+        end
+        return if compiled
+        File.unlink @js_output_file rescue Errno::ENOENT
+      end
+      # Do it; defensive .to_s.dump allows for bools and nums
+      java_opts = args.collect{|a|a.to_s.dump}.join(', ')
+      @stdout, @stderr = Closure.java("ClosureScript.compile_js(new String[]{#{java_opts}});")
+    end
+    
+    # Allows http caching of the js_output_file for scripts that want to do
+    # their own error checking.
+    # @example
+    #   <% @response = goog.compile(args).to_response %>
+    # @return (#finish) 
+    def to_response
+      if @js_output_file
+        FileResponse.new @env, @js_output_file, 'application/javascript'
+      else
+        response = Rack::Response.new
+        response.headers['Content-Type'] = 'application/javascript'
+        response.headers["Cache-Control"] = 'max-age=0, private, must-revalidate'
+        response.write @stdout
+        response
+      end
+    end
+    
+    # Checks the compilation status and will log to the javascript console.
+    # This is the best technique for compiling unless you have different
+    # needs for reporting errors.
+    # @example
+    #   <% @response = goog.compile(args).to_response_with_console %>
+    def to_response_with_console
+      response = Rack::Response.new
+      # Ruby exceptions
+      if @exception
+        response.write 'try{console.error('
+        response.write '"Closure Script: Ruby Exception\n\n", '
+        response.write @exception.to_s.dump
+        response.write ")}catch(err){};\n"
+      end
+      # Closure Template Errors
+      templates_errors_js = Templates.errors_js @env
+      response.write templates_errors_js if templates_errors_js
+      # Closure Compiler Errors
+      if stderr and !stderr.empty?
+        split_log = stderr.split("\n")
+        if split_log.last =~ /^\d+ err/i
+          error_message = split_log.pop
+        else
+          error_message = split_log.shift
+        end
+        error_log = "'Closure Compiler: %s', "
+        if split_log.empty?
+          error_log += error_message.dump
+        else
+          error_log += (error_message + "\n\n" + split_log.join("\n")).dump
+        end
+        if error_message =~ /^0 err/i
+          response.write "try{console.log(#{error_log})}catch(err){};\n"
+        else
+          response.write "try{console.error(#{error_log})}catch(err){};\n"
+        end
+      end
+      # Finally, the javascript
+      return to_response if response.empty?
+      response.write javascript
+      response.headers['Content-Type'] = 'application/javascript'
+      response.headers["Cache-Control"] = 'max-age=0, private, must-revalidate'
+      response
+    end
+
+    # Always returns the compiled javascript (possibly an empty string).
+    # @example
+    #   <%= goog.compile(args) %>
+    def javascript
+      if @js_output_file
+        File.read(@js_output_file) rescue ''
+      else
+        @stdout
+      end
+    end
+    alias :to_s :javascript
+    
+    # Results from compiler.jar.  If you didn't specify a --js_output_file
+    # then this will be the compiled script.  Otherwise, it's usually empty
+    # but may contain output depending on the arguments.
+    # If nil, compilation was skipped because js_output_file was up to date
+    # or an exception was passed on initialization.
+    attr_reader :stdout
+    
+    # Results from compiler.jar.  The log, when there is one, is found here.
+    # Use `--summary_detail_level 3` to see log when no errors or warnings.
+    # If nil, compilation was skipped because js_output_file was up to date
+    # or an exception was passed on initialization.
+    attr_reader :stderr
+
+    # Ruby exception; typically from {Sources}.  The compiler will not
+    # generate these exceptions.  This is only a mechanism to get Ruby
+    # exceptions about dependencies on to the Javascript console.log.
+    attr_reader :exception
+    
+  end
+  
+end

data/lib/closure/file_response.rb

@@ -0,0 +1,90 @@
+# Copyright 2011 The Closure Script Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Closure
+  
+  # Can be used as a Rack::Response.  Provides advanced cache control.
+  
+  class FileResponse
+    
+    def initialize(env, filename, content_type = nil)
+      @env = env
+      @filename = filename
+      @status = 200
+      @headers = {}
+      @body = []
+      
+      begin
+        raise Errno::EPERM unless File.file?(filename) and File.readable?(filename)
+      rescue SystemCallError
+        @body = ["404 Not Found\n"]
+        @headers["Content-Length"] = @body.first.size.to_s
+        @headers["Content-Type"] = "text/plain"
+        @headers["X-Cascade"] = "pass"
+        @status = 404
+        return
+      end
+      
+      # Caching strategy
+      mod_since = Time.httpdate(env['HTTP_IF_MODIFIED_SINCE']) rescue nil
+      last_modified = File.mtime(filename)
+      @status = 304 and return if last_modified == mod_since
+      @headers["Last-Modified"] = last_modified.httpdate
+      if env['QUERY_STRING'] =~ /^[0-9]{9,10}$/ and last_modified == Time.at(env['QUERY_STRING'].to_i)
+        @headers["Cache-Control"] = 'max-age=86400, public' # one day
+      else
+        @headers["Cache-Control"] = 'max-age=0, private, must-revalidate'
+      end
+      
+      # Sending the file or reading an unknown length stream to send
+      @body = self
+      unless size = File.size?(filename)
+        @body = [File.read(filename)]
+        size = @body.first.respond_to?(:bytesize) ? @body.first.bytesize : @body.first.size
+      end
+      @headers["Content-Length"] = size.to_s
+      @headers["Content-Type"] = content_type || Rack::Mime.mime_type(File.extname(filename), 'text/plain')
+    end
+    
+    # Support using self as a response body.
+    # @yield [String] 8k blocks
+    def each
+      File.open(@filename, "rb") do |file|
+        while part = file.read(8192)
+          yield part
+        end
+      end
+    end
+
+    # Filename attribute.
+    # Alias is used by some rack servers to detach from Ruby early.
+    # @return [String]
+    attr_reader :filename
+    alias :to_path :filename
+
+    # Was the file in the system and ready to be served?
+    def found?
+      @status == 200 or @status == 304
+    end
+  
+    # Present the final response for rack.
+    # @return (Array)[status, headers, body]
+    def finish
+      [@status, @headers, @body]
+    end
+  
+  end
+
+end

data/lib/closure/goog.rb

@@ -0,0 +1,143 @@
+# Copyright 2011 The Closure Script Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Closure
+  
+  # Scripts render with an instance named goog in the context.
+  
+  class Goog
+    
+    def initialize(env, sources, render_stack)
+      @sources = sources
+      @env = env
+      @render_stack = render_stack
+      @dependencies = []
+    end
+    
+    # You can add additional files to have their mtimes scanned.
+    # Perhaps you want to use a .yml file to define build options.
+    # Closure::Script calls this for every render so you don't need
+    # to define compiler arguments in the same script that calls compile.
+    def add_dependency(dependency)
+      dependency = File.expand_path dependency, @render_stack.last
+      @dependencies << dependency unless @dependencies.include? dependency
+    end
+
+    # Run a compiler job.  Accepts every argument that compiler.jar supports.
+    # Accepts new `--ns namespace` option which literally expands into
+    # `--js filename` arguments in place to satisfy the namespace.
+    # If you specify a --js_output_file then the compiler will check File.mtime
+    # on every source file plus all the closure-scripts and skip the compilation
+    # if the js_output_file is newest.
+    # Paths are relative to the script calling #compile.
+    # @example myapp.js.erb
+    #   <% @response = goog.compile(%w{
+    #     --js_output_file ../public/myapp.js
+    #     --ns myapp.HelloWorld
+    #     --compilation_level ADVANCED_OPTIMIZATIONS
+    #   }).to_response_with_console %>
+    # @param [Array<String>] args
+    # @return [Compilation]
+    def compile(args)
+      args = Array.new args
+      files = []
+      files_index = 0
+      args_index = 0
+      temp_deps_js = nil
+      exception = nil
+      begin
+        while args_index < args.length
+          option, value = args[args_index, 2]
+          if option == '--ns'
+            files_for(value, files)
+            replacement = []
+            while files_index < files.length
+              if files[files_index] =~ /\.externs$/
+                require 'tempfile'
+                temp_deps_js ||= Tempfile.new 'closure_deps_js'
+                replacement.push '--externs'
+              else
+                replacement.push '--js'
+              end
+              replacement.push files[files_index]
+              files_index = files_index + 1
+            end
+            args[args_index, 2] = replacement
+          else
+            args_index = args_index + 2
+          end
+        end
+        if temp_deps_js
+          # EXPERIMENTAL: support for goog.provide and require in externs.
+          # This is ugly but I hope it will no longer be necessary
+          # once compiler.jar is made aware of goog.provide in externs.
+          temp_deps_js.open
+          @sources.deps_response(File.dirname(base_js), @env).each do |s|
+            temp_deps_js.write s
+          end
+          temp_deps_js.close
+          # File mtime is rolled back to not trigger compilation.
+          File.utime(Time.now, Time.at(0), temp_deps_js.path)
+          args.unshift temp_deps_js.path
+          args.unshift '--js'
+        end
+        Compiler.new args, @dependencies, File.dirname(@render_stack.last), @env, exception
+      rescue Exception => e
+        exception = e
+      ensure
+        temp_deps_js.unlink if temp_deps_js
+      end
+    end
+
+    # Calculate files needed to satisfy a namespace.
+    # This will be especially useful for module generation.
+    # If you pass the filenames returned from last run,
+    # additional files (if any) will be appended to satisfy
+    # the new namespace.
+    # @example cal_file_list.erb
+    #  <%= goog.files_for %w{myapp.Calendar} %>
+    # @return (Array)
+    def files_for(namespace, filenames=nil)
+      @sources.files_for(namespace, filenames, @env)
+    end
+
+    # The Google Closure base.js script.
+    # If you use this instead of a static link, you are free to relocate relative
+    # to the Google Closure library without updating every html fixture page.
+    # Unfortunately, the better caching can't be used because of the way
+    # base.js explores the DOM looking for where to load deps.js.
+    # @example view_test.erb
+    #  <script src="<%= goog.base_js %>"></script>
+    def base_js
+      @sources.base_js(@env)
+    end
+    
+    # This is where base.js looks to find deps.js by default.  You will always
+    # be served a Closure Script generated deps.js from this location.
+    def deps_js
+      @sources.deps_js(@env)
+    end
+
+    # You can serve a deps.js from anywhere you want to drop a script.
+    # @example something.js.erb
+    #  <% @response = goog.deps_response %>
+    # @return (Rack::Response)
+    def deps_response
+      @sources.deps_response(File.dirname(Rack::Utils.unescape(@env["PATH_INFO"])), @env)
+    end
+    
+  end
+  
+end

data/lib/closure/middleware.rb

@@ -0,0 +1,43 @@
+# Copyright 2011 The Closure Script Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Closure
+
+  # Although Closure Script can run as an app or in a cascade, most installations
+  # will use this {Middleware} configured with Closure.add_source().
+  # @example config.ru
+  #  require 'closure'
+  #  Closure.add_source '../src/myapp', '/myapp'
+  #  use Closure::Middleware
+  
+  class Middleware
+    
+    # @param (String) home_page File to serve at the root.  Handy for stand-alone projects.
+    #   You can use a closure-script, even in non-source folders, by using the url extension
+    #   e.g. 'index.html' instead of the actual filename 'index.haml'.
+    def initialize(app, home_page=nil)
+      @app = app
+      @server = Server.new(Closure.sources, home_page)
+    end
+
+    def call(env)
+      status, headers, body = @server.call(env)
+      return @app.call(env) if headers["X-Cascade"] == "pass"
+      [status, headers, body]
+    end
+
+  end
+  
+end

data/lib/closure/sass.rb

@@ -0,0 +1,56 @@
+# Copyright 2011 The Closure Script Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Closure
+
+  # Closure Script can easily respond to hundreds of requests
+  # per second, but not with Sass::Plugin::Rack in the stack. 
+  # This change has been submitted to and accepted by the Sass team.
+  # Don't use Sass::Plugin::Rack until you are on a version that
+  # has the dwell option.  Use Closure::Sass in the meantime.
+  # @example config.ru
+  #  require 'closure'
+  #  require 'sass/plugin'
+  #  Sass::Plugin.options[:template_location] = {in_dir => out_dir}
+  #  use Closure::Sass, 10
+
+  class Sass
+    
+    # @param app [#call] The Rack application
+    # @param dwell [Float] in seconds.  
+    def initialize(app, dwell = 1.0)
+      @app = app
+      @dwell = dwell
+      @check_after = Time.now.to_f
+    end
+    
+    # @return (Float) 
+    # Limits how often Sass::Plugin.check_for_updates is allowed to run.
+    attr_accessor :dwell
+
+    # Rack interface.
+    # @param (Hash) env Rack environment.
+    # @return (Array)[status, headers, body]
+    def call(env)
+      if Time.now.to_f > @check_after
+        require 'sass/plugin'
+        ::Sass::Plugin.check_for_updates
+        @check_after = Time.now.to_f + @dwell
+      end
+      @app.call(env)
+    end
+    
+  end
+end

data/lib/closure/script.rb

@@ -0,0 +1,139 @@
+# Copyright 2011 The Closure Script Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Closure
+  
+  # @private
+  class ScriptNotFoundError < StandardError
+  end
+
+  # @private
+  class ScriptCallStackTooDeepError < StandardError
+  end
+  
+  # A Closure::Script instance is the context in which scripts are rendered.
+  # It inherits everything from Rack::Request and supplies a response instance
+  # you can use for redirects, cookies, and other controller actions.
+  class Script < Rack::Request
+    
+    def initialize(env, sources, filename)
+      super(env)
+      @closure_script_render_stack = []
+      @goog = Goog.new(env, sources, @closure_script_render_stack)
+      @response = original_response = Rack::Response.new
+      rendering = render(filename)
+      if @response == original_response and @response.empty?
+        @response.write rendering
+      end
+    rescue ScriptCallStackTooDeepError, ScriptNotFoundError => e
+      e.set_backtrace e.backtrace[1..-1]
+      raise e if @closure_script_render_stack.size > 1
+      @response.status = 404
+      @response.write "404 Not Found\n"
+      @response.header["X-Cascade"] = "pass"
+      @response.header["Content-Type"] = "text/plain"
+    end
+    
+    # After rendering, #finish will be sent to the client.
+    # If you replace the response or add to the response#body, 
+    # the script engine rendering will not be added.
+    # @return [Rack::Response]
+    attr_accessor :response
+
+    # All the cool stuff lives here.
+    # @return [Goog]
+    attr_accessor :goog
+
+    # Render another script.  The same Closure::Script instance is
+    # used for all internally rendered scripts so you can pass
+    # information with instance variables.
+    # @example view_test.erb
+    #   <%= render 'util/logger_popup' %>
+    # @param (String) filename Relative to current script.
+    def render(filename)
+      if @closure_script_render_stack.size > 100
+        # Since nobody sane would recurse through here, this mainly
+        # finds a render self that you might get after a copy and paste
+        raise ScriptCallStackTooDeepError 
+      elsif @closure_script_render_stack.size > 0
+        # Hooray for relative paths and easily movable files
+        filename = File.expand_path(filename, File.dirname(@closure_script_render_stack.last))
+      else
+        # Underbar scripts are partials by convention; keep them from rendering at root
+        filename = File.expand_path(filename)
+        raise ScriptNotFoundError if File.basename(filename) =~ /^_/
+      end
+      ext = File.extname(filename)
+      files1 = [filename]
+      files1 << filename + '.html' if ext == ''
+      files1 << filename.sub(/.html$/,'') if ext == '.html'
+      files1.each do |filename1|
+        Closure.config.engines.each do |ext, engine|
+          files2 = [filename1+ext]
+          files2 << filename1.gsub(/.html$/, ext) if File.extname(filename1) == '.html'
+          unless filename1 =~ /^_/ or @closure_script_render_stack.empty?
+            files2 = files2 + files2.collect {|f| "#{File.dirname(f)}/_#{File.basename(f)}"} 
+          end
+          files2.each do |filename2|
+            if File.file?(filename2) and File.readable?(filename2)
+              if @closure_script_render_stack.empty?
+                response.header["Content-Type"] = Rack::Mime.mime_type(File.extname(filename1), 'text/html')
+              end
+              @goog.add_dependency filename2
+              @closure_script_render_stack.push filename2
+              result = engine.call self, filename2
+              @closure_script_render_stack.pop
+              return result
+            end
+          end
+        end
+      end
+      raise ScriptNotFoundError
+    end
+    
+    # Helper for URL escaping.
+    # @param [String]
+    # @return [String]
+    def escape(s)
+      Rack::Utils.escape(s)
+    end
+
+    # Helper and alias for HTML escaping.
+    # @param [String]
+    # @return [String]
+    def escape_html(s)
+      Rack::Utils.escape_html(s)
+    end
+    alias :h :escape_html
+    
+    # Helper for relative filenames.
+    # @param [String]
+    # @return [String]
+    def expand_path(s)
+      File.expand_path(s, File.dirname(@closure_script_render_stack.last))
+    end
+
+    # Helper to add file mtime as query for future-expiry caching.
+    # @param [String]
+    # @return [String]
+    def expand_src(s)
+      # If the file can't be read, simply skip the cache string.
+      "#{s}?#{File.mtime(expand_path(s)).to_i}" rescue s
+    end
+    
+    
+  end
+  
+end