distil 0.7.0

data/lib/configurable.rb

@@ -0,0 +1,125 @@
+module Kernel
+
+  def Boolean(string)
+    return true if string == true || string =~ /^true$/i
+    return false if string == false || string.nil? || string =~ /^false$/i
+    raise ArgumentError.new("invalid value for Boolean: \"#{string}\"")
+  end
+
+end
+
+
+
+class Configurable
+  attr_reader :options
+  
+  @@options= {}
+
+  def get_options(settings=nil, parent=nil)
+    keys= @@options.keys
+    values= @@options.map { |k,v| v[:value] }
+  
+    s= Struct.new(*keys).new(*values)
+    return s if !settings
+  
+    setting_keys= settings.keys.map { |key| key.to_s }
+  
+    @@options.each { |key, value|
+
+      intersect= value[:aliases] & setting_keys
+      next if !parent && intersect.empty?
+
+      if (intersect.empty?)
+        s[key]= parent[key]
+        next
+      end
+    
+      if (intersect.length>1)
+        raise ArgumentError, "Multiple variants for #{key.to_s} defined: #{intersect.join(", ")}"
+      end
+          
+      setting_key= intersect[0]
+      setting_value= settings[setting_key]
+      settings.delete(setting_key)
+    
+      # decide if any type conversions are needed...
+      type= value[:type]
+      setting_value= case
+        when FalseClass==type || TrueClass==type
+          Boolean(setting_value)
+        when Array==type
+          setting_value.is_a?(String) ? setting_value.split(/\s*,\s*/) : setting_value
+        when Fixnum==type
+          setting_value.to_i
+        when NilClass==type
+          setting_value
+        when String==type
+          setting_value.to_s
+        else
+          type.new(setting_value)
+        end
+    
+      s[key]= setting_value
+
+    }
+
+    s
+  end
+
+  # option name, [type], [default], [options]
+  def self.option(name, *rest)
+  
+    name_string= name.to_s
+  
+    info= {
+      :aliases=>[name_string, name_string.gsub('_', '-'), name_string.gsub('_', ' ')].uniq
+    }
+
+    arg= rest.shift
+
+    if (arg.is_a?(Class))
+      info[:type]= arg
+      info[:value]= nil #arg.new
+      arg= rest.shift
+    end
+
+    if (!arg.is_a?(Hash))
+      info[:value]= arg
+      info[:type]= arg.class if !info.key?(:type)
+      arg= rest.shift
+    end
+
+    # handle named arguments
+    if (arg.is_a?(Hash))
+      info.merge!(arg)
+    end
+
+    @@options[name]= info
+  
+    Configurable.send :define_method, name do
+      @options[name]
+    end
+  
+  end
+
+  def self.option_alias(name, name_alias)
+    if (!@@options.key?(name))
+      raise ArgumentError, "No such option: #{name}"
+    end
+  
+    name_alias= name_alias.to_s
+  
+    @@options[name][:aliases].concat([name_alias,
+                                      name_alias.to_s.gsub('_', '-'),
+                                      name_alias.to_s.gsub('_', ' ')].uniq)
+  end
+  
+  def initialize(options={}, parent=nil)
+    if (parent.is_a?(Configurable))
+      parent_options= parent.options
+    end
+    @options= get_options(options, parent_options)
+    @extras= options
+  end
+  
+end

data/lib/file-set.rb

@@ -0,0 +1,42 @@
+require "#{$script_dir}/source-file"
+
+class FileSet
+  include Enumerable
+  attr_reader :files
+  
+  def initialize(set)
+   @files= []
+   case
+     when (set.is_a?(String))
+       include_file(set)
+     when (set.is_a?(Array))
+       set.each { |f| include_file(f) }
+    end
+  end
+  
+  def include_file(file)
+    full_path= File.expand_path(file)
+
+    if File.directory?(full_path)
+      Dir.foreach(full_path) { |f|
+          next if ('.'==f[/^\./])
+          include_file(File.join(full_path, f))
+      }
+    else
+      if (File.exists?(full_path))
+        source_file= SourceFile.from_path(full_path)
+      else
+        source_file= Target.current.find_file(file)
+        return if (!source_file)
+      end
+      
+      return if (@files.include?(source_file))
+      @files << source_file
+    end
+  end
+  
+  def each
+    @files.each { |f| yield f }
+  end
+  
+end

data/lib/file-types/css-file.rb

