distil 0.13.6 → 0.14.0.b

data/lib/distil/library.rb

@@ -0,0 +1,243 @@
+module Distil
+  
+  LIBRARY_CACHE_FOLDER= File.expand_path("~/.distil/library_cache")
+  
+  class Library < Configurable
+
+    attr_reader :name, :path, :href, :version, :include_path, :project
+    attr_reader :build_command, :revision, :protocol
+
+    def initialize(config, project)
+      @project= project
+      
+      if config.is_a?(String)
+        config= {
+          :href=>config
+        }
+      end
+
+      configure_with(config) do |c|
+        
+        c.with :href do |href|
+          @href= URI.parse(href)
+          case when svn_url?
+            @protocol= :svn
+          when git_url?
+            @protocol= :git
+          when http_folder?
+            @protocol= :http_recursive
+          else
+            @protocol= :http
+          end
+        end
+        
+      end
+      
+      @name ||= File.basename(href.path, ".*")
+
+      if @path.nil?
+        parts= [LIBRARY_CACHE_FOLDER, href.host, File.dirname(href.path)]
+        case when svn_url? || git_url?
+          parts << File.basename(href.path, ".*")
+        when http_folder?
+          parts << File.basename(href.path)
+        end
+        @path= File.join(*parts)
+        @path << "-#{@version}" unless @version.nil?
+      end
+      
+      @path= File.expand_path(@path)
+      
+      update if !up_to_date?
+      
+      Dir.chdir(path) do
+        case
+        when File.exist?("Buildfile") || File.exists?("buildfile") || File.exist?("#{name}.jsproj")
+          @build_command= APP_SCRIPT
+          remote_project= Project.find(path)
+          output_folder= remote_project ? remote_project.output_folder : 'build'
+          @product_path= File.join(path, output_folder)
+        when File.exist?("Makefile") || File.exist?("makefile")
+          @build_command= "make"
+        when File.exists?("Rakefile") || File.exists?("rakefile")
+          @build_command= "rake"
+        when File.exists?("Jakefile") || File.exists?("jakefile")
+          @build_command= "jake"
+        else
+          @build_command= ""
+        end
+      end
+      
+      build
+    end
+
+    def to_s
+      "Library: #{name} @ #{path}"
+    end
+
+    def include_path
+      File.join(path, @include_path||"")
+    end
+    
+    def product_path
+      @product_path || path
+    end
+    
+    def svn_url?
+      "#{@href}" =~ /svn(?:\+ssh)?:\/\/*/
+    end
+  
+    def git_url?
+      "#{@href}" =~ /^git:\/\// || "#{@href}" =~ /\.git$/
+    end
+    
+    def http_folder?
+      File.extname(href.path).empty?
+    end
+
+    def require_git
+      begin
+        `git --version 2>/dev/null`
+      rescue
+        nil
+      end
+      if $?.nil? || !$?.success?
+        raise ValidationError.new("The git version control tool is required to pull this repository: #{uri}")
+      end
+    end
+    
+    def fetch_with_git
+      require_git
+      FileUtils.mkdir_p(path)
+      Dir.chdir path do
+        clone_cmd  = "git clone"
+        clone_cmd += " -b #{version}" unless version.nil?
+        clone_cmd += " #{href} ."
+        clone_cmd += " -q"
+        if !system(clone_cmd)
+          raise ValidationError.new("Failed to clone external project: #{href}")
+        end
+      end          
+    end
+
+    def fetch_with_http
+      if !href.respond_to?(:read)
+        raise ValidationError, "Cannot read from project source url: #{href}"
+      end
+
+      FileUtils.mkdir_p(path)
+      begin
+        text= href.read
+      rescue OpenURI::HTTPError => http_error
+        raise ValidationError, "Unable to fetch remote project: status=#{http_error.io.status[0]} url=#{href}"
+      end
+      File.open(File.join(path, File.basename(href.path)), "w") { |output|
+        output.write text
+      }
+    end
+
+    def fetch_with_http_recursive
+      dir= File.dirname(path)
+      FileUtils.mkdir_p(dir)
+      fetcher= Distil::RecursiveHTTPFetcher.new(href, 1, dir)
+      fetcher.fetch
+    end
+    
+    def fetch
+      self.send "fetch_with_#{@protocol}"
+    end
+    
+    def update_with_git
+      require_git
+      Dir.chdir path do
+        command = "git pull"
+        command << " origin #{version}" if version
+        `#{command}`
+      end
+    end
+    
+    def update_with_http
+      fetch_with_http
+    end
+    
+    def update
+      if File.exists?(path)
+        self.send "update_with_#{@protocol}"
+      else
+        fetch
+      end
+    end
+    
+    def output_path
+      @output_path||= File.join(project.output_path, name)
+    end
+    
+    def up_to_date?
+      return false unless File.exists?(path)
+      return @up_to_date unless @up_to_date.nil?
+      
+      case protocol
+      when :git
+        require_git
+        Dir.chdir path do
+          current_sha1= `git rev-parse #{version}`
+          origin_sha1= `git ls-remote #{href} #{version}`
+          if $?.exitstatus!=0
+            project.error("Could not determine whether library is up to date: #{name}")
+            return @up_to_date=true
+          end
+          origin_sha1= origin_sha1.split(/\s/)[0]
+          return @up_to_date= (current_sha1.strip==origin_sha1.strip)
+        end
+      else
+        @up_to_date= true
+      end
+    end
+    
+    def build
+      update unless up_to_date?
+
+      unless build_command.empty?
+        Dir.chdir(path) do
+          exit 1 if !system("#{build_command}")
+        end
+      end
+      
+      File.unlink(output_path) if File.symlink?(output_path)
+      
+      # FileUtils.rm_rf(project_path) if File.directory?(project_path)
+      File.symlink(project.relative_output_path_for(product_path), output_path)
+    end
+    
+    def content_for(content_type, variant=RELEASE_VARIANT)
+      file= file_for(content_type, variant)
+      return nil if !file
+      File.read(file)
+    end
+    
+    def file_for(content_type, language=nil, variant=RELEASE_VARIANT)
+      if language
+        file= File.join(output_path, "#{name}-#{language}-#{variant}.#{content-type}")
+        return file if File.exists?(file)
+        file= File.join(output_path, "#{name}-#{language}-release.#{content-type}")
+        return file if File.exists?(file)
+        file= File.join(output_path, "#{name}-#{language}.#{content-type}")
+        return file if File.exists?(file)
+      end
+      
+      file= File.join(output_path, "#{name}-#{variant}.#{content_type}")
+      return file if File.exists?(file)
+      file= File.join(output_path, "#{name}-release.#{content_type}")
+      return file if File.exists?(file)
+      file= File.join(output_path, "#{name}.#{content_type}")
+      return file if File.exists?(file)
+      
+      candidates= Dir.glob(File.join(output_path, "*.#{content_type}"))
+      return candidates.first if 1==candidates.length
+      
+      nil
+    end
+
+  end
+  
+end

data/lib/distil/product/cache-manifest-product.rb

@@ -0,0 +1,21 @@
+module Distil
+  
+  class CacheManifestProduct < Product
+    content_type "manifest"
+    variants [RELEASE_VARIANT]
+    
+    def build
+      FileUtils.mkdir_p(File.dirname(output_path))
+      File.open(output_path, "w") { |output|
+        output.puts "CACHE MANIFEST"
+        output.puts "# generated @ #{Time.new.rfc2822}"
+        output.puts
+        project.assets.each { |a|
+          output.puts project.relative_output_path_for(a)
+        }
+      }
+    end
+    
+  end
+  
+end

data/lib/distil/product/css-product.rb

@@ -1,34 +1,52 @@
 module Distil
-
+  
   class CssProduct < Product
-    include Concatenated
-    extension "css"
-  end
+    content_type "css"
+    variants [RELEASE_VARIANT, DEBUG_VARIANT]
 
-  class CssMinifiedProduct < Product
-    include Minified
-    extension "css"
-  end
+    def build_debug
+      File.open(output_path, "w") { |output|
+
+        output.puts notice_comment
+        output_files= []
+        
+        libraries.each { |l|
+          f= project.file_from_path(l.file_for(content_type, language, variant))
+          output_files << f if f
+        }
+
+        output_files += files
+        
+        output_files.each { |f|
+          output.puts "@import url(\"#{f.relative_path}\");"
+        }
+        
+      }
+    end
+
+    def build_release
+      File.open(output_path, "w") { |output|
 
-  class CssDebugProduct < Product
-    include Debug
-    extension "css"
+        output.puts notice_comment
 
-    def write_output
-      return if up_to_date
-      @up_to_date= true
-      
-      File.open(filename, "w") { |f|
-        f.write(target.notice_text)
+        output_files= []
         
-        external_files.each { |ext|
-          next if !File.exist?(ext)
-          f.write("@import url(\"#{relative_path(ext)}\");\n")
+        libraries.each { |l|
+          f= project.file_from_path(l.file_for(content_type, language, variant))
+          output_files << f if f
         }
-      
-        files.each { |file|
-          f.write("@import url(\"#{relative_path(file)}\");\n")
+
+        output_files += files
+        
+        output_files.each { |f|
+          content= f.rewrite_content_relative_to_path(nil)
+          next if !content || content.empty?
+
+          output.puts "/* #{f.relative_path} */"
+          output.puts content
+          output.puts ""
         }
