distil 0.7.0

data/lib/source-file.rb

@@ -0,0 +1,181 @@
+require 'fileutils'
+
+$compressor = "#{$script_dir}/yuicompressor-2.4.2.jar"
+
+class SourceFile
+  attr_accessor :parent_folder, :full_path
+
+  def initialize(filepath)
+    @full_path= File.expand_path(filepath)
+
+    @parent_folder= File.dirname(@full_path)
+    @dependencies= Array.new
+    @assets= Array.new
+    
+    @@file_cache[@full_path]= self
+  end
+
+  @@root_folder= FileUtils.pwd
+  def self.root_folder
+    @@root_folder
+  end
+  
+  def self.root_folder=(new_root_folder)
+    @@root_folder= File.expand_path(new_root_folder)
+  end
+  
+  def self.extension
+  end
+  
+  def extension
+    self.class.extension
+  end
+  
+  def can_embed_as_content
+    false
+  end
+  
+  def minify_content_type
+  end
+  
+  @@file_types= []
+  def self.inherited(subclass)
+    @@file_types << subclass
+  end
+
+  @@file_cache= Hash.new
+  def self.from_path(filepath)
+    full_path= File.expand_path(filepath)
+    file= @@file_cache[full_path]
+    return file if file
+    
+    extension= File.extname(filepath)
+    
+    @@file_types.each { |handler|
+      next if (handler.extension != extension)
+
+      return handler.new(filepath)
+    }
+    
+    return SourceFile.new(filepath)
+  end
+
+  def to_s
+    @full_path
+  end
+  
+  def to_str
+    @full_path
+  end
+
+  def error(message, line_number=0)
+    Target.current.error(message, self, line_number)
+  end
+
+  def warning(message, line_number=0)
+    Target.current.warning(message, self, line_number)
+  end
+
+  def basename(suffix="")
+    File.basename(@full_path, suffix)
+  end
+  
+  def file_path
+    @file_path || self.relative_to_folder(@@root_folder)
+  end
+
+  def file_path=(path)
+    @file_path=path
+  end
+  
+  def has_file_path
+    @file_path
+  end
+  
+  def content
+    @content ||= File.read(@full_path)
+  end
+
+  def content_relative_to_destination(destination)
+    content.gsub(/\{\{FILEREF\(([^)]*)\)\}\}/) { |match|
+      file= SourceFile.from_path($1)
+      file.relative_to_folder(destination)
+    }
+  end
+
+  def debug_content_relative_to_destination(destination)
+    self.content_relative_to_destination(destination)
+  end
+  
+  def minify_content(source)
+  	# Run the Y!UI Compressor
+    return source if !minify_content_type
+  	buffer= ""
+    
+  	IO.popen("java -jar #{$compressor} --type #{minify_content_type}", "r+") { |pipe|
+  	  pipe.puts(source)
+  	  pipe.close_write
+  	  buffer= pipe.read
+	  }
+	  
+    # buffer = `java -jar #{$compressor} --type #{type} #{working_file}`
+  	if ('css'==minify_content_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 self.path_relative_to_folder(path, folder)
+    outputFolder= File.expand_path(folder).to_s
+  
+    # Remove leading slash and split into parts
+    file_parts= path.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 relative_to_folder(output_folder)
+    self.class.path_relative_to_folder(@full_path, output_folder)
+  end
+
+  def relative_to_file(source_file)
+    folder= File.dirname(File.expand_path(source_file))
+    self.relative_to_folder(folder)
+  end
+  
+  def dependencies
+    # make certain the content is loaded
+    self.content
+    @dependencies
+  end
+
+  def assets
+    # make certain the content is loaded
+    self.content
+    @assets
+  end
+  
+  def copy_to(folder)
+    file_path= self.file_path
+    final_target_folder= File.join(folder, File.dirname(file_path))
+    FileUtils.mkdir_p final_target_folder
+    FileUtils.cp self.full_path, final_target_folder
+    File.join(final_target_folder, File.basename(file_path))
+  end
+  
+end
+
+# load all the other file types
+Dir.glob("#{$script_dir}/file-types/*-file.rb") { |file|
+  require file
+}

data/lib/target.rb

@@ -0,0 +1,96 @@
+require "#{$script_dir}/task"
+require "set"
+
+class Target < Configurable
+  attr_accessor :target_name, :warning_count, :error_count
+
+  option :tasks, Array
+  
+  def initialize(name, settings, project)
+    super(settings, project)
+    
+    @project= project
+    @target_name= name
+    @@current= self
+    
+    @tasks= []
+
+    @extras.each { |task_name, task_settings|
+      next if (tasks && !tasks.include?(task_name))
+      t= Task.by_name(task_name)
+      @tasks << t.new(self, task_settings)
+    }
+
+    @warning_count=0
+    @error_count=0
+  end
+
+  def self.current
+    @@current
+  end
+
+  def error(message, file="", line_number=0)
+    @error_count+=1
+    if (file && line_number)
+      printf("%s:%d: error: %s\n", file, line_number, message)
+    else
+      printf("error: %s\n", message)
+    end
+  end
+  
+  def warning(message, file="", line_number=0)
+    @warning_count+=1
+    return if (ignore_warnings)
+    if (file && line_number)
+      printf("%s:%d: warning: %s\n", file, line_number, message)
+    else
+      printf("warning: %s\n", message)
+    end
+  end
+  
+  def products
+    products= []
+    @tasks.each { |task|
+      products.concat(task.products)
+    }
+    products
+  end
+  
+  def find_file(file)
+    external_projects.each { |project|
+      path= File.expand_path(File.join(project["include"], file))
+      if (File.exists?(path))
+        source_file= SourceFile.from_path(path)
+        source_file.file_path= file
+        return source_file
+      end
+    }
+    nil
+  end
+
+  def process_files
+    @tasks.each { |t|
+      t.find_files
+
+      next if !t.need_to_build
+
+      t.validate_files
+      t.document_files
+      t.process_files
+    }
+  end
+
+  def finish
+    @tasks.each { |t|
+      t.finish if t.need_to_build
+      t.build_assets
+    }
+
+    @tasks.each { |t|
+      t.cleanup
+    }
+    
+    puts "#{@error_count} error(s), #{@warning_count} warning(s)#{ignore_warnings ? " ignored" : ""}"
+  end
+  
+end

data/lib/task.rb

@@ -0,0 +1,239 @@
+require "#{$script_dir}/source-file"
+require "#{$script_dir}/file-set"
+require 'set'
+require "#{$script_dir}/configurable"
+
+class Task < Configurable
+  attr_reader :included_files, :assets
+
+  option :remove_prefix
+
+  def initialize(target, settings)
+    if (settings.is_a?(Array) || settings.is_a?(String))
+      settings= { "include"=>settings }
+    end
+    super(settings, target)
+    
+    @target= target
+    @included_files= []
+    
+    @files_to_include= []
+    @files_to_exclude= []
+    @assets= Set.new
+    @probed= Set.new
+    
+    if (remove_prefix)
+      SourceFile.root_folder= remove_prefix
+    end
+  end
+
+  @@tasks= []
+  def self.inherited(subclass)
+    @@tasks << subclass
+  end
+  
+  def self.available_tasks
+    @@tasks
+  end
+
+  @@task_index= nil
+  def self.task_index
+    return @@task_index if @@task_index
+    @@task_index= Hash.new
+    @@tasks.each { |t|
+      next if !t.task_name
+      @@task_index[t.task_name]= t
+    }
+    @@task_index
+  end
+  
+  def self.by_name(taskname)
+    self.task_index[taskname]
+  end
+  
+  def self.task_name
+    nil
+  end
+  
+  def task_name
+    self.class.task_name
+  end
+    
+  def handles_file?(file)
+    false
+  end
+
+  #  Do a simple token substitution. Tokens begin and end with @.
+  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 include_file(file)
+    return if @probed.include?(file)
+    return if @included_files.include?(file)
+    return if !handles_file?(file)
+    return if !@files_to_include.include?(file)
+    return if @files_to_exclude.include?(file)
+
+    @probed << file
+    
+    file.dependencies.each { |d| include_file(d) }
+    @assets.merge(file.assets)
+    @assets << file
+    @included_files << file
+  end
+
+  def find_files
+    @probed= Set.new
+    @included_files= []
+    @files_to_include.each { |i| include_file(i) }
+  end
+  
+  def products
+    []
+  end
+  
+  def need_to_build
+    return @need_to_build if !@need_to_build.nil?
+    
+    product_modification_times= products.map { |p|
+      p=File.expand_path(p)
+      return (@need_to_build=true) if !File.exists?(p)
+      File.stat(p).mtime
+    }
+    oldest_product_modification_time= product_modification_times.max
+    
+    @assets.each { |a|
+      stat= File.stat(a)
+      return (@need_to_build=true) if stat.mtime > oldest_product_modification_time
+    }
+    
+    return (@need_to_build=false)
+  end
+  
+  def validate_files
+  end
+  
+  def document_files
+  end
+  
+  def process_files
+  end
+  
+  def finish
+  end
+  
+  def symlink_assets
+    full_root_path= File.expand_path(remove_prefix||"")
+    
+    folders= []
+
+    assets.each { |a|
+      path= a.has_file_path ? a.file_path : a.relative_to_folder(full_root_path)
+
+      parts= File.dirname(path).split(File::SEPARATOR)
+      if ('.'==parts[0])
+        target_path= File.join(output_folder, path)
+        FileUtils.rm target_path if File.exists? target_path
+        File.symlink a.full_path, target_path
+        next
+      end
+
+      for i in (0..parts.length-1)
+        f= parts[0..i].join(File::SEPARATOR)
+        if !folders.include?(f)
+          folders << f
+        end
+      end
+      
+    }
+    
+    folders.sort!
+    folders.each { |f|
+      # puts "#{File.join(remove_prefix, f)} => #{File.join(output_folder, f)}"
+      src_folder= remove_prefix ? File.join(remove_prefix, f) : f
+      target_folder= File.expand_path(File.join(output_folder, f))
+      next if File.exists?(target_folder)
+      File.symlink File.expand_path(src_folder), target_folder
+    }
+    
+    # puts "#{task_name}: folder=#{folders.inspect}"
+  end
+  
+  def copy_assets
+    assets.each { |a|
+      a.copy_to(output_folder)
+    }
+  end
+  
+  def build_assets
+    if ("release"==mode)
+      copy_assets
+    else
+      symlink_assets
+    end
+  end
+  
+  def copy_assets_orig
+    # puts "\nincluded:"
+    # @included_files.each { |f| puts f.file_path }
+    # 
+    # puts "\nordered:"
+    # @ordered_files.each { |f| puts f.file_path }
+    # puts "\nassets:"
+    # assets.each { |a| puts a.file_path }
+    
+    folders= assets.map { |a|
+      short_folder_name= File.dirname(a.file_path).split("/")[0]
+      if ("."==short_folder_name)
+        [a.file_path, a.relative_to_folder(output_folder)]
+      else      
+        short_folder_regex= /.*\/#{Regexp.escape(short_folder_name)}\//
+        # puts "#{a.file_path}: #{short_folder_regex.inspect}: #{a.relative_to_folder(@options.output_folder)}"
+        relative_folder_name= (a.relative_to_folder(output_folder))[short_folder_regex]
+        [short_folder_name, relative_folder_name]
+      end
+    }
+    folders.compact!
+    folders.uniq!
+    
+    # puts "\nfolders:"
+    # folders.each { |f| puts f.inspect }
+    
+    folders.each { |f|
+      target_folder= "#{output_folder}/#{f[0]}"
+      FileUtils.rm target_folder if File.symlink?(target_folder)
+      # FileUtils.rm_r target_folder if File.exists?(target_folder)
+    }
+    
+    if ("release"==mode)
+      assets.each { |a| a.copy_to(output_folder) }
+    else
+      folders.each { |f|
+        # puts "#{f[0]}"
+        target_folder= "#{output_folder}/#{f[0]}"
+        source_folder= f[1]
+        File.symlink source_folder, target_folder
+      }
+    end
+  end
+  
+  def cleanup
+  end
+  
+end
+
+
+# load all the other task types
+Dir.glob("#{$script_dir}/tasks/*-task.rb") { |file|
+  require file
+}

data/lib/tasks/copy-task.rb

@@ -0,0 +1,21 @@
+class CopyTask < Task
+  
+  def self.task_name
+    "copy"
+  end
+  
+  def initialize(target, options)
+    super(target, options)
+    @files_to_exclude= @options.exclude.to_a
+    @files_to_include= @options.include.to_a
+  end    
+
+  def need_to_build
+    true
+  end
+  
+  def handles_file?(file_name)
+    true
+  end
+
+end

data/lib/tasks/css-task.rb

@@ -0,0 +1,18 @@
+require "#{$script_dir}/tasks/single-output-task.rb"
+
+class CssTask < SingleOutputTask
+  
+  def self.task_name
+    "css"
+  end
+  
+  def output_type
+    "css"
+  end
+  
+  # CssTask handles files that end in .css
+  def handles_file?(file_name)
+    "#{file_name}"[/\.css$/]
+  end
+
+end

data/lib/tasks/javascript-task.rb

@@ -0,0 +1,125 @@
+require "open3"
+require "tempfile.rb"
+require "#{$script_dir}/tasks/single-output-task.rb"
+
+$lint_command= "#{$vendor_dir}/jsl-0.3.0/bin/jsl"
+$jsdoc_command= "#{$vendor_dir}/jsdoc-toolkit/jsrun.sh"
+
+class JavascriptTask < SingleOutputTask
+
+  option :bootstrap_file, "#{$script_dir}/bootstrap-template.js"
+  option :jsl_conf, "#{$script_dir}/jsl.conf"
+  option :jsdoc_conf, "#{$script_dir}/jsdoc.conf"
+  option :jsdoc_template, "#{$vendor_dir}/jsdoc-extras/templates/coherent"
+  option :jsdoc_plugins, "#{$vendor_dir}/jsdoc-extras/plugins"
+  option :doc_folder, "doc"
+  option :generate_docs, false
+  
+  def self.task_name
+    "js"
+  end
+  
+  def output_type
+    "js"
+  end
+  
+  # JsTask handles files that end in .js
+  def handles_file?(file_name)
+    "#{file_name}"[/\.js$/]
+  end
+
+  def validate_files
+
+    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"
+    }
+    
+    @included_files.each { |f|
+      tmp << "+process #{f}\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 document_files()
+      
+    return if (!@options.generate_docs)
+    return if (!File.exists?($jsdoc_command))
+    
+    tmp= Tempfile.new("jsdoc.conf")
+    
+    template= File.read(@options.jsdoc_conf)
+    doc_files= @included_files.map { |f| "\"#{f.file_path}\"" }
+    
+    conf= replace_tokens(template, {
+                    "DOC_FILES"=>doc_files.join(",\n"),
+                    "DOC_OUTPUT_DIR"=>@options.doc_folder,
+                    "DOC_TEMPLATE_DIR"=>@options.jsdoc_template,
+                    "DOC_PLUGINS_DIR"=>@options.jsdoc_plugins
+                })
+
+    tmp << conf
+    tmp.close()
+    
+    command= "#{$jsdoc_command} -c=#{tmp.path}"
+    
+    stdin, stdout, stderr= Open3.popen3(command)
+    stdin.close
+    output= stdout.read
+    errors= stderr.read
+
+    tmp.delete
+    
+    puts errors
+    puts output
+      
+  end
+
+  def process_files
+    super
+    template= File.read(@options.bootstrap_file)
+    @debug= replace_tokens(template, {
+              "LOAD_SCRIPTS" => @debug
+            })
+  end
+  
+end