distil 0.7.0

data/lib/tasks/multiple-output-task.rb

@@ -0,0 +1,134 @@
+require "#{$script_dir}/tasks/output-task.rb"
+
+class MultipleOutputTask < OutputTask
+
+  def initialize(target, options)
+    super(target, options)
+
+    type= output_extension
+    return if (!type)
+    
+    target_name= "#{target.target_name}".downcase
+    if ('all'!=target_name)
+      @options.output_folder= File.join(output_folder, target_name)
+    end
+    
+    prefix= "#{output_folder}/"
+    
+    # if ("all"!=target_name)
+    #   prefix= "#{prefix}#{target_name}/"
+    # end
+    
+    # @options.output_folder= prefix
+    FileUtils.mkdir_p(output_folder)
+    
+    @prefix= prefix
+    @concat= Hash.new
+    @debug= Hash.new
+  end
+
+  def products
+    @products if @products
+    
+    @products= []
+    
+    type= output_extension
+    @included_files.each { |file|
+      basename= file.basename(".#{type}")
+      name_concat= "#{@prefix}#{basename}-uncompressed.#{type}"
+      name_min= "#{@prefix}#{basename}.#{type}"
+      name_gz= "#{@prefix}#{basename}.#{type}.gz"
+      name_debug= "#{@prefix}#{basename}-debug.#{type}"
+      @products.concat([name_concat, name_min, name_gz, name_debug])
+    }
+    @products
+  end
+  
+  def process_file(file)
+    concat= ""
+    debug= ""
+
+    destination= File.expand_path(remove_prefix||"")
+    
+    file.dependencies.each { |depend|
+      next if !@files_to_include.include?(depend)
+      next if @files_to_exclude.include?(depend)
+      
+      concat << depend.content_relative_to_destination(destination)
+      debug << depend.debug_content_relative_to_destination(destination)
+    }
+    
+    concat << file.content_relative_to_destination(destination)
+    debug << file.debug_content_relative_to_destination(destination)
+    
+    @concat[file]= concat
+    @debug[file]= debug
+  end
+  
+  def process_files
+    @included_files.each { |f|
+      process_file(f)
+    }
+  end
+
+  def finish_file(file)
+    type= output_extension
+    return if (!type)
+
+    basename= file.basename(".#{type}")
+    name_concat= "#{@prefix}#{basename}-uncompressed.#{type}"
+    name_min= "#{@prefix}#{basename}.#{type}"
+    name_gz= "#{@prefix}#{basename}.#{type}.gz"
+    name_debug= "#{@prefix}#{basename}-debug.#{type}"
+    
+    # puts "Finish: #{file}"
+    # puts "  #{name_concat}"
+    # puts "  #{name_min}"
+    # puts "  #{name_gz}"
+    # puts "  #{name_debug}"
+    # 
+    # Clear old files
+    [name_concat, name_min, name_gz, name_debug].each { |f|
+      next if (!File.exists?(f))
+      File.delete(f)
+    }
+
+    params= {
+      "VERSION"=>version
+    }
+    
+    concat= replace_tokens(@concat[file], params)
+    return if (""==concat)
+    
+    File.open(name_concat, "w") { |f|
+      f.write(notice_text)
+      f.write(concat)
+    }
+    
+    minified= minify(concat)
+
+    File.open(name_min, "w") { |f|
+      f.write(notice_text)
+      f.write(minified)
+    }
+    
+    Zlib::GzipWriter.open(name_gz) { |f|
+      f.write(notice_text)
+      f.write(minified)
+    }
+
+    debug= replace_tokens(@debug[file], params)
+    return if (""==debug)
+    
+    File.open(name_debug, "w") { |f|
+      f.write(notice_text)
+      f.write(debug)
+    }
+  end
+
+  def finish
+    @included_files.each { |f|
+      finish_file(f)
+    }
+  end
+end

data/lib/tasks/nib-task.rb