+        
       }
     end
     

data/lib/distil/product/html-product.rb

@@ -0,0 +1,20 @@
+module Distil
+  
+  class HtmlProduct < Product
+    content_type "html"
+    variants [RELEASE_VARIANT]
+    
+    def build
+      folder= File.dirname(output_path)
+      FileUtils.mkdir_p(folder)
+      
+      files.each { |f|
+        product_path= File.join(folder, File.basename(f))
+        FileUtils.rm product_path if File.exists? product_path
+        File.symlink f.path_relative_to(folder), product_path
+      }
+    end
+    
+  end
+  
+end

data/lib/distil/product/javascript-product.rb

@@ -1,139 +1,150 @@
 module Distil
 
-  class JavascriptProduct < JavascriptBaseProduct
-    include Concatenated
-
-    extension "js"
+  BOOTSTRAP_SCRIPT= "#{ASSETS_DIR}/distil.js"
+  FILE_SEPARATOR= "        /*jsl:ignore*/;/*jsl:end*/"
+  
+  class JavascriptProduct < Product
+    content_type "js"
+    variants [RELEASE_VARIANT, DEBUG_VARIANT]
     
-    option :global_export
-    option :additional_globals, [], :aliases=>['globals']
+    include ErrorReporter
     
-    def before_externals(f)
-      f.puts("/*#nocode+*/")
-      f.puts(bootstrap_source) if bootstrap
+    MODULE_TEMPLATE= ERB.new %q{
+      distil.module("<%=project.name%>", <%=json_for(definition)%>);
+    }.gsub(/^\s*/, '')
+    
+    def can_embed_as_content(file)
+      ["css", "html", "json"].include?(file.extension)
     end
 