@@ -0,0 +1,75 @@
+class CssFile < SourceFile
+
+  def self.extension
+    ".css"
+  end
+
+  def can_embed_as_content
+    true
+  end
+
+  def minify_content_type
+    "css"
+  end
+  
+  def content
+    return @content if (@content && @root_folder==@@root_folder)
+
+    # Remember the value of the class root_folder variable, because it changes
+    # where files are generated relative to.
+    @root_folder= @@root_folder
+
+    buffer= File.read(@full_path)
+    # Replace all ' (single quotes) with " (double quotes) in
+    # order to fix a problem with the background url regexp
+    buffer.gsub!(/\'/,'"')
+    # Force a newline after a rule terminating ; (semi-colon) 
+    # in order to fix a problem with the background url regexp
+    buffer.gsub!(/;(\n|\r)*/, ";\n")
+
+    # Rewrites the 'url("...")' rules to a relative path 
+    # based on the location of the new concatenated CSS file.
+    line_num=0
+
+    lines= buffer.split("\n")
+    
+    lines.each { |line|
+    
+      line_num+=1
+
+      line.gsub!(/@import\s+url\("?(.*\.css)"?\)/) { |match|
+        css_file= File.join(@parent_folder, $1)
+        
+        if (!File.exists?(css_file))
+          error "imported CSS file not found: #{$1}", line_num
+          # leave the @import rule in place
+          match
+        else
+          dependency= SourceFile.from_path(css_file)
+          @dependencies << dependency
+        end
+      }
+      
+      line.gsub!(/url\("?(.*\.(jpg|png|gif))"?\)/) { |match|
+        image_file= File.join(@parent_folder, $1)
+
+        if (!File.exists?(image_file))
+          warning "resource not found: #{$1} (#{image_file})", line_num
+          "url(\"#{$1}\")"
+        else
+          asset= SourceFile.from_path(image_file)
+          @assets << asset
+          # dependency.dependencies
+          "url(\"{{FILEREF(#{asset})}}\")"
+        end
+      }
+    }
+
+    @content= lines.join("\n")
+  end
+
+  def debug_content_relative_to_destination(destination)
+    "@import url(\"#{self.relative_to_folder(destination)}\");\n"
+  end
+  
+end

data/lib/file-types/html-file.rb

@@ -0,0 +1,11 @@
+class HtmlFile < SourceFile
+
+  def self.extension
+    ".html"
+  end
+
+  def can_embed_as_content
+    true
+  end
+
+end

data/lib/file-types/javascript-file.rb

@@ -0,0 +1,98 @@
+$jsl_import_regex= /\/\*jsl:import\s+([^\*]*)\*\//
+$include_regex= /NIB\.asset\(['"]([^)]+)['"]\)/
+
+class JavascriptFile < SourceFile
+
+  def self.extension
+    ".js"
+  end
+
+  def can_embed_as_content
+    true
+  end
+
+  def minify_content_type
+    "js"
+  end
+
+  def content
+    return @content if (@content && @root_folder==@@root_folder)
+
+    # Remember the value of the class root_folder variable, because it changes
+    # where files are generated relative to.
+    @root_folder= @@root_folder
+
+    @dependencies= []
+    content= File.read(@full_path).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(@parent_folder, $1))
+        
+        if (File.exists?(import_file))
+          dependency= SourceFile.from_path(import_file)
+          @dependencies << dependency
+        else
+          dependency= Target.current.find_file($1)
+          if (dependency)
+            @dependencies << dependency
+          else
+            error "Missing import file: #{$1}", line_num
+          end
+        end
+        
+        # replace jsl import with empty string
+        ""
+
+      }
+      
+      line.gsub!($include_regex) { |match|
+
+        import_file= File.expand_path(File.join(@parent_folder, $1))
+
+        if (!File.exists?(import_file))
+          error "Missing import file: #{$1}", line_num
+          "NIB.asset('#{$1}')"
+        else
+          asset= SourceFile.from_path(import_file)
+          @assets << asset
+          if (asset.can_embed_as_content)
+            "NIB.asset('{{FILEREF(#{asset})}}','{{CONTENTREF(#{asset})}}')"
+          else
+            "NIB.asset('{{FILEREF(#{asset})}}')"
+            # include_content= asset.content.gsub("\\", "\\\\").gsub(/>\s+</, "><").gsub("\n", "\\n").gsub("\"", "\\\"").gsub("'", "\\\\'")
+            # "INC('{{FILEREF(#{asset})}}','{{CONTENTREF(#{asset})}}')"
+          end
+        end
+        
+      }
+      
+    }
+
+    # return the array of dependencies
+    @content= content.join("\n") + "\n"
+  end
+
+  def content_relative_to_destination(destination)
+    relative= super(destination)
+    relative.gsub(/\{\{CONTENTREF\(([^)]*)\)\}\}/) { |match|
+      file= SourceFile.from_path($1)
+      included_content= file.content_relative_to_destination(destination)
+      included_content= file.minify_content(included_content)
+      included_content.gsub("\\", "\\\\").gsub(/>\s+</, "><").gsub("\n", "\\n").gsub("\"", "\\\"").gsub("'", "\\\\'")
+    }
+  end
+  
+  def debug_content_relative_to_destination(destination)
+    path= @file_path ? @file_path : self.relative_to_folder(destination)
+    "loadScript(\"#{path}\");\n"
+  end
+
+end