@@ -0,0 +1,83 @@
+require "#{$script_dir}/tasks/output-task.rb"
+require "#{$script_dir}/tasks/javascript-task.rb"
+
+class NibTask < MultipleOutputTask
+
+  def self.task_name
+    "jsnib"
+  end
+
+  def source_type
+    "js"
+  end
+  
+  def output_type
+    "jsnib"
+  end
+  
+  # NibTask handles files that end in .jsnib
+  def handles_file?(file_name)
+    "#{file_name}"[/\.jsnib$/]
+  end
+
+  def validate_file(file)
+
+    return if (!File.exists?($lint_command))
+        
+    tmp= Tempfile.new("jsl.conf")
+    
+    conf_files= [ "jsl.conf",
+                  "#{ENV['HOME']}/.jsl.conf",
+                  @options.jsl_conf
+                ]
+
+    jsl_conf= conf_files.find { |f| File.exists?(f) }
+
+    tmp << File.read(jsl_conf)
+    tmp << "\n"
+    
+    @options.external_projects.each { |project|
+      tmp << "+include #{project["include"]}\n"
+    }
+    
+    file.dependencies.each { |f|
+      tmp << "+process #{f}\n"
+    }
+    
+    tmp << "+process #{file}\n"
+    
+    tmp.close()
+    
+    command= "#{$lint_command} -nologo -nofilelisting -conf #{tmp.path}"
+    
+    stdin, stdout, stderr= Open3.popen3(command)
+    stdin.close
+    output= stdout.read
+    errors= stderr.read
+
+    tmp.delete
+    
+    output= output.split("\n")
+    summary= output.pop
+    match= summary.match(/(\d+)\s+error\(s\), (\d+)\s+warning\(s\)/)
+    if (match)
+        @target.error_count+= match[1].to_i
+        @target.warning_count+= match[2].to_i
+    end
+    
+    output= output.join("\n")
+    
+    if (!output.empty?)
+        puts output
+        puts
+    end
+      
+  end
+
+  def validate_files
+    @included_files.each { |f|
+      validate_file(f)
+    }
+  end
+  
+end

data/lib/tasks/output-task.rb