-    def after_externals(f)
+    def escape_embeded_content(file)
+      content= file.rewrite_content_relative_to_path(nil)
+      file.minified_content(content)
+    end
+
+    def json_for(obj)
+      JSON.generate(obj)
     end
     
-    def before_files(f)
+    def module_definition
+      asset_paths= {}
+      asset_data= {}
+      definition= {}
+      required_files= []
+      
+      libraries.each { |l|
+        f= l.file_for(content_type, language, variant)
+        required_files << project.relative_output_path_for(f)
+      }
+      
+      files.each { |f|
+        required_files << project.relative_output_path_for(f)
+      }
+      
+      assets.each { |asset|
+        next if project.source_files.include?(asset)
 
-      if 0 != assets.length
-        asset_references= []
-        asset_map= []
-        assets.each { |a|
-          if can_embed_file?(a)
-            next if @files.include?(a)
-            content= a.minified_content(target.get_content_for_file(a))
-            content= content.gsub("\\", "\\\\").gsub("\n", "\\n").gsub("\"", "\\\"").gsub("'", "\\\\'")
-            asset_references << "\"#{target.alias_for_asset(a)}\": \"#{content}\""
-          else
-            asset_alias= target.alias_for_asset(a)
-            asset_path= relative_path(a)
-            next if asset_alias==asset_path
-            asset_map << "'#{asset_alias}': '#{asset_path}'" 
+        if RELEASE_VARIANT==variant
+          key= project.asset_aliases[asset]||asset.relative_path
+          if can_embed_as_content(asset)
+            asset_data[key]= escape_embeded_content(asset)
           end
-        }
+        else
+          key= project.asset_aliases[asset]
+          asset_paths[key]= project.relative_output_path_for(asset) if key
+        end
+      }
+      
+      definition[:asset_map]= asset_paths
+      if RELEASE_VARIANT==variant
+        definition[:assets]= asset_data
+      else
+        definition[:required]= required_files
+      end
+      
+      MODULE_TEMPLATE.result binding
+    end
 
