distil 0.10.4 → 0.11.0

data/lib/distil/target.rb

@@ -0,0 +1,235 @@
+module Distil
+
+  class Target < Configurable
+    include ErrorReporter
+    
+    attr_accessor :project, :assets
+    
+    option :version, String
+    option :name, String
+    option :notice_file, ProjectPath, "$(source_folder)/NOTICE", :aliases=>['notice']
+    option :target_type, String, FRAMEWORK_TYPE, :aliases=>['type'], :valid_values=>[FRAMEWORK_TYPE, APP_TYPE]
+
+    option :include_files, FileSet, :aliases=>['source']
+    option :exclude_files, FileSet, :aliases=>['exclude']
+
+    option :include_projects, [], :aliases=>['include']
+    
+    option :validate, true
+    option :generate_docs, false
+
+    option :minify, true
+    option :compress, true
+
+    def initialize(settings, project)
+      @project=project
+
+      super(settings, project)
+
+      @assets= Set.new
+      @probed= Set.new
+      @contents= {}
+      @asset_aliases= {}
+      
+      if !include_files
+        self.include_files= FileSet.new
+      end
+      
+      if !exclude_files
+        self.exclude_files= FileSet.new
+      end
+
+      include_projects.each { |p|
+        external_project= project.external_project_with_name(p)
+        if !external_project
+          raise ValidationError.new("No such external project: #{p}")
+        end
+        
+        if (WEAK_LINKAGE==external_project.linkage)
+          external_project.linkage= STRONG_LINKAGE
+        end
+      }
+    end
+
+    def source_folder
+      project.source_folder
+    end
+    
+    def tasks
+      @tasks ||= Task.tasks.map { |task| task.new(@extras.clone, self) }
+    end
+
+    def products
+      return @products if @products
+      
+      product_types= [CssProduct, CssDebugProduct, JavascriptProduct, JavascriptDebugProduct]
+      if minify
+        product_types << CssMinifiedProduct
+        product_types << JavascriptMinifiedProduct
+      end
+
+      if generate_docs
+        product_types << JavascriptDocProduct
+      end
+      
+      @products=[]
+      product_types.each { |t|
+        product= t.new(@extras.clone, self)
+        product.files= files
+        @products << product if !product.files.empty?
+      }
+
+      @products
+    end
+    
+    def notice_text
+      @notice_text if @notice_text
+
+      if (nil==@notice_text)
+        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
+    end
+
+    def include_file(file)
+      return if @probed.include?(file)
+      return if @files.include?(file)
+      return if !include_files.include?(file)
+      return if exclude_files.include?(file)
+
+      @probed << file
+
+      tasks.each { |t| t.include_file(file) }
+      
+      file.dependencies.each { |d| include_file(d) }
+      @assets.merge(file.assets)
+      @assets << file
+      @files << file
+    end
+    
+    def files
+      return @files if @files
+      
+      @probed= Set.new
+      @files= []
+    
+      tasks.each { |t|
+        extra_files= t.find_files
+        extra_files.each { |f| include_files.include_file(f) }
+      }
+      
+      include_files.each { |i| include_file(i) }
+      
+      @files
+    end
+
+    def symlink_assets
+      folders= []
+
+      assets.each { |a|
+        path= a.file_path || a.relative_to_folder(source_folder)
+
+        parts= File.dirname(path).split(File::SEPARATOR)
+        if ('.'==parts[0])
+          product_path= File.join(output_folder, path)
+          FileUtils.rm product_path if File.exists? product_path
+          File.symlink a.relative_to_folder(output_folder), product_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|
+        src_folder= File.join(source_folder, f)
+        product_folder= File.join(project.output_folder, f)
+        
+        next if File.exists?(product_folder)
+        File.symlink src_folder, product_folder
+      }
+    end
+  
+    def copy_assets
+      assets.each { |a|
+        a.copy_to(project.output_folder, source_folder)
+      }
+    end
+  
+    def build_assets
+      if (RELEASE_MODE==project.mode)
+        copy_assets
+      else
+        symlink_assets
+      end
+    end
+    
+    def add_asset(asset)
+      @assets << asset
+    end
+    
+    def set_alias_for_asset(asset_alias, asset_file)
+      @assets << asset_file
+      @asset_aliases[asset_file.to_s]= asset_alias
+    end
+    
+    def alias_for_asset(asset_file)
+      full_path= asset_file.to_s
+      @asset_aliases[full_path] || asset_file.relative_to_folder(source_folder)
+    end
+    
+    def build
+      puts "\n#{name}:\n\n"
+      
+      tasks.each { |t| t.process_files(files) }
+      
+      products.each { |p| p.write_output }
+      
+      build_assets
+    end
+    
+    def find_file(file, source_file=nil)
+      return nil if project.external_projects.nil?
+      
+      parts= file.split(File::SEPARATOR)
+      project_name= parts[0]
+
+      external_project= project.external_project_with_name(project_name)
+      return nil if !external_project
+
+      if 1==parts.length
+        return SourceFile::from_path(external_project.product_name(:import, source_file.extension))
+      else
+        return SourceFile::from_path(File.join(external_project.source_folder, *parts[1..-1]))
+      end
+    end
+    
+    def get_content_for_file(file)
+      file=SourceFile.from_path(file) if !file.is_a?(SourceFile)
+      @contents[file.to_s] ||= file.content
+    end
+
+    def set_content_for_file(file, content)
+      @contents[file.to_s] = content
+    end
+    
+  end
+  
+end
+
+# load all the other target types
+# Dir.glob("#{File.dirname(__FILE__)}/target/*-target.rb") { |file|
+#   require file
+# }

