closure 1.2.701 → 1.3.0

data/lib/closure/goog.rb

@@ -18,7 +18,7 @@ class Closure
   # Scripts render with an instance named goog in the context.
   
   class Goog
-    
+
     def initialize(env, sources, render_stack)
       @sources = sources
       @env = env
@@ -31,89 +31,136 @@ class Closure
     # 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
+      dependency = File.expand_path dependency, File.dirname(@render_stack.last)
       @dependencies << dependency unless @dependencies.include? dependency
     end
+    
+    # If you change any javascript sources then you need to tell Script.
+    # This is a lazy refresh, you may call it repeatedly.
+    def refresh
+      @sources.invalidate @env
+    end
+    
+    # Convert soy templates to javascript.  Accepts all arguments that
+    # SoyToJsSrcCompiler.jar support plus it expands filename globs.
+    # All source filenames are relative to the script calling #soy_to_js.
+    # @param [Array<String>] args
+    def soy_to_js(args)
+      Templates::compile(args, File.dirname(@render_stack.last))
+      refresh
+    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.
+    # Compile javascript.  Accepts every argument that compiler.jar supports.
+    # This method supports all compiler augmentations added by Closure Script.
+    # Path options are expanded relative to the script calling #compile.
+    # - `--ns namespace` expands in place to `--js filename` arguments which satisfy the namespace.
+    # - `--module name:*:dep` File count will be filled in automatically.  The * is replaced with the
+    #   count of files up to next --module or the end.
+    # - `--js_output_file file` is compared against sources modification times to determine
+    #   if compilation is to be performed.
+    # - `--compilation_level` when not supplied, the scripts are loaded raw.
     # @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 %>
+    #   }).to_response %>
     # @param [Array<String>] args
     # @return [Compilation]
     def compile(args)
-      args = Array.new args
-      files = []
-      files_index = 0
-      args_index = 0
-      temp_deps_js = nil
-      compilation_level = nil
+      args = Array.new args # work on a copy
+      pre_js_tempfile = nil
       begin
-        while args_index < args.length
-          option, value = args[args_index, 2]
-          compilation_level = value if option == '--compilation_level'
-          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
+        Compiler::Util.expand_paths args, File.dirname(@render_stack.last)
+        orig_externs = Compiler::Util.arg_values args, '--externs'
+        Compiler::Util.namespace_augment args, @sources, @env
+        mods = Compiler::Util.module_augment args
+        if Compiler::Util.arg_values(args, '--compilation_level').empty?
+          # Raw mode
+          comp = Compiler::Compilation.new @env
+          unless mods.empty?
+            comp << Compiler::Util.module_info(mods)
+            comp << Compiler::Util.module_uris_raw(mods, @sources)
+          end
+          js_counter = 0
+          args_index = 0
+          while args_index < args.length
+            option, value = args[args_index, 2]
+            if option == '--js'
+              value = File.expand_path value, File.dirname(@render_stack.last)
+              script_tag = "<script src=#{src_for(value).dump}></script>"
+              comp << "document.write(#{script_tag.dump});\n"
+              js_counter += 1
+              # For modules, just the files for the first module
+              break if !mods.empty? and js_counter >= mods[0][:files].length
             end
-            args[args_index, 2] = replacement
-          else
             args_index = args_index + 2
           end
-        end
-        if compilation_level
-          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
+        else
+          # Compiled mode
+          module_output_path_prefix = Compiler::Util.arg_values(args, '--module_output_path_prefix').last
+          if !mods.empty? and !module_output_path_prefix
+            # raise this before compilation so we don't write to a weird place
+            raise "--module_output_path_prefix is required when using --module"
+          end
+          # If the externs were changed by namespace_augment then we need to include
+          # a temp file containing the goog.provide statements that satisfy compiler.jar.
+          if orig_externs != Compiler::Util.arg_values(args, '--externs')
+            pre_js_tempfile = Tempfile.new 'closure_pre_js'
+            # Insert before the first --js (in case of modules)
+            args_index = 0
+            while args_index < args.length
+              if args[args_index] == '--js'
+                args.insert args_index, '--js', pre_js_tempfile.path
+                break
+              end
+              args_index = args_index + 2
+            end
+            pre_js_tempfile.open
             @sources.deps_response(File.dirname(base_js), @env).each do |s|