data/lib/file-types/json-file.rb

@@ -0,0 +1,14 @@
+require "#{$script_dir}/file-types/javascript-file.rb"
+
+class JsonFile < JavascriptFile
+
+  def self.extension
+    ".json"
+  end
+
+  def minify_content(source)
+    super("(#{source})")[1..-3]
+    
+  end
+  
+end

data/lib/file-types/nib-file.rb

@@ -0,0 +1,9 @@
+require "#{$script_dir}/file-types/javascript-file.rb"
+
+class NibFile < JavascriptFile
+
+  def self.extension
+    ".jsnib"
+  end
+
+end

data/lib/jsdoc.conf

@@ -0,0 +1,18 @@
+{
+	// source files to use
+	_: [@DOC_FILES@],
+	
+	// document all functions, even uncommented ones
+	a: true,
+	
+	// including those marked @private
+	p: true,
+	
+	// use this directory as the output directory
+	d: "@DOC_OUTPUT_DIR@",
+	
+	// use this template
+	t: "@DOC_TEMPLATE_DIR@",
+	
+	plugins: "@DOC_PLUGINS_DIR@"
+}

data/lib/jsl.conf

@@ -0,0 +1,121 @@
+#
+# JavaScript Lint 0.2.4 Configuration File
+#
+# This file can be used to lint a collection of scripts, or to enable
+# or disable warnings for scripts that are linted via the command line.
+#
+
+### Warnings
+# Enable or disable warnings based on requirements.
+# Use "+WarningName" to display or "-WarningName" to suppress.
+#
++no_return_value              # function {0} does not always return a value
++duplicate_formal             # duplicate formal argument {0}
++equal_as_assign              # test for equality (==) mistyped as assignment (=)?{0}
++var_hides_arg                # variable {0} hides argument
++redeclared_var               # redeclaration of {0} {1}
++anon_no_return_value         # anonymous function does not always return a value
++missing_semicolon            # missing semicolon
++meaningless_block            # meaningless block; curly braces have no impact
++comma_separated_stmts        # multiple statements separated by commas (use semicolons?)
++unreachable_code             # unreachable code
++missing_break                # missing break statement
++missing_break_for_last_case  # missing break statement for last case in switch
++comparison_type_conv         # comparisons against null, 0, or an empty string allowing implicit type conversion (use === or !==)
+-inc_dec_within_stmt          # increment (++) and decrement (--) operators used as part of greater statement
++useless_void                 # use of the void type may be unnecessary (void is always undefined)
++multiple_plus_minus          # unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs
++use_of_label                 # use of label
+-block_without_braces         # block statement without curly braces
++leading_decimal_point        # leading decimal point may indicate a number or an object member
++trailing_decimal_point       # trailing decimal point may indicate a number or an object member
++octal_number                 # leading zeros make an octal number
++nested_comment               # nested comment
+-misplaced_regex              # regular expressions should be preceded by a left parenthesis, assignment, colon, or comma
++ambiguous_newline            # unexpected end of line; it is ambiguous whether these lines are part of the same statement
++empty_statement              # empty statement or extra semicolon
+-missing_option_explicit      # the "option explicit" control comment is missing
++partial_option_explicit      # the "option explicit" control comment, if used, must be in the first script tag
++dup_option_explicit          # duplicate "option explicit" control comment
++useless_assign               # useless assignment
+-ambiguous_nested_stmt        # block statements containing block statements should use curly braces to resolve ambiguity
++ambiguous_else_stmt          # the else statement could be matched with one of multiple if statements (use curly braces to indicate intent)
++missing_default_case         # missing default case in switch statement
++duplicate_case_in_switch     # duplicate case in switch statements
++default_not_at_end           # the default case is not at the end of the switch statement
++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
+
+
+### Output format
+# Customize the format of the error message.
+#    __FILE__ indicates current file path
+#    __FILENAME__ indicates current file name
+#    __LINE__ indicates current line
+#    __ERROR__ indicates error message
+#
+# Visual Studio syntax (default):
+#+output-format __FILE__(__LINE__): __ERROR__
+# Alternative syntax:
++output-format __FILE__:__LINE__: __ERROR__
+
+
+### Context
+# Show the in-line position of the error.
+# Use "+context" to display or "-context" to suppress.
+#
++context
+
+
+### Semicolons
+# By default, assignments of an anonymous function to a variable or
+# property (such as a function prototype) must be followed by a semicolon.
+#
+-lambda_assign_requires_semicolon
+
+
+### Control Comments
+# Both JavaScript Lint and the JScript interpreter confuse each other with the syntax for
+# the /*@keyword@*/ control comments and JScript conditional comments. (The latter is
+# enabled in JScript with @cc_on@). The /*jsl:keyword*/ syntax is preferred for this reason,
+# although legacy control comments are enabled by default for backward compatibility.
+#
+-legacy_control_comments
+
+
+### Defining identifiers
+# By default, "option explicit" is enabled on a per-file basis.
+# To enable this for all files, use "+always_use_option_explicit"
++always_use_option_explicit
+
+# Define certain identifiers of which the lint is not aware.
+# (Use this in conjunction with the "undeclared identifier" warning.)
+#
+# Common uses for webpages might be:
++define window
++define document
++define console
++define XMLHttpRequest
++define ActiveXObject
++define arguments
++define navigator
++define Image
+
+# # Coherent library
+# +define coherent
+# 
+# # Can't import Prototype because it contains _tons_ of errors (v1.5)
+# # +define Prototype
+# # +define Ajax
+# +define Event
+# +define Element
+# +define XHR
+
+### Files
+# Specify which files to lint
+# Use "+recurse" to enable recursion (disabled by default).
+# To add a set of files, use "+process FileName", "+process Folder\Path\*.js",
+# or "+process Folder\Path\*.htm".
+#
+#+process jsl-test.js

