distil 0.10.4 → 0.11.0

data/lib/distil/product.rb

@@ -0,0 +1,97 @@
+module Distil
+  
+  class Product < Configurable
+    option :concatenated_name, OutputPath, "$(name)-uncompressed.$(extension)", :aliases=>['concatenated']
+    option :debug_name, OutputPath, "$(name)-debug.$(extension)", :aliases=>['debug']
+    option :minified_name, OutputPath, "$(name).$(extension)", :aliases=>['minified']
+    option :compressed_name, OutputPath, "$(name).$(extension).gz", :aliases=>['compressed']
+
+    option :force, false
+    
+    attr_accessor :assets, :target, :join_string
+    class_attr :extension
+    
+    def initialize(settings, target)
+      @target= target
+      @files= []
+      @assets= Set.new
+      super(settings, target)
+    end
+
+    def can_embed_file?(file)
+      false
+    end
+    
+    def handles_file?(file)
+      [extension].include?(file.extension)
+    end
+    
+    def files
+      @files
+    end
+    
+    def files=(fileset)
+      fileset.each { |f|
+        next if !handles_file?(f)
+        @files << f
+        @assets.merge(f.assets)
+      }
+    end
+    
+    def up_to_date
+      return @up_to_date if !@up_to_date.nil?
+      return false if force
+      
+      return @up_to_date=false if !File.exists?(filename)
+      
+      output_modified= File.stat(filename).mtime
+      max_asset_modified= File.stat(target.project.project_file).mtime
+
+      assets.each { |f|
+        max_asset_modified= f.last_modified if f.last_modified > max_asset_modified
+      }
+
+      return @up_to_date=false if (output_modified < max_asset_modified)
+      
+      external_files.each { |f|
+        next if !File.exist?(f)
+        last_modified= File.stat(f).mtime
+        max_asset_modified= last_modified if last_modified > max_asset_modified
+      }
+
+      return @up_to_date=false if (output_modified < max_asset_modified)
+
+      @up_to_date= true
+    end
+
+    def filename
+      raise NotImplementedError.new("This product does not implement the filename method.")
+    end
+    
+    def write_output
+      raise NotImplementedError.new("No write_output method has been defined for this product.")
+    end
+    
+    def relative_path(file)
+      file=SourceFile.from_path(file) if file.is_a?(String)
+      
+      file_path= file.full_path
+      output_folder= target.project.output_folder
+      source_folder= target.project.source_folder
+      
+      path=file.relative_to_folder(source_folder) if 0==file_path.index(source_folder)
+      path=file.relative_to_folder(output_folder) if 0==file_path.index(output_folder)
+      path
+    end
+
+  end
+  
+end
+
+require 'distil/product/concatenated'
+require 'distil/product/debug'
+require 'distil/product/minified'
+require 'distil/product/css-product'
+require 'distil/product/javascript-base-product'
+require 'distil/product/javascript-product'
+require 'distil/product/javascript-doc-product'

data/lib/distil/project/distil-project.rb

@@ -0,0 +1,99 @@
+module Distil
+  
+  class DistilProject < Project
+    
+    attr_reader :project_file
+
+    option :ignore_warnings, false
+
+    option :external_projects, [], :aliases=>['external']
+    option :distileries, Array, :aliases=>['distilleries', 'distilery', 'distillery']
+  
+  
+    def initialize(project_file, settings={}, parent=nil)
+      @project_file= File.expand_path(project_file)
+      @projects_by_name={}
+
+      project_info= YAML.load_file(@project_file)
+      project_info.merge!(settings)
+      project_info["path"]= File.dirname(@project_file)
+      
+      begin
+        super(project_info, parent)
+      rescue ValidationError
+        $stderr.print "#{APP_NAME}: #{project_file}: #{$!}\n"
+        exit 1
+      end
+
+      load_external_projects
+    end
+
+    def targets
+      @targets if @targets
+      
+      @targets= []
+      target_list= @extras['targets']
+      
+      if !target_list
+        @targets << Target.new(@extras.clone, self)
+        return @targets
+      end
+
+      @targets= target_list.map { |target|
+        Target.new(target, self)
+      }
+    end
+
+    def load_external_projects
+      return if !external_projects
+
+      self.external_projects= external_projects.map { |config|
+        project= Project.from_config(config, self)
+        next if !project
+        @projects_by_name[project.name]= project
+      }
+    end
+
+    def external_project_with_name(name)
+      @projects_by_name[name]
+    end
+    
+    def build
+      FileUtils.mkdir_p(output_folder)
+      load_distileries
+      build_external_projects
+      build_targets
+    end
+
+    def load_distileries
+      return if distileries.nil?
+    
+      distileries.each { |d|
+        if (File.exists?(d))
+          require d
+          next
+        end
+        path= Gem.required_location(d, 'distilery.rb')
+        if (path.nil?)
+          puts "Missing distilery: #{d}"
+        end
+        next if path.nil?
+        require path
+      }
+    end
+  
+    def build_external_projects
+      external_projects.each { |project|
+        project.build
+      }
+    end
+
+    def build_targets
+      targets.each { |target|
+        target.build
+      }
+      report
+    end
+  end
+  
+end  