-              temp_deps_js.write s
+              next unless s =~ /^goog\.provide/
+              pre_js_tempfile.write s
             end
-            temp_deps_js.close
+            pre_js_tempfile.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'
+            File.utime(Time.now, Time.at(0), pre_js_tempfile.path)
           end
-          Compiler.new args, @dependencies, File.dirname(@render_stack.last), @env
-        else
-          comp = Compiler.new []
-          comp.stdout = ''
-          args_index = 0
-          while args_index < args.length
-            option, value = args[args_index, 2]
-            if option == '--js'
-              script_tag = "<script src=#{path_for(value).dump}></script>"
-              comp.stdout += "document.write(#{script_tag.dump});\n"
+          comp = Compiler.compile args, @dependencies, @env
+          unless mods.empty?
+            refresh # compilation may add new files, module_uris_compiled uses src_for
+            prefix =  File.expand_path module_output_path_prefix, File.dirname(@render_stack.last)
+            if comp.js_output_file
+              File.open comp.js_output_file, 'w' do |f|
+                f.write Compiler::Util.module_info mods
+                f.write Compiler::Util.module_uris_compiled mods, @sources, prefix
+              end
+            else
+              comp << Compiler::Util.module_info(mods)
+              comp << Compiler::Util.module_uris_compiled(mods, @sources, prefix)
             end
-            args_index = args_index + 2
+            # Load the first module
+            first_module_file = module_output_path_prefix + mods[0][:name] + '.js'
+            first_module_file = File.expand_path first_module_file, File.dirname(@render_stack.last)
+            script_tag = "<script src=#{src_for(first_module_file).dump}></script>"
+            comp << "document.write(#{script_tag.dump});\n"
           end
-          comp
         end
+        comp
       ensure
-        temp_deps_js.unlink if temp_deps_js
+        if pre_js_tempfile
+          pre_js_tempfile.close
+          pre_js_tempfile.unlink 
+        end
       end
     end
+    
+    # Calculate the deps src for a filename.
+    # @param (String) filename
+    # @return (String) http path info with forward caching query.
+    def src_for(filename)
+      filename = File.expand_path filename
+      @sources.src_for(filename, @env)
+    end
 
     # Calculate files needed to satisfy a namespace.
     # This will be especially useful for module generation.
@@ -127,26 +174,22 @@ class Closure
       @sources.files_for(namespace, filenames, @env)
     end
 
