closure 1.2.701 → 1.3.0

data/externs/jquery.externs

@@ -0,0 +1,4 @@
+/*
+goog.provide('externs.jQuery')
+goog.require('externs.jQuery.v1_5')
+*/

data/lib/closure/beanshell.rb

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'open3'
 
 class Closure
   
@@ -37,10 +36,9 @@ class Closure
         return execute command
       rescue Errno::EPIPE
         # Shut down broken pipe; another will be started.
-        $cmdin.close
-        $cmdout.close
-        $cmderr.close
-        $cmdin = nil
+        $stderr.print "#{self.class}: restarting Java.\n"
+        $pipe.close
+        $pipe = nil
       end
       # This "second chance" will not rescue the error.
       execute command
@@ -51,29 +49,19 @@ class Closure
     # Executes a command on the REPL and returns the result.
     def execute(command)
       out = ''
-      err = ''
       @semaphore.synchronize do
-        unless $cmdin
+        unless $pipe
           classpath = [@classpath, JAR].flatten
           java_repl = "#{Closure.config.java} -classpath #{classpath.join(':').dump} bsh.Interpreter"
-          $cmdin, $cmdout, $cmderr = Open3::popen3(java_repl)
+          $pipe = IO.popen(java_repl, 'w+')
           eat_startup = ''
-          eat_startup << $cmdout.readpartial(8192) until eat_startup =~ PROMPT
+          eat_startup << $pipe.readpartial(8192) until eat_startup =~ PROMPT
         end
-        $cmdin << command
-        # An extra thread collects stderr while we watch stdout for completion.
-        running = true
-        err_reader = Thread.new { err << $cmderr.readpartial(8192) while running }
-        out << $cmdout.readpartial(8192) until out =~ PROMPT
-        running = false
-        Thread.exclusive { err_reader.terminate if err_reader.status == "sleep" }
-        err_reader.join
-        # Funny thing is, stdout sometimes finishes sending before stderr begins.
-        err << $cmderr.read_nonblock(8192) while true rescue Errno::EAGAIN
+        $pipe << command
+        out << $pipe.readpartial(8192) until out =~ PROMPT
       end
-      [out.sub(PROMPT, ''), err]
+      out.sub(PROMPT, '')
     end
-
     
   end
   

data/lib/closure/compiler.rb

@@ -17,18 +17,20 @@ class Closure
   
   class Compiler
     
+    class Error < StandardError
+    end
+    
     # 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
+      --create_source_map
       --output_manifest
       --property_map_output_file
       --variable_map_output_file
+      --module_output_path_prefix
     }
     
     # These are filename options and will be expanded to a new base.
@@ -40,132 +42,275 @@ class Closure
       --variable_map_input_file
     }
     
-    # Instantiating will perform compilation.  It will check file modification times
+    # Compile Javascript. Checks 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.
-    def initialize(args, dependencies = [], base = nil, env = {})
-      @env = env
-      return if args.empty? # otherwise java locks up
-      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
+    # @param (Hash) env Rack environment.  Supply if you want a response that is cacheable.
+    def self.compile(args, dependencies = [], env = {})
+      if Util.arg_values(args, '--js').empty?
+        return Compilation.new env, nil, 'No source javascript specified'
       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|
+      js_output_file = Util.arg_values(args, '--js_output_file').last
+      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 = Util.arg_values(args, INPUT_OPTIONS) + dependencies
+        files.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
+        if compiled
+          return Compilation.new env, js_output_file
+        end
+        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'
+      stdout, log = Closure.run_java Closure.config.compiler_jar, 'com.google.javascript.jscomp.CommandLineRunner', args
+      if log.empty?
+        log = nil
       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
-      # 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")
+        # Totals at the end make sense for the command line.  But at
+        # the start makes more sense for html and the Javascript console
+        split_log = log.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
+          log = error_message
         else
-          error_log += (error_message + "\n\n" + split_log.join("\n")).dump
+          log = error_message + "\n\n" + split_log.join("\n")
         end