-        f << <<-EOS
+    def build_release
+      File.open(output_path, "w") { |output|
+        
+        output.puts notice_comment
         
-distil.module('#{target.name}', {
-  folder: '',
-  asset_map: {
-    #{asset_map.join(",\n    ")}
-  },
-  assets: {
-    #{asset_references.join(",\n    ")}
-  }
-});
+        if (APPLICATION_TYPE==project.project_type)
+          output.puts File.read(BOOTSTRAP_SCRIPT)
+          output.puts FILE_SEPARATOR
+        end
 
+        # emit remote assets first
+        libraries.each { |l|
+          f= project.file_from_path(l.file_for(content_type, language, variant))
+          next if !f
+          
+          content= f.rewrite_content_relative_to_path(nil)
+          next if !content || content.empty?
+          
+          output.puts content
+          output.puts FILE_SEPARATOR
+        }
 
-EOS
-      end
+        output.puts module_definition
 
-      if global_export
-        exports= [global_export, *additional_globals].join(", ")
-        f.puts "(function(#{exports}){"
-      end
-    end
-    
-    def after_files(f)
-      if global_export
-        exports= ["window.#{global_export}=window.#{global_export}||{}", *additional_globals].join(", ")
-        f.puts "})(#{exports});"
-      end
+        if project.global_export
+          exports= [project.global_export, *project.additional_globals].join(", ")
+          output.puts "(function(#{exports}){"
+        end
 
-      f.puts "\n\n/*#nocode-*/\n\n"
-      
-      f.puts "distil.kick();" if bootstrap
-      
-    end
-    
-  end
+        files.each { |f|
+          content= f.rewrite_content_relative_to_path(nil)
 
-  class JavascriptMinifiedProduct < Product
-    include Minified
-    extension "js"
-  end
+          next if !content || content.empty?
+            
+          output.puts content
+          output.puts ""
+          output.puts FILE_SEPARATOR
+        }
+        
+        if project.global_export
+          exports= ["window.#{project.global_export}=window.#{project.global_export}||{}", *project.additional_globals].join(", ")
+          output.puts "})(#{exports});"
+        end
+        
+        output.puts "distil.moduleDidLoad('#{project.name}');"  
+      }
+    end
 
-  class JavascriptDebugProduct < JavascriptBaseProduct
-    include Debug
-    extension "js"
+    def build_debug
+      File.open(output_path, "w") { |output|
 
-    option :global_export
-    option :synchronous_load, false, :aliases=>['sync']
-  
-    def write_output
-      return if up_to_date
-      @up_to_date= true
-      
-      copy_bootstrap_script
-      
-      required_files= files.map { |file| "'#{relative_path(file)}'" }
-      asset_map= []
-      assets.each { |a|
-        asset_alias= target.alias_for_asset(a)
-        asset_path= relative_path(a)
-        next if asset_alias==asset_path
-        asset_map << "'#{asset_alias}': '#{asset_path}'" 
-      }
-      
-      external_files.each { |ext|
-        next if !File.exist?(ext)
-        required_files.unshift("'#{relative_path(ext)}'")
-      }
-      
-      File.open(filename, "w") { |f|
-        f.write(target.notice_text)
-        f.write("#{bootstrap_source}\n\n") if bootstrap
+        output.puts notice_comment
         
-        if global_export
-          f.write("window.#{global_export}=window.#{global_export}||{};");
-          f.write("\n\n");
+        if (APPLICATION_TYPE==project.project_type)
+          output.puts File.read(BOOTSTRAP_SCRIPT)
         end
         
-        files.each { |file|
-          f.write("/*jsl:import #{relative_path(file)}*/\n")
-        }
-        
-        if (APP_TYPE==target.target_type && synchronous_load)
-          f.puts "distil.sync= #{Kernel::Boolean(synchronous_load)};"
+        if project.global_export
+          output.puts
+          output.puts "window.#{project.global_export}=window.#{project.global_export}||{};"
+          output.puts
         end
+
+        libraries.each { |l|
+          path= project.relative_output_path_for(l.file_for(content_type, language, variant))
+          next if !path
+          output.puts "/*jsl:import #{path}*/"
+        }
         
-        f.write(<<-EOS)
+        files.each { |f|
+          path= project.relative_output_path_for(f)
+          next if !path
+          output.puts "/*jsl:import #{path}*/"
+        }
 
-distil.module('#{target.name}', {
-  folder: '',
-  required: [#{required_files.join(", ")}],
-  asset_map: {
-    #{asset_map.join(",\n    ")}
-  }
-});
-EOS
+        output.puts module_definition
+          
       }
-
     end
-    
-  end
 
-end
+  end
+  
+end