data/lib/distil/task/css-dependency-task.rb

@@ -0,0 +1,64 @@
+module Distil
+
+  CSS_IMPORT_REGEX = /@import\s+url\("?(.*\.css)"?\)/
+  
+  class CssDependencyFilter < Task
+  
+    def handles_file(file)
+      return ["css"].include?(file.content_type)
+    end
+  
+    def include_file(file)
+      return if !handles_file(file)
+
+      content= target.get_content_for_file(file)
+
+      # Replace all ' (single quotes) with " (double quotes)
+      content.gsub!(/\'/,'"')
+      # Force a newline after a rule terminating ; (semi-colon)
+      content.gsub!(/;(\n|\r)*/, ";\n")
+
+      source_folder= get_option("source_folder")
+      
+      # Rewrites the 'url("...")' rules to a relative path 
+      # based on the location of the new concatenated CSS file.
+      line_num=0
+
+      lines= content.split("\n")
+    
+      lines.each { |line|
+    
+        line_num+=1
+
+        line.gsub!(CSS_IMPORT_REGEX) { |match|
+          css_file= File.join(file.parent_folder, $1)
+
+          if (!File.exists?(css_file))
+            file.error "Imported CSS file not found: #{$1}", line_num
+            # leave the @import rule in place
+            match
+          else
+            file.add_dependency(SourceFile.from_path(css_file))
+          end
+        }
+      
+        line.gsub!(/url\("?(.*\.(jpg|png|gif))"?\)/) { |match|
+          image_file= File.join(file.parent_folder, $1)
+
+          if (!File.exists?(image_file))
+            file.warning "Resource not found: #{$1} (#{image_file})", line_num
+            "url(\"#{$1}\")"
+          else
+            asset= SourceFile.from_path(image_file)
+            file.add_asset(asset)
+            "url(\"#{asset.relative_to_folder(source_folder)}\")"
+          end
+        }
+      }
+    
+      target.set_content_for_file(file, lines.join("\n"))
+    end
+  
+  end
+
+end

data/lib/distil/task/jsl-dependency-task.rb

@@ -0,0 +1,49 @@
+module Distil
+
+  JSL_IMPORT_REGEX= /\/\*jsl:import\s+([^\*]*)\*\//
+  
+  class JslDependencyTask < Task
+
+    def handles_file(file)
+      return ["js"].include?(file.content_type)
+    end
+
+    def include_file(file)
+      return if !handles_file(file)
+
+      content= target.get_content_for_file(file).split("\n")
+    
+      line_num=0
+    
+      content.each { |line|
+      
+        line_num+=1
+      
+        # handle dependencies
+        line.gsub!(JSL_IMPORT_REGEX) { |match|
+
+          import_file= File.expand_path(File.join(file.parent_folder, $1))
+          if (File.exists?(import_file))
+            file.add_dependency SourceFile.from_path(import_file)
+          else
+            dependency= target.find_file($1, file)
+            if (dependency)
+              file.add_dependency dependency
+            else
+              file.error "Missing import file: #{$1}", line_num
+            end
+          end
+        
+          # replace jsl import with empty string
+          ""
+
+        }
+      
+      }
+    
+      target.set_content_for_file(file, content.join("\n"))
+    end
+    
+  end
+  
+end

data/lib/distil/task/nib-task.rb

@@ -0,0 +1,72 @@
+module Distil
+
+  NIB_ASSET_REGEX= /(NIB\.asset(?:Url)?)\(['"]([^)]+)['"]\)/
+  
+  class NibTask < Task
+    include ErrorReporter
+
+    def handles_file(file)
+      return ["js"].include?(file.content_type)
+    end
+
+    def preprocess_file(nib_name, nib_folder, file)
+      return if !handles_file(file)
+
+      content= target.get_content_for_file(file).split("\n")
+    
+      line_num=0
+    
+      content.each { |line|
+      
+        line_num+=1
+      
+        # handle dependencies
+        line.gsub!(NIB_ASSET_REGEX) { |match|
+          asset_file= File.expand_path(File.join(file.parent_folder, $2))
+          asset_file= SourceFile.from_path(asset_file)
+          if (!File.exists?(asset_file))
+            file.warning "Asset not found: #{$2} (#{asset_file})", line_num
+            "#{$0}"
+          else
+            "#{$1}(\"#{asset_file.relative_to_folder(target.source_folder)}\")"
+            # "#{$1}(\"#{nib_name}##{asset_file.relative_to_folder(nib_folder)}\")"
+          end
+        }
+      
+      }
+    
+      target.set_content_for_file(file, content.join("\n"))
+    end
+    
+    def include_file(file)
+
+      return if !File.fnmatch("**/*.jsnib/*.js", file)
+      # puts "Nib asset: #{file}"
+      match= file.to_s.match(/([^\.\/]+).jsnib\/(.*)\.js/)
+      return if match[1]!=match[2]
+
+      nib_name= match[1]
+      nib_folder= File.dirname(file)
+
+      preprocess_file(nib_name, nib_folder, file)
+      
+      
+      # Found main js file inside the JSNib add assets for all the other files
+      target.set_alias_for_asset("#{match[1]}##{match[2]}", file)
+      Dir.glob("#{File.dirname(file)}/**/*") { |asset|
+        next if File.directory?(asset) || asset.to_s==file.to_s
+        
+        asset= SourceFile.from_path(asset)
+        preprocess_file(nib_name, nib_folder, asset)
+        file.add_asset(asset)
+        
+        if 'html'==asset.content_type
+          target.set_alias_for_asset("#{nib_name}##{asset.relative_to_folder(nib_folder)}", asset)
+        end
+      }
+      
+    end
+    
+  end
+  
+end

data/lib/distil/task/validate-js-task.rb

@@ -0,0 +1,75 @@
+module Distil
+
+  LINT_COMMAND= "#{VENDOR_DIR}/jsl-0.3.0/bin/jsl"
+  # LINT_COMMAND= "/Users/jeff/.gem/ruby/1.8/gems/distil-0.10.2/vendor/jsl-0.3.0/bin/jsl"
+  
+  class ValidateJsTask < Task
+
+    include ErrorReporter
+    
+    option :jsl_conf, "#{LIB_DIR}/jsl.conf"
+    
+    def handles_file(file)
+      return ["js"].include?(file.content_type)
+    end
+
+    def process_files(files)
+      return if (!File.exists?(LINT_COMMAND))
+
+      tmp= Tempfile.new("jsl.conf")
+    
+      conf_files= [ "jsl.conf",
+                    "#{ENV['HOME']}/.jsl.conf",
+                    jsl_conf
+                  ]
+
+      jsl_conf= conf_files.find { |f| File.exists?(f) }
+
+      tmp << File.read(jsl_conf)
+      tmp << "\n"
+
+      tmp << "+define distil\n"
+      
+      # add aliases
+      target.project.external_projects.each { |project|
+        import_file= project.product_name(:import, 'js')
+        next if !File.exist?(import_file)
+        tmp << "+alias #{project.name} #{import_file}\n"
+      }
+    
+      files.each { |f|
+        next if !handles_file(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)
+          @@error_count+= match[1].to_i
+          @@warning_count+= match[2].to_i
+      end
+    
+      output= output.join("\n")
+    
+      if (!output.empty?)
+          puts output
+          puts
+      end
+
+    end
+    
+  end
+  
+end

data/lib/distil/task.rb

@@ -0,0 +1,50 @@
+require 'set'
+
+module Distil
+  
+  class Task < Configurable
+    
+    def initialize(options, target)
+      @target= target
+      super(options, target)
+    end
+
+    def project
+      target.project
+    end
+
+    def target
+      @target
+    end
+    
+    @@tasks= []
+    def self.inherited(subclass)
+      @@tasks << subclass
+    end
+  
+    def self.tasks
+      @@tasks
+    end
+    
+    def handles_file?(file)
+      false
+    end
+
+    def find_files
+      []
+    end
+    
+    def include_file(file)
+    end
+
+    def process_files(files)
+    end
+  
+  end
+  
+end
+
+# load all the other task types
+Dir.glob("#{LIB_DIR}/distil/task/*-task.rb") { |file|
+  require file
+}

data/lib/distil.rb

@@ -0,0 +1,72 @@
+require "set"
+require 'yaml'
+require 'tempfile'
+require 'fileutils'
+require 'zlib'
+require "open3"
+require 'uri'
+
+def class_attr(*rest)
+  rest.each { |name|
+    class_eval %(
+          def self.#{name}(*rest)
+            if (rest.length>0)
+              @#{name}= rest[0]
+            else
+              @#{name} || (superclass.respond_to?(name) ? superclass.#{name} : nil)
+            end
+          end
+          def self.#{name}=(value)
+            @#{name}= value
+          end
+          def #{name}
+            @#{name} || self.class.#{name}
+          end
+          def #{name}=(value)
+            @#{name}=value
+          end
+        )
+  }
+end
+
+def exist?(path, file)
+  File.file?(File.join(path, file))
+end
+
+module Distil
+  
+  FRAMEWORK_TYPE = "framework"
+  APP_TYPE = "application"
+  
+  WEAK_LINKAGE = 'weak'
+  STRONG_LINKAGE = 'strong'
+  LAZY_LINKAGE = 'lazy'
+  
+  DEBUG_MODE = 'debug'
+  RELEASE_MODE = 'release'
+  
+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
+
+
+
+require 'distil/error-reporter'
+require 'distil/configurable'
+require 'distil/source-file'
+require 'distil/task'
+require 'distil/product'
+require 'distil/target'
+require 'distil/project'

data/lib/jsl.conf

@@ -46,6 +46,10 @@
 +legacy_cc_not_understood     # couldn't understand control comment using /*@keyword@*/ syntax
 +jsl_cc_not_understood        # couldn't understand control comment using /*jsl:keyword*/ syntax
 +useless_comparison           # useless comparison; comparing identical expressions
++with_statement               # with statement hides undeclared variables; use temporary variable instead
++trailing_comma_in_array      # extra comma is not recommended in array initializers
++assign_to_function_call      # assignment to a function call
++parseint_missing_radix       # parseInt missing radix parameter
 
 
 ### Output format

data/vendor/jsl-0.3.0/src/Makefile.ref

@@ -89,9 +89,14 @@ LDFLAGS += -lm
 endif
 
 # Prevent floating point errors caused by VC++ optimizations
-ifeq ($(OS_ARCH),WINNT)
-CFLAGS += /Op
-endif # WINNT
+ifdef USE_MSVC
+_MSC_VER = $(shell $(CC) 2>&1 | sed -n 's/.*Compiler Version \([0-9]*\)\.\([0-9]*\).*/\1\2/p')
+ifeq (,$(filter-out 1200 1300 1310,$(_MSC_VER)))
+CFLAGS += -Op
+else
+CFLAGS += -fp:precise
+endif
+endif # USE_MSVC
 
 #
 # Ask perl what flags it was built with, so we can build js with similar flags
@@ -332,11 +337,15 @@ endif
 # special rule for jsmath.o since we want to incrementally link
 # against fdlibm to pull in only what is needed
 $(OBJDIR)/jsmath.o: jsmath.c jsmath.h jslibmath.h $(FDLIBM_LIBRARY)
-ifneq (,$(filter OS2 WINNT,$(OS_ARCH)))
+ifeq ($(OS_ARCH),OS2)
+  $(CC) -Fo$(JSMATH_PRELINK) -c $(CFLAGS) $<
+else
+ifdef USE_MSVC
   $(CC) -Fo$(JSMATH_PRELINK) -c $(CFLAGS) $<
 else
 	$(CC) -o $(JSMATH_PRELINK) -c $(CFLAGS) $<
 endif
+endif
 
 ifeq ($(OS_ARCH),QNX)
 ifneq ($(OS_TARGET),NTO)
@@ -345,12 +354,13 @@ else
 	$(LD) $(DASH_R) -o $@ $(JSMATH_PRELINK) $(FDLIBM_LIBRARY)
 endif
 else
-ifdef USE_MSVC
+ifeq ($(OS_ARCH),WINNT)
 	@echo Warning: to use $(LIBRARY) must also link against $(FDLIBM_LIBRARY)
 	@cp $(JSMATH_PRELINK) $@
-endif
+else
 	$(LD) $(DASH_R) -o $@ $(JSMATH_PRELINK) $(FDLIBM_LIBRARY)
 endif
+endif
 
 # Note: generated headers must be built before descending
 #       into fdlibm directory