-        if error_message =~ /^0 err/i
-          if error_message =~ / 0 warn/i
-            response.write "try{console.log(#{error_log})}catch(err){};\n"
-          else
-            response.write "try{console.warn(#{error_log})}catch(err){};\n"
-          end
+        raise Error, log unless error_message =~ /^0 err/i
+      end
+      Compilation.new(env, js_output_file, log) << stdout
+    end
+    
+    
+    class Compilation
+      attr_reader :log
+      attr_reader :js_output_file
+      
+      def initialize(env, js_output_file=nil, log=nil)
+        @javascript = []
+        @env = env
+        @js_output_file = js_output_file
+        @log = log
+      end
+      
+      # @private deprecated
+      def to_response_with_console
+        response = to_response
+        if response.class == Rack::Response
+          msg = "#to_response_with_console deprecated, use #to_response"
+          response.write "try{console.warn(#{msg.dump})}catch(err){};\n"
+        end
+        response
+      end
+
+      # Turn the compiled javascript into a Rack::Response object.
+      # Success and warning messages, which aren't raised like errors,
+      # will be logged to the javascript console.
+      # @example
+      #   <% @response = goog.compile(args).to_response %>
+      # @return (Rack::Response)
+      def to_response
+        if !log and @javascript.empty? and @js_output_file
+          response = FileResponse.new @env, @js_output_file, 'application/javascript'
         else
-          response.write "try{console.error(#{error_log})}catch(err){};\n"
+          response = Rack::Response.new
+          response.headers['Content-Type'] = 'application/javascript'
+          response.headers["Cache-Control"] = 'max-age=0, private, must-revalidate'
+          if log
+            consolable_log = '"Closure Compiler: %s\n\n", ' + log.rstrip.dump
+            if log.split("\n").first =~ / 0 warn/i
+              response.write "try{console.log(#{consolable_log})}catch(err){};\n"
+            else
+              response.write "try{console.warn(#{consolable_log})}catch(err){};\n"
+            end
+          end
+          response.write javascript
         end
+        response
+      end
+      
+      # Appends a string to the javascript.
+      # @param [String] javascript
+      def <<(javascript)
+        @javascript << javascript
+        self
       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
+      # Always returns the compiled javascript (possibly an empty string).
+      # @example
+      #   <%= goog.compile(args) %>
+      def javascript
+        if @js_output_file
+          file_js = File.read(@js_output_file) rescue ''
+          ([file_js] + @javascript).join nil
+        else
+          @javascript.join nil
+        end
       end
+      alias :to_s :javascript
+      
     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.
-    attr_accessor :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.
-    attr_accessor :stderr
+    # Closure Script extends compiler.jar by transforming the arguments in novel ways.
+    # The most obvious augmentation is to support --ns for compiling namespaces.
+    # We can also expand paths to a new base, work with modules, and much more.
+    # These all will directly modify args.
+    # @private This is a high value target for refactoring in minor version updates.
+    class Util
 
-  end
+      # Expands all filesystem argument values to a specified folder.
+      # @param [Array<String>] args
+      # @return [Array<String>] args
+      def self.expand_paths(args, base)
+        file_options = INPUT_OPTIONS + OUTPUT_OPTIONS
+        args_index = 0
+        while args_index < args.length
+          option, value = args[args_index, 2]
+          value = File.expand_path value, base
+          if file_options.include? option
+            args[args_index+1] = value
+          end
+          args_index = args_index + 2
+        end
+        args
+      end
   