-    # Calculate the file server path for a filename.
-    # @param (String) filename
-    # @return (String)
-    def path_for(filename)
-      @sources.path_for(filename, @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>
+    # @return [String]
     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.
+    # Very old Library versions may get confused by the forward caching query
+    # string; either update your base.js, install a deps_response Script where
+    # it's looking, or manually set CLOSURE_BASE_PATH.
+    # @return [String]
     def deps_js
       @sources.deps_js(@env)
     end
@@ -158,6 +201,17 @@ class Closure
     def deps_response
       @sources.deps_response(File.dirname(Rack::Utils.unescape(@env["PATH_INFO"])), @env)
     end
+
+    # Advanced Scripts may need to know where all the sources are.
+    # This has potential for a source browser, editor, and more.
+    # @example
+    #  goog.each {|directory, path| ... }
+    def each
+      @sources.each do |directory, path| 
+        yield directory, path
+      end
+    end
+    include Enumerable
     
   end
   

data/lib/closure/script.rb

@@ -12,35 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'pathname'
 
 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
+  # 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
+
+    class NotFound < StandardError
+    end
+
+    class RenderStackOverflow < StandardError
+    end
     
     ENV_ERROR_CONTENT_TYPE = 'closure.error.content_type'
     
     def initialize(env, sources, filename)
       super(env)
-      @closure_script_render_stack = []
-      @goog = Goog.new(env, sources, @closure_script_render_stack)
+      @render_stack = []
+      @goog = Goog.new(env, sources, @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
-      if @closure_script_render_stack.size > 0
+    rescue RenderStackOverflow, NotFound => e
+      if @render_stack.size > 0
         # Make errors appear from the render instead of the engine.call
         e.set_backtrace e.backtrace[1..-1]
         env[ENV_ERROR_CONTENT_TYPE] = @response.finish[1]["Content-Type"] rescue nil
@@ -65,24 +64,34 @@ class Closure
     # @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.
+    # An array of filenames representing the current render stack.
+    # @example
+    #  <%= if render_stack.size == 1
+    #        render 'html_version' 
+    #      else
+    #        render 'included_version'
+    #      end 
+    #  %>
+    # @return [<Array>]
+    attr_reader :render_stack
+
+    # Render another Script.
     # @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
+    # @param (String) filename Relative to current Script.
+    # @param (Hash) locals Local variables for the Script.
+    def render(filename, locals = {})
+      if render_stack.size > 100
+        # Since nobody sane should 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
+        raise RenderStackOverflow 
+      elsif render_stack.size > 0
         # Hooray for relative paths and easily movable files
-        filename = File.expand_path(filename, File.dirname(@closure_script_render_stack.last))
+        filename = File.expand_path(filename, File.dirname(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) =~ /^_/
+        raise NotFound if File.basename(filename) =~ /^_/
       end
       ext = File.extname(filename)
       files1 = [filename]
@@ -92,55 +101,60 @@ class Closure
         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?
+          unless filename1 =~ /^_/ or 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?
+              if render_stack.empty?
                 response.header["Content-Type"] = Rack::Mime.mime_type(File.extname(filename1), 'text/html')
               end
+              render_stack.push filename2
               @goog.add_dependency filename2
-              @closure_script_render_stack.push filename2
-              result = engine.call self, filename2
-              @closure_script_render_stack.pop
+              result = engine.call self, locals
+              render_stack.pop
               return result
             end
           end
         end
       end
-      raise ScriptNotFoundError
+      raise NotFound
     end
     
-    # Helper for URL escaping.
-    # @param [String]
-    # @return [String]
-    def escape(s)
-      Rack::Utils.escape(s)
+    # Helper for finding files relative to Scripts.
+    # @param [String] filename
+    # @return [String] absolute filesystem path
+    def expand_path(filename, dir=nil)
+      dir ||= File.dirname render_stack.last
+      File.expand_path filename, dir
     end
 
-    # Helper and alias for HTML escaping.
-    # @param [String]
-    # @return [String]
-    def escape_html(s)
-      Rack::Utils.escape_html(s)
+    # Helper to locate a file as a file server path.
+    # @param [String] filename
+    # @return [String] absolute http path
+    def expand_src(filename, dir=nil)
+      found = false
+      filename = expand_path filename, dir
+      src = nil
+      @goog.each do |dir, path|
+        dir_range = (dir.length..-1)
+        if filename.index(dir) == 0
+          src = "#{path}#{filename.slice(dir_range)}"
+          break
+        end
+      end
+      raise Errno::ENOENT unless src
+      src
     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))
+    # Helper to locate a file as a file server path.
+    # @param [String] filename
+    # @return [String] relative http path
+    def relative_src(filename, dir=nil)
+      file = expand_src filename, dir
+      base = Pathname.new File.dirname path_info
+      Pathname.new(file).relative_path_from(base).to_s
     end
-
-    # Helper to add file mtime as query for future-expiry caching.
-    # @param [String]
-    # @return [String]
-    def expand_src(s)
-      @goog.path_for(expand_path(s)) rescue s
-    end
-    
     
   end
   

data/lib/closure/server.rb

@@ -29,6 +29,7 @@ class Closure
     def initialize(sources, home_page = nil)
       @sources = sources
       @home_page = home_page
+      @working_dir = Dir.getwd
     end
     
     # Rack interface.
@@ -39,8 +40,15 @@ class Closure
       return not_found if path_info.include? '..' # unsafe
       # Stand-alone projects will find this useful
       if @home_page and path_info == '/'
+        Dir.chdir @working_dir
         response = FileResponse.new(env, @home_page)
         response = Script.new(env, @sources, @home_page).response unless response.found?
+        if response.header["X-Cascade"] == "pass"
+          if ENV["CLOSURE_SCRIPT_WELCOME"]
+            welcome = File.join Closure.base_path, 'scripts', 'welcome'
+            response = Script.new(env, @sources, welcome).response
+          end
+        end
         return response.finish
       end
       # Usurp the deps.js in detected Closure Library
@@ -48,12 +56,13 @@ class Closure
         if path_info == @sources.deps_js(env)
           return @sources.deps_response(File.dirname(path_info), env).finish
         end
-      rescue ClosureBaseNotFoundError
+      rescue Sources::BaseJsNotFoundError
       end
       # Then check all the sources
       @sources.each do |dir, path|
         next unless path
         if path_info =~ %r{^#{Regexp.escape(path)}(/.*|)$}
+          Dir.chdir @working_dir
           filename = File.join(dir, $1)
           response = FileResponse.new(env, filename)
           if !response.found? and File.extname(path_info) == ''

data/lib/closure/show_exceptions.rb

@@ -18,6 +18,10 @@ class Closure
   # This is Rack middleware to show Ruby exceptions.  It is automatically loaded when
   # using Closure::Middleware.  It works very much like Rack::ShowExceptions but will
   # use the Javascript console when it can detect the request was for javascript.
+  #
+  # If Javascript detection isn't working because you're not using .js.erb for the
+  # extension, add this as the first line of your script:
+  #     <% @response.headers['Content-Type'] = 'application/javascript' %>
   
   class ShowExceptions
     
@@ -29,12 +33,34 @@ class Closure
 
       def call(env)
         @app.call(env)
+      rescue Closure::Compiler::Error => e
+        raise e unless env[Script::ENV_ERROR_CONTENT_TYPE] == 'application/javascript'
+        body = 'try{console.error('
+        body += '"Closure Compiler: %s\n\n", '
+        body += "#{e.message.rstrip.dump}"
+        body += ')}catch(err){}'
+        body
+        [200,
+         {"Content-Type" => "application/javascript",
+          "Content-Length" => body.size.to_s},
+         [body]]
+      rescue Closure::Templates::Error => e
+        raise e unless env[Script::ENV_ERROR_CONTENT_TYPE] == 'application/javascript'
+        body = 'try{console.error('
+        body += '"Closure Templates: 1 error(s)\n\n", '
+        body += "#{e.message.rstrip.dump}"
+        body += ')}catch(err){}'
+        body
+        [200,
+         {"Content-Type" => "application/javascript",
+          "Content-Length" => body.size.to_s},
+         [body]]
       rescue StandardError, LoadError, SyntaxError => e
         raise e unless env[Script::ENV_ERROR_CONTENT_TYPE] == 'application/javascript'
         body = 'try{console.error('
-        body += '"Ruby Exception: %s\n\n", '
+        body += '"Closure Script: %s\n\n", '
         body += "#{e.class.to_s.dump}, "
-        body += "#{e.message.dump}, "
+        body += "#{e.message.rstrip.dump}, "
         body += '"\n\n", '
         body += "#{e.backtrace.join("\n").dump}"
         body += ')}catch(err){}'
@@ -44,11 +70,12 @@ class Closure
           "Content-Length" => body.size.to_s},
          [body]]
       end