data/lib/project.rb

@@ -0,0 +1,96 @@
+require "#{$script_dir}/target"
+
+require 'yaml'
+
+class Project < Configurable
+
+  option :tasks, Array
+  option_alias :tasks, :task
+  
+  option :version, String
+  option :project_name, String
+  option_alias :project_name, :name
+  
+  option :targets, Array
+  option_alias :targets, :target
+  
+  option :mode
+  option :ignore_warnings, false
+
+  option :external_projects, Array.new
+
+  def initialize(project_file, settings)
+    @project_file= File.expand_path(project_file)
+    Dir.chdir(File.dirname(@project_file))
+    
+    project_info= YAML.load_file(@project_file)
+    settings.merge!(project_info)    
+    super(settings)
+  end
+  
+  def build_external_projects
+    
+    # Handle external projects
+    external_projects.map! { |project|
+
+      if !project.is_a?(String)
+        project
+      else
+        project={
+          "folder"=>project,
+          "build"=>"distil",
+          "include"=>File.join(project, "build")
+        }
+      end
+    }
+    
+    external_projects.each { |project|
+      
+      if (project.key?("folder") && !File.directory?(project["folder"]))
+        puts "#{@project_file}: external project folder missing: #{project["folder"]}"
+        exit
+      end
+  
+      if (!project.key?("include"))
+        project["include"]= File.join(project["folder"], "build")
+      end
+  
+      build= project["build"] || "distil"
+      wd= Dir.pwd
+      Dir.chdir(project["folder"]||project["include"])
+      # pass along mode flag to sub-projects
+      if (mode)
+        build= "#{build} -mode=#{mode}"
+      end
+      system(build)
+      Dir.chdir(wd)
+    }
+
+  end
+  
+  def build_targets
+    
+    @extras.each { |section, value|
+      
+      next if (options.targets && !options.targets.include?(section))
+      next if ((!options.targets || !options.targets.include?(section)) &&
+           value.is_a?(Hash) && value.has_key?("enabled") && !value["enabled"])
+
+      puts
+      puts "#{project_name}-#{section}:"
+      puts
+
+      task= Task.by_name(section)
+      if (task)
+        new_value= Hash.new
+        new_value[section]= value
+        value= new_value
+        section= "all"
+      end
+      
+      target= Target.new(section, value, self)
+      target.process_files
+      target.finish
+    }
+  end
+end