+      # Transforms arguments to support --module name:* syntax.
+      # @param [Array<String>] args
+      # @return [Array<Hash>] mods
+      def self.module_augment(args)
+        found_starred = false
+        found_numeric = false
+        js_files = []
+        mods = []
+        args_index = args.length
+        while args_index > 0
+          args_index = args_index - 2
+          option, value = args[args_index, 2]
+          if option == '--js'
+            js_files.unshift value
+          elsif option == '--module'
+            if js_files.empty?
+              raise "No --js files for --module #{value}" 
+            end
+            mod = value.split ':'
+            if mod[1] == '*'
+              mod[1] = js_files.size 
+              found_starred = true
+            else
+              found_numeric = true
+            end
+            mods.unshift({
+              :name => mod[0],
+              :requires => mod[2..-1],
+              :files => js_files
+            })
+            js_files = []
+            args[args_index+1] = mod.join ':'
+          end
+        end
+        unless js_files.empty? or mods.empty?
+          raise 'Automatic --module must appear before first --js option.'
+        end
+        if found_starred and found_numeric
+          raise 'Static and automatic --module options can not be mixed.'
+        end
+        mods
+      end
+      
+      # The javascript snippet for module info
+      # @param [Array<Hash>] mods
+      def self.module_info(mods)
+        js = "var MODULE_INFO = {"
+        js += mods.map do |mod|
+          reqs = mod[:requires].map{ |r| r.dump }
+          s = "#{mod[:name].dump}: [#{reqs.join ', '}]"
+        end.join ', '
+        js += "};\n"
+      end
+
+
+      # The javascript snippet for raw module file locations
+      # @param [Array<Hash>] mods
+      def self.module_uris_raw(mods, sources)
+        js = "var MODULE_URIS = {\n"
+        js += mods.map do |mod|
+          files = mod[:files].map{ |r| (sources.src_for r).dump }
+          s = "#{mod[:name].dump}: [\n#{files.join ",\n"}]"
+        end.join ",\n"
+        js += "\n};\n"
+      end
+    
+    
+      # The javascript snippet for compiled module file locations
+      # @param [Array<Hash>] mods
+      def self.module_uris_compiled(mods, sources, prefix)
+        js = "var MODULE_URIS = {\n"
+        js += mods.map do |mod|
+          file = sources.src_for prefix + mod[:name] + '.js'
+          s = "#{mod[:name].dump}: [#{file.dump}]"
+        end.join ",\n"
+        js += "\n};\n"
+      end
+      
+      # Extracts the values for a options in the arguments.
+      # Use Array#last to emulate compiler.jar for single options.
+      # Will collect from an array of options.
+      # @param [Array<String>] args
+      # @param [String|Array<String>] options One or more options.
+      # @return [Array<String>]
+      def self.arg_values(args, options)
+        options = [options].flatten unless options.kind_of? Array
+        values = []
+        args_index = 0
+        while args_index < args.length
+          if options.include? args[args_index]
+            values << args[args_index+1] 
+          end
+          args_index = args_index + 2
+        end
+        values
+      end
+      
+      # Converts --ns arguments into --js arguments
+      # @param [Array<String>] args
+      # @return [Array<String>] args
+      def self.namespace_augment(args, sources, env={})
+        files = []
+        files_index = 0
+        args_index = 0
+        while args_index < args.length
+          option, value = args[args_index, 2]
+          if option == '--ns'
+            sources.files_for(value, files, env)
+            replacement = []
+            while files_index < files.length
+              if files[files_index] =~ /\.externs$/
+                # use_externs_hack = true
+                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
+        args
+      end
+      
+    end
+  end
 end

data/lib/closure/engines.rb

@@ -0,0 +1,50 @@
+# By putting the require inside the block, we allow for a generous
+# selection of engines without needing to actually install all of them.
+
+# ERB
+Closure.config.engines['.erb'] = Proc.new do |script, locals|
+  require 'erb'
+  erb = ::ERB.new(File.read(script.render_stack.last), nil, '-')
+  erb.filename = script.render_stack.last
+  script.extend ::ERB::Util
+  script_binding = script.instance_eval{binding}
+  script.send(:instance_variable_set, '@_closure_locals', locals)
+  set_locals = locals.keys.map { |k| "#{k}=@_closure_locals[#{k.inspect}];" }.join
+  eval set_locals, script_binding
+  erb.result script_binding
+end
+
+# HAML
+Closure.config.haml = {:format => :html5}
+Closure.config.engines['.haml'] = Proc.new do |script, locals|
+  require 'haml'
+  options = Closure.config.haml.merge(:filename => script.render_stack.last)
+  ::Haml::Engine.new(File.read(script.render_stack.last), options).render(script, locals)
+end
+
+# MARKDOWN
+Closure.config.kramdown = {:input => 'Markdown'}
+kramdown = Proc.new do |script, locals|
+  require 'kramdown'
+  html = ::Kramdown::Document.new(File.read(script.render_stack.last), Closure.config.kramdown).to_html
+  if script.render_stack.size == 1
+    <<-EOT
+<!DOCTYPE html>
+<html><head>
+<meta name="generator" content="kramdown #{::Kramdown::VERSION}" />
+<style type="text/css" media="screen">
+  body{font:13px/1.231 arial,helvetica,clean,sans-serif;*font-size:small;*font:x-small;}
+  select,input,button,textarea,button{font:99% arial,helvetica,clean,sans-serif;}
+  table{font-size:inherit;font:100%;}
+  pre,code,kbd,samp,tt{font-family:monospace;*font-size:108%;line-height:100%;}
+  pre{padding:5px 12px;margin-top:4px;border:1px solid #eef;background:#f5f5ff;}
+</style></head><body>
+#{html}
+</body></html>
+    EOT
+  else
+    html
+  end
+end
+Closure.config.engines['.md'] = kramdown
+Closure.config.engines['.markdown'] = kramdown