data/lib/distil/project/external-project.rb

@@ -0,0 +1,53 @@
+module Distil
+  
+  class ExternalProject < Project
+
+    option :name, String
+    option :repository
+    option :build_command, String, :aliases=>['build']
+    option :linkage, WEAK_LINKAGE, :valid_values=> [WEAK_LINKAGE, STRONG_LINKAGE, LAZY_LINKAGE]
+
+    option :import_name, OutputPath, "$(name)-debug.$(extension)", :aliases=>['import']
+    option :concatenated_name, OutputPath, "$(name)-uncompressed.$(extension)", :aliases=>['concatenated']
+    option :debug_name, OutputPath, "$(name)-debug.$(extension)", :aliases=>['debug']
+    option :minified_name, OutputPath, "$(name).$(extension)", :aliases=>['minified']
+    option :compressed_name, OutputPath, "$(name).$(extension).gz", :aliases=>['compressed']
+    
+    def initialize(config, parent=nil)
+      if !config.has_key?("source_folder")
+        config["source_folder"]= "build/$(mode)"
+      end
+      super(config, parent)
+      
+      @options.output_folder= File.join(parent.output_folder, name)
+    end
+
+    def product_name(product_type, extension)
+      info= Struct.new(:extension).new(extension)
+      name= self.send("#{product_type.to_s}_name")
+      Interpolated.value_of(name, info)
+    end
+    
+    def build
+      wd= Dir.getwd
+      Dir.chdir(path)
+      system build_command
+      Dir.chdir(wd)
+      
+      # external projects aren't included in the output when weak linked,
+      # they are just expected to be there, somehow. Like magic.
+      return if WEAK_LINKAGE==linkage
+          
+      FileUtils.rm_r(output_folder) if File.directory?(output_folder)
+      FileUtils.unlink(output_folder) if File.symlink?(output_folder)
+      
+      if DEBUG_MODE==mode
+        FileUtils.symlink(File.expand_path(source_folder), output_folder)
+      else
+        FileUtils.cp_r(File.expand_path(source_folder), output_folder)
+      end
+    end
+    
+  end
+  
+end

data/lib/distil/project.rb

@@ -0,0 +1,78 @@
+module Distil
+  
+  class Project < Configurable
+
+    include ErrorReporter
+
+    option :output_folder, ProjectPath, "build/$(mode)", :aliases=>['output']
+    option :source_folder, ProjectPath, ""
+    
+    option :path, String
+    option :mode, DEBUG_MODE, :valid_values=>[DEBUG_MODE, RELEASE_MODE]
+    option :force
+    
+    def build
+    end
+    
+    def self.from_config(config, parent=nil)
+
+      if config.is_a?(String)
+        string= config
+        config= { "name" => File.basename(config, ".*") }
+        full_path= File.expand_path(string)
+        if File.exist?(full_path) && File.file?(full_path)
+          config["path"]= File.dirname(full_path)
+        else
+          config["path"]= full_path
+        end
+      end
+      
+      config["mode"]||= parent.mode if parent
+        
+      path= config["path"]
+      if !path
+        ErrorReporter.error "No path for project: #{config["name"]}"
+        return nil
+      end
+      
+      if !File.directory?(path)
+        ErrorReporter.error "Path is not valid for project: #{config["name"]}"
+        return nil
+      end
+      
+      basename= File.basename(path)
+      
+      case
+      when exist?(path, "#{basename}.jsproj")
+        project_file= File.join(path, "#{basename}.jsproj")
+        project_info= YAML.load_file(project_file)
+        project_info.merge!(config)
+        project_info["path"]= path
+        project= ExternalProject.new(project_info, parent)
+        if parent
+          project.build_command ||= "distil --mode=#{parent.mode} --force=#{parent.force}"
+        else
+          project.build_command ||= "distil"
+        end
+      when exist?(path, "Makefile") || exist?(path, "makefile")
+        project= ExternalProject.new(config, parent)
+        project.build_command ||= "make"
+      when exist?(path, "Rakefile") || exist?(path, "rakefile")
+        project= ExternalProject.new(config, parent)
+        project.build_command ||= "rake"
+      when exist?(path, "Jakefile") || exist?(path, "jakefile")
+        project= ExternalProject.new(config, parent)
+        project.build_command ||= "jake"
+      else
+        ErrorReporter.error "Could not determine type for project: #{config["name"]}"
+      end
+      return project
+      
+    end
+    
+  end
+  
+end
+
+require 'distil/project/external-project'
+require 'distil/project/distil-project'