+      
     end
     
     # @private - internal use only
     class Html < Rack::ShowExceptions
-      # We may implement our own someday
+      #TODO make our own someday
     end
   
     def initialize(app)

data/lib/closure/sources.rb

@@ -13,20 +13,21 @@
 # limitations under the License.
 
 require 'pathname'
+require 'thread'
 
 class Closure
   
-  # @private
-  class MultipleClosureBaseError < StandardError
-  end
-
-  # @private
-  class ClosureBaseNotFoundError < StandardError
-  end
-  
   # This class is responsible for scanning source files and managing dependencies.
 
   class Sources
+
+    # @private
+    class MultipleBaseJsError < StandardError
+    end
+
+    # @private
+    class BaseJsNotFoundError < StandardError
+    end
     
     include Enumerable
     
@@ -68,6 +69,7 @@ class Closure
     # @param (String) directory Filesystem location of your sources.
     # @return (Sources) self
     def add(directory, path=nil)
+      raise "immutable once used" if @last_been_run
       if path
         raise "path must start with /" unless path =~ %r{^/}
         path = '' if path == '/'
@@ -96,7 +98,7 @@ class Closure
       end
       @semaphore.synchronize do
         refresh(env)
-        raise ClosureBaseNotFoundError unless @goog
+        raise BaseJsNotFoundError unless @goog
         @goog[:base_js]
       end
     end