@@ -0,0 +1,73 @@
+require "#{$script_dir}/task.rb"
+require 'zlib'
+
+$compressor = "#{$vendor_dir}/yuicompressor-2.4.2.jar"
+
+class OutputTask < Task
+  option :notice
+  option :output_folder, "build"
+  option :include, FileSet
+  option :exclude, FileSet
+  
+  def initialize(target, options)
+    super(target, options)
+    @files_to_exclude= @options.exclude.to_a
+    @files_to_include= @options.include.to_a
+    FileUtils.mkdir_p(output_folder)
+  end
+
+  def output_type
+    nil
+  end
+  
+  def source_type
+    output_type
+  end
+  
+  def output_extension
+    output_type
+  end
+
+  def products
+    @products
+  end
+  
+  def minify(source)
+  	# Run the Y!UI Compressor
+  	buffer= ""
+  	
+  	IO.popen("java -jar #{$compressor} --type #{source_type}", "r+") { |pipe|
+  	  pipe.puts(source)
+  	  pipe.close_write
+  	  buffer= pipe.read
+	  }
+	  
+    # buffer = `java -jar #{$compressor} --type #{type} #{working_file}`
+  	if ('css'==output_type)
+  		# puts each rule on its own line, and deletes @import statements
+  		return buffer.gsub(/\}/,"}\n").gsub(/.*@import url\(\".*\"\);/,'')
+  	else
+  		return buffer
+  	end
+  end
+  
+  def notice_text
+    if (!@options.notice)
+      return ""
+    end
+    
+    if (nil==@notice_text)
+      notice_file= @options.notice;
+      if (!File.exists?(notice_file))
+        @notice_text= ""
+      else
+        text= File.read(notice_file).strip
+        text= "    #{text}".gsub(/\n/, "\n    ")
+        @notice_text= "/*!\n#{text}\n*/\n\n"
+      end
+    end
+  
+    return @notice_text
+  end
+  
+end

data/lib/tasks/single-output-task.rb

@@ -0,0 +1,83 @@
+require "#{$script_dir}/tasks/output-task.rb"
+
+class SingleOutputTask < OutputTask
+
+  def initialize(target, options)
+    super(target, options)
+
+    type= output_extension
+    return if (!type)
+    
+    target_name= "#{target.target_name}".downcase
+    prefix= "#{output_folder}/#{project_name}"
+    
+    if ("all"==target_name)
+      target_name= ""
+    else
+      prefix= "#{prefix}-"
+    end
+
+    @name_concat= "#{prefix}#{target_name}-uncompressed.#{type}"
+    @name_min= "#{prefix}#{target_name}.#{type}"
+    @name_gz= "#{prefix}#{target_name}.#{type}.gz"
+    @name_debug= "#{prefix}#{target_name}-debug.#{type}"
+
+    @products= [@name_concat, @name_min, @name_gz, @name_debug]
+    
+    @concat = ""
+    @debug = ""
+  end
+
+  def process_files
+    destination= File.expand_path(remove_prefix||"")
+    @included_files.each { |f|
+      @concat << f.content_relative_to_destination(destination)
+      @debug << f.debug_content_relative_to_destination(destination)
+    }
+  end
+
+  def finish
+    return if (!output_type)
+    
+    # Clear old files
+    [@name_concat, @name_min, @name_gz, @name_debug].each { |file|
+      next if (!File.exists?(file))
+      File.delete(file)
+    }
+
+    return if (""==@concat)
+
+    params= {
+      "VERSION"=>@options.version
+    }
+    
+    concat= replace_tokens(@concat, params)
+    
+    File.open(@name_concat, "w") { |f|
+      f.write(notice_text)
+      f.write(concat)
+    }
+    
+    minified= minify(concat)
+
+    File.open(@name_min, "w") { |f|
+      f.write(notice_text)
+      f.write(minified)
+    }
+    
+    Zlib::GzipWriter.open(@name_gz) { |f|
+      f.write(notice_text)
+      f.write(minified)
+    }
+
+    return if (""==@debug)
+    
+    File.open(@name_debug, "w") { |f|
+      f.write(notice_text)
+      debug= replace_tokens(@debug, params)
+      f.write(debug)
+    }
+  end
+
+end
+

data/lib/tasks/test-task.rb

@@ -0,0 +1,280 @@
+#######
+# NOT READY FOR USE
+#######
+
+
+require 'webrick'
+require "#{$script_dir}/test/browser.rb"
+
+include WEBrick
+
+$unit_test_html= File.read("#{$script_dir}/test/unittest.html")
+$script_wrapper_html= File.read("#{$script_dir}/test/scriptwrapper.html")
+
+def replace_tokens(string, params)
+	return string.gsub(/(\n[\t ]*)?@([^@ \t\r\n]*)@/) { |m|
+		key= $2
+		ws= $1
+		value= params[key]||m;
+		if (ws && ws.length)
+			ws + value.split("\n").join(ws);
+		else
+			value
+		end
+	}
+end
+
+def relative_path(file, output_folder)
+	outputFolder= File.expand_path(output_folder).to_s
+	file= File.expand_path(file).to_s
+	
+	# Remove leading slash and split into parts
+	file_parts= file.slice(1..-1).split('/');
+	output_parts= outputFolder.slice(1..-1).split('/');
+
+	common_prefix_length= 0
+
+	file_parts.each_index { |i|
+		common_prefix_length= i
+		break if file_parts[i]!=output_parts[i]
+	}
+
+	return '../'*(output_parts.length-common_prefix_length) + file_parts[common_prefix_length..-1].join('/')
+end
+
+def order_files(file, ordered_files= Array.new, probed= Set.new)
+  return if probed.include?(file)
+  return if ordered_files.include?(file)
+  probed << file
+  
+  file.dependencies.each { |d| order_files(d, ordered_files, probed) }
+  ordered_files << file
+  
+  ordered_files
+end
+  
+#  Create an HTML wrapper file for a JavaScript file. The wrapper will include
+#  one script tag for each imported file in the script. This means you don't
+#  have to write lots of silly wrapper HTML files for your tests.
+def html_wrapper_for_script_file(script_file)
+  source_file= SourceFile.from_path(script_file)
+
+  files= order_files(source_file)
+
+  current_dir= File.expand_path('.')
+
+  files.map! { |file|
+    # file= file.gsub(/-uncompressed\.js/, '-debug.js')
+    file.relative_to_folder(current_dir)
+  }
+    
+  scripts= files.map { |file|
+    "<script src=\"#{file}\" type=\"text/javascript\" charset=\"utf-8\"></script>"
+  }
+
+  replace_tokens($script_wrapper_html, {
+            "scripts" => scripts.join("\n"),
+            "title" => "#{script_file}"
+          })
+end
+
+class ScriptWrapper < HTTPServlet::AbstractServlet
+
+  def do_GET(request, response)
+    response.status = 200
+    response['Content-Type'] = 'text/html'
+    
+    file= request.query.to_s
+    response.body = html_wrapper_for_script_file(file)
+  end
+
+end  
+
+class WEBrick::HTTPServlet::AbstractServlet
+  def prevent_caching(res)
+    res['ETag'] = nil
+    res['Last-Modified'] = Time.now + 100**4
+    res['Cache-Control'] = 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0'
+    res['Pragma'] = 'no-cache'
+    res['Expires'] = Time.now - 100**4
+  end
+end
+
+class NonCachingFileHandler < WEBrick::HTTPServlet::FileHandler
+  def do_GET(req, res)
+    super
+    set_default_content_type(res, req.path)
+    prevent_caching(res)
+  end
+  
+  def set_default_content_type(res, path)
+    res['Content-Type'] = case path
+      when /\.js$/ then 'text/javascript'
+      when /\.html$/ then 'text/html'
+      when /\.css$/ then 'text/css'
+      else 'text/plain'
+    end
+  end
+end
+
+class BrowserTestServlet < HTTPServlet::AbstractServlet
+  
+  def initialize(server, browser_test)
+    super(server)
+    @browser_test= browser_test
+  end
+  
+  def generate_file(filename)
+    params= {
+      'file'=>filename
+    }
+    return replace_tokens($unit_test_html, params)
+  end
+  
+  def do_GET(request, response)
+    prevent_caching(response)
+    
+    file= request.query.to_s
+    if ("first_file"==file)
+      response.status= 302
+      response['Location']= @browser_test.next_file
+      response.body= "Forwarded..."
+      return
+    end
+    
+    response.status = 200
+    response['Content-Type'] = 'text/html'
+    response.body = $unit_test_html
+  end
+
+  def do_POST(request, response)
+    prevent_caching(response)
+    q= request.query
+    
+    failures= []
+    
+    q['failures'].split('~!~').each { |line|
+      failures << "#{line}"
+    }
+    
+    location= @browser_test.send_results({
+        'failures' => failures,
+        'passed' => q['numberOfPasses'].to_i,
+        'failed' => q['numberOfFailures'].to_i,
+        'skipped' => q['numberOfSkipped'].to_i
+      })
+    
+    response.status= 302
+    response['Location']= location
+    response.body="Redirected..."
+  end
+  
+end
+
+class TestTask < Task
+  
+  option :browsers, ['safari']
+  option :tests, FileSet
+  option :run_tests, false
+  
+  def initialize(target, options)
+    super(target, options)
+    @result_queue= Queue.new
+    @file_queue= Queue.new
+
+    @files_to_include= @options.tests.to_a
+    
+    @passed= 0
+    @failed= 0
+    @skipped= 0
+  end
+
+  def self.task_name
+    "test"
+  end
+
+  def handles_file?(file_name)
+    "#{file_name}"[/\.js$/] || "#{file_name}"[/\.html$/]
+  end
+
+  def start_webserver()
+    access_log_stream = File.open('/dev/null', 'w')
+    access_log = [[access_log_stream, AccessLog::COMBINED_LOG_FORMAT]]
+
+    # @server = HTTPServer.new(:Port=>8000)
+    #   
+    @server = HTTPServer.new(:Port=>8000, :Logger=>Log.new(nil, BasicLog::WARN),
+                 :AccessLog=>[])
+  
+    @server.mount "/wrapped", ScriptWrapper
+    @server.mount "/lib", NonCachingFileHandler, $script_dir
+    @server.mount "/", NonCachingFileHandler, "."
+  
+    trap "INT" do @server.shutdown end
+    t= Thread.new { @server.start }
+  end
+  
+  def next_file()
+    file= @file_queue.pop
+    file= relative_path(file, Dir.getwd)
+    
+    if (file[/\.js$/])
+      file= "/wrapped?#{file}"
+    end
+    return file
+  end
+  
+  def send_results(results)
+    @result_queue.push(results)
+    next_file
+  end
+  
+  def cleanup()
+    # find the files again, because tests often include output files, which may
+    # not be present in a clean build
+    find_files
+
+    return if (!@options.run_tests || 'false'===@options.run_tests || 'no'===@options.run_tests)
+    return if (0==@included_files.length)
+    
+    start_webserver
+    @server.mount "/unittest", BrowserTestServlet, self
+
+    puts "browsers=#{@options.browsers.inspect}"
+    browsers= @options.browsers.map { |b| "#{b}".downcase }
+    
+    browsers.each { |b|
+      browser= ($browsers[b]).new
+      next if !browser.supported?
+
+      browser.setup
+      browser.visit("http://localhost:8000/unittest")
+    
+      @included_files.each { |f|
+
+        @file_queue.push(f)
+        status= @result_queue.pop
+      
+        file= File.expand_path(f)
+
+        @passed= status['passed']
+        @failed= status['failed']
+        @skipped= status['skipped']
+
+        status['failures'].each { |line|
+          puts "#{file}: #{line}"
+        }
+
+      }
+    
+      # release waiting call to send_results
+      @file_queue.push('about:blank');
+
+      puts "#{b}: #{@passed} passed #{@failed} failed #{@skipped} skipped\n"
+    }
+    
+    @server.unmount "/unittest"
+    @server.shutdown
+  end
+  
+end