data/lib/distil/source-file/css-file.rb

@@ -0,0 +1,14 @@
+module Distil
+
+  class CssFile < SourceFile
+
+    extension "css"
+    content_type "css"
+
+    def minified_content(source)
+      super(source).gsub(/\}/,"}\n").gsub(/.*@import url\(\".*\"\);/,'')
+    end
+
+  end
+
+end

data/lib/distil/source-file/html-file.rb

@@ -0,0 +1,14 @@
+module Distil
+
+  class HtmlFile < SourceFile
+
+    extension "html"
+    content_type "html"
+
+    def minified_content(source)
+      source.gsub(/>\s+</, "><")
+    end
+  
+  end
+
+end

data/lib/distil/source-file/javascript-file.rb

@@ -0,0 +1,17 @@
+module Distil
+  
+  class JavascriptFile < SourceFile
+    extension 'js'
+    content_type 'js'
+    
+    def can_embed_as_content(file)
+      [".css", ".html", ".json"].include?(file.extension)
+    end
+
+    def escape_embeded_content(content)
+      content.gsub("\\", "\\\\").gsub("\n", "\\n").gsub("\"", "\\\"").gsub("'", "\\\\'")
+    end
+
+  end
+
+end

data/lib/distil/source-file/json-file.rb

@@ -0,0 +1,16 @@
+require "distil/source-file/javascript-file"
+
+module Distil
+  
+  class JsonFile < JavascriptFile
+    
+    extension 'json'
+    content_type 'js'
+    
+    def minified_content(source)
+      super("(#{source})")[1..-3]
+    end
+  
+  end
+  
+end

data/lib/distil/source-file.rb

@@ -0,0 +1,172 @@
+require 'fileutils'
+
+$compressor = File.expand_path("#{VENDOR_DIR}/yuicompressor-2.4.2.jar")
+
+module Distil
+  
+  class SourceFile
+    attr_accessor :parent_folder, :full_path
+    class_attr :extension
+    class_attr :content_type
+
+    include ErrorReporter
+    
+    def initialize(filepath)
+      @full_path= File.expand_path(filepath)
+
+      @parent_folder= File.dirname(@full_path)
+      @dependencies= []
+      @assets= []
+    
+      @@file_cache[@full_path]= self
+    end
+  
+    def can_embed_as_content(file)
+      false
+    end
+
+    def warning(message, line=nil)
+      super(message, self, line)
+    end
+    
+    def error(message, line=nil)
+      super(message, self, line)
+    end
+    
+    @@file_types= []
+    def self.inherited(subclass)
+      @@file_types << subclass
+    end
+
+    def self.file_types
+      @@file_types
+    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)[1..-1]
+    
+      @@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 basename(suffix=extension)
+      File.basename(@full_path, suffix)
+    end
+  
+    def file_path
+      @file_path
+    end
+
+    def file_path=(path)
+      @file_path=path
+    end
+  
+    def load_content
+      File.read(@full_path)
+    end
+
+    def escape_embeded_content(content)
+      content
+    end
+  
+    def content
+      @content ||= load_content
+    end
+
+    def last_modified
+      @last_modified ||= File.stat(@full_path).mtime
+    end
+    
+    def minified_content(source)
+    	# Run the Y!UI Compressor
+      return source if !content_type
+    	buffer= ""
+    
+    	IO.popen("java -jar #{$compressor} --type #{content_type}", "r+") { |pipe|
+    	  pipe.puts(source)
+    	  pipe.close_write
+    	  buffer= pipe.read
+  	  }
+	  
+      buffer
+    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
+      content
+      @dependencies
+    end
+
+    def add_dependency(file)
+      return if @dependencies.include?(file)
+      @dependencies << file
+    end
+  
+    def assets
+      content
+      @assets
+    end
+  
+    def add_asset(file)
+      @assets << file
+    end
+  
+    def copy_to(folder, prefix)
+      file_path= self.file_path || relative_to_folder(prefix||"")
+      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
+
+end
+
+# load all the other file types
+Dir.glob("#{LIB_DIR}/distil/source-file/*-file.rb") { |file|
+  require file
+}