@@ -113,7 +115,7 @@ class Closure
       end
       @semaphore.synchronize do
         refresh(env)
-        raise ClosureBaseNotFoundError unless @goog
+        raise BaseJsNotFoundError unless @goog
         @goog[:deps_js]
       end
     end
@@ -143,16 +145,8 @@ class Closure
           response.headers['Cache-Control'] = "max-age=#{[1,@dwell.floor].max}, private, must-revalidate"
           response.headers['Last-Modified'] = Time.now.httpdate
         end
-        templates_errors_js = Templates.errors_js env
         mod_since = Time.httpdate(env['HTTP_IF_MODIFIED_SINCE']) rescue nil
-        if templates_errors_js
-          response = Rack::Response.new
-          response.headers['Content-Type'] = 'application/javascript'
-          response.headers['Cache-Control'] = "max-age=0, private, must-revalidate"
-          response.write @deps[base].body
-          response.write templates_errors_js
-          response
-        elsif mod_since == Time.httpdate(@deps[base].headers['Last-Modified'])
+        if mod_since == Time.httpdate(@deps[base].headers['Last-Modified'])
           Rack::Response.new [], 304 # Not Modified
         else
           @deps[base]
@@ -186,7 +180,7 @@ class Closure
         end
         ns = @ns
         if !filenames or filenames.empty?
-          raise ClosureBaseNotFoundError unless @goog
+          raise BaseJsNotFoundError unless @goog
           filenames ||= []
           filenames << @goog[:base_filename]
         end
@@ -197,11 +191,10 @@ class Closure
       calcdeps(ns, namespace, filenames)
     end
     
-
     # Calculate the file server path for a filename
     # @param (String) filename
     # @return (String)
-    def path_for(filename, env={})
+    def src_for(filename, env={})
       @semaphore.synchronize do
         refresh(env)
         f, dep = @files.find {|f, dep| f == filename}
@@ -211,14 +204,22 @@ class Closure
         "#{dep[:path]}?#{dep[:mtime].to_i}"
       end
     end
-    
+   
+    # Certain Script operations, such as building Templates, will need
+    # to invalidate the cache.
+    def invalidate(env)
+      env.delete ENV_FLAG
+      @last_been_run = Time.at 0
+    end
 
     protected
     
     # Namespace recursion with circular stop on the filename
     def calcdeps(ns, namespace, filenames, prev = nil)
       unless source = ns[namespace]
-        raise "Namespace #{namespace.dump} not found." 
+        msg = "#{prev[:filename]}: " rescue ''
+        msg += "Namespace #{namespace.dump} not found."
+        raise msg
       end
       return if source == prev or filenames.include? source[:filename]
       source[:require].each do |required|
@@ -312,7 +313,7 @@ class Closure
     # We can't trust anything if we see more than one goog
     def multiple_base_js_failure
       reset_all_computed_instance_vars
-      raise MultipleClosureBaseError
+      raise MultipleBaseJsError
     end
     
     def reset_all_computed_instance_vars