sproutcore 1.6.0.1 → 1.7.1.beta

data/lib/sproutcore/tools/build.rb

@@ -13,49 +13,70 @@ $to_html5_manifest_networks = []
 
 module SC
   class Tools
-
+    
     desc "build [TARGET..]", "Builds one or more targets"
-    method_options(MANIFEST_OPTIONS)
+    
+    # Standard manifest options.  Used by build tool as well.
+    method_option :languages, :type => :string,
+      :desc => "The languages to build."
+      
+    method_option :symlink, :default => false
+    
+    method_option :buildroot, :type => :string,
+      :desc => "The path to build to."
+    method_option :stageroot, :type => :string,
+      :aliases => %w(--target -t),
+      :desc => "The path to stage to."
+    method_option :format, :type => :string
+    method_option :output, :type => :string
+    method_option :all, :type => false
+    method_option :build_numbers, :type => :string, :aliases => ['-B'],
+      :desc => "The identifier(s) for the build."
+    method_option :include_required, :default => false, :aliases => '-r',
+      :desc => "Deprecated. All builds build dependencies."
+      
+    
     method_option :entries, :type => :string
-    method_option :clean,   :type => :boolean, :aliases => "-c"
-    # This is defined in MANIFEST_OPTIONS but I add the aliases here only since we use target elsewhere
-    method_option :buildroot, :type => :string, :aliases => %w(--target -t)
+    method_option :whitelist, :type => :string,
+      :desc => "The whitelist to use when building. By default, Whitelist (if present)"
+    method_option :blacklist, :type => :string,
+      :desc => "The blacklist to use when building. By default, Blacklist (if present)"
+    method_option :accept, :type => :string,
+      :desc => "The SproutCore Accept file to determine which files to include. By default, Accept (if present)"
+    method_option :allow_commented_js, :type => :boolean,
+      :desc => "If supplied, commented JS will be allowed into the build."
     def build(*targets)
+      if options.help
+        help('build')
+        return
+      end
+
       t1 = Time.now
       SC.logger.info  'Starting build process...'
       # Copy some key props to the env
+      SC.env.whitelist_name = options.whitelist
+      SC.env.blacklist_name = options.blacklist
+      SC.env.accept_name    = options.accept
       SC.env.build_prefix   = options.buildroot if options.buildroot
       SC.env.staging_prefix = options.stageroot if options.stageroot
       SC.env.use_symlink    = options.symlink
-      SC.env.clean          = options.clean
 
       # Get entries option
       entry_filters = nil
       if options[:entries]
         entry_filters = options[:entries].split(',')
       end
-
+      
+      # We want Chance to clear files like sprites immediately after they're asked for, 
+      # because we'll only need them once during a build.
+      Chance.clear_files_immediately
+      
       # Get the manifests to build
-      manifests = build_manifests(*targets)
-
-      # First clean all manifests
-      # Do this before building so we don't accidentally erase already build
-      # nested targets.
-      if SC.env.clean
-        manifests.each do |manifest|
-          build_root = manifest.target.build_root
-          info "Cleaning #{build_root}"
-          FileUtils.rm_r(build_root) if File.directory?(build_root)
-
-          staging_root = manifest.target.staging_root
-          info "Cleaning #{staging_root}"
-          FileUtils.rm_r(staging_root) if File.directory?(staging_root)
-        end
-      end
-
-      # Now build entries for each manifest...
-      manifests.each do |manifest|
-
+      manifests = build_manifests(*targets) do |manifest|
+        # This is our own logic to prevent processing a manifest twice
+        next if manifest[:built_by_builder]
+        manifest[:built_by_builder] = true
+        
         # get entries.  If "entries" option was specified, use to filter
         # filename.  Must match end of filename.
         entries = manifest.entries
@@ -71,24 +92,49 @@ module SC
         end
 
         # if there are entries to build, log and build
-        if entries.size > 0
-          info "Building entries for #{manifest.target.target_name}:#{manifest.language}..."
-
-          target_build_root = Pathname.new(manifest.target.project.project_root)
-          entries.each do |entry|
-            dst = Pathname.new(entry.build_path).relative_path_from(target_build_root)
-            info "  #{entry.filename} -> #{dst}"
-            entry.build!
-          end
-
-        end
+        build_entries_for_manifest manifest, options.allow_commented_js
+        
+        # Build dependencies
+        target = manifest.target
+        required = target.expand_required_targets :theme => true,
+          :debug => target.config.load_debug,
+          :tests => target.config.load_tests,
+ 
+          # Modules are not 'required' technically, as they may be loaded
+          # lazily. However, we want to know all targets that should be built,
+          # so we'll include modules as well.
+          :modules => true
+
+        
+        required.each {|t| 
+          m = t.manifest_for (manifest.variation)
+          
+          
+          # And, yes, the same as above. We're just building entries for all required targets.
+          # We're also going to mark them as fully-built so they don't get built again.
+          next if m[:built_by_builder]
+          m[:built_by_builder] = true
+          m.build!
+          
+          build_entries_for_manifest m, options.allow_commented_js
+          
+          
+        }
+        
+        # Clean up
+        manifest.reset!
+        Chance::ChanceFactory.clear_instances
       end
 
-      if $to_html5_manifest.length > 0
-        $to_html5_manifest.each do |entry|
-          SC::Helpers::HTML5Manifest.new.build(entry)
-        end
-      end
+      # The HTML5 manifest generator does not work properly; it is unstable (can cause crashes)
+      # and won't pick up modules. We need an alternative implemenation, preferably one that uses
+      # Abbot's own manifests to figure out what files are required. This is non-trivial, however.
+      #
+      # if $to_html5_manifest.length > 0
+      #   $to_html5_manifest.each do |entry|
+      #     SC::Helpers::HTML5Manifest.new.build(entry)
+      #   end
+      # end
 
       SC::Helpers::Minifier.wait
 
@@ -98,5 +144,7 @@ module SC
       seconds = seconds%60
       puts 'Build time '+minutes.floor.to_s+ ' minutes '+seconds.floor.to_s+' secs'
     end
+    
   end
+
 end

data/lib/sproutcore/tools/gen.rb

@@ -50,12 +50,11 @@ module SC
     desc "gen generator Namespace[.ClassName] [--target=TARGET_NAME] [--filename=FILE_NAME]",
       "Generates SproutCore components"
 
-    method_options(
-      MANIFEST_OPTIONS.merge(:help       => :string,
+    method_options(:help       => :string,
                              :filename   => :string,
                              :target     => :string,
                              '--dry-run' => false,
-                             :force      => false))
+                             :force      => false)
 
     def gen(*arguments)
       return show_help if arguments.empty?

data/lib/sproutcore/tools/manifest.rb

@@ -8,23 +8,29 @@
 module SC
   class Tools
 
-    # Standard manifest options.  Used by build tool as well.
-    MANIFEST_OPTIONS = { :symlink           => false,
-                         :stageroot         => :string,
-                         :format            => :string,
-                         :output            => :string,
-                         :all               => false,
-                         :buildroot         => :string,
-                         ['--languages', '-L']              => :string,
-                         ['--build-numbers', '-B']          => :string,
-                         ['--include-required', '-r']       => false }
-
     desc "manifest [TARGET..]", "Generates a manifest for the specified targets"
-    method_options(MANIFEST_OPTIONS.merge(
-      :format        => :string,
-      :only          => :string,
-      :except        => :string,
-      :hidden        => false ))
+    
+    # Standard manifest options.  Used by build tool as well.
+    method_option :languages, :type => :string,
+      :desc => "The languages to build."
+    method_option :symlink, :default => false
+    method_option :buildroot, :type => :string,
+      :desc => "The path to build to."
+    method_option :stageroot, :type => :string,
+      :desc => "The path to stage to."
+    method_option :format, :type => :string
+    method_option :output, :type => :string
+    method_option :all, :type => false
+    
+    method_option :build_numbers, :type => :string, :aliases => ['-B'],
+      :desc => "The identifier(s) for the build."
+    method_option :include_required, :default => false, :aliases => '-r',
+      :desc => "Deprecated. All builds build dependencies."
+      
+    method_option :format => :string
+    method_option :only => :string
+    method_option :except => :string
+    method_option :hidden => false
     def manifest(*targets)
 
       # Copy some key props to the env

data/lib/sproutcore/tools/server.rb

@@ -16,11 +16,32 @@ module SC
                     :host       => :string,
                     :irb        => false,
                     :filesystem => true
+    
+    method_option :whitelist, :type => :string,
+      :desc => "The whitelist to use when building. By default, Whitelist (if present)"
+    method_option :blacklist, :type => :string,
+      :desc => "The blacklist to use when building. By default, Blacklist (if present)"
+    method_option :accept, :type => :string,
+      :desc => "The SproutCore Accept file to determine which files to include. By default, Accept (if present)"
+
+    
+    method_option :allow_from_ips,
+      :default => "127.0.0.1",
+      :desc => "One or more (comma-separated) masks to accept requests from. " +
+        "For example: 10.*.*.*,127.0.0.1"
     def server
+      if options.help
+        help('server')
+        return
+      end
+      
       prepare_mode!('debug') # set mode again, using debug as default
 
       SC.env[:build_prefix]   = options[:buildroot] if options[:buildroot]
       SC.env[:staging_prefix] = options[:stageroot] if options[:stageroot]
+      SC.env[:whitelist_name] = options.whitelist
+      SC.env[:blacklist_name] = options.blacklist
+      SC.env[:accept_name]    = options.accept
 
       # get project and start service.
       project = requires_project!

data/lib/sproutcore/tools.rb

@@ -32,17 +32,27 @@ module SC
 
     # All sproutcore tools can take some standard options.  These are
     # processed automatically when the tool is loaded
-    class_option "project",           :type => :string
-    class_option "mode",              :type => :string
-    class_option "logfile",           :type => :string
-    class_option "build",             :type => :string, :aliases => "-b"
-    class_option "build-targets",     :type => :string
-    class_option "yui-minification",  :type => :boolean
-    class_option "dont-minify",       :type => :boolean
-    class_option "verbose",           :type => :boolean, :aliases => "-v"
-    class_option "very-verbose",      :type => :boolean, :aliases => "-V"
-    class_option "library",           :type => :string #deprecated
-    class_option "environment",       :type => :string #deprecated
+    class_option "project",      :type => :string
+    class_option "mode",         :type => :string
+    class_option "logfile",      :type => :string
+    class_option "build",        :type => :string, :aliases => "-b"
+    class_option "build-targets",:type => :string,
+      :desc => "Targets to build (excluding their dependencies)"
+    
+    class_option "yui-minification",     :type => :boolean,
+      :desc => "Deprecated. Does nothing."
+    
+    class_option "dont-minify",     :type => :boolean,
+      :desc => "Disables minification for the build."
+    
+    class_option "verbose",      :type => :boolean, :aliases => "-v"
+    class_option "very-verbose", :type => :boolean, :aliases => "-V"
+    
+    class_option "library",      :type => :string, #deprecated
+      :desc => "Deprecated."
+    class_option "environment",  :type => :string, #deprecated
+      :desc => "Deprecated."
+    class_option "help",         :type => :boolean
 
     default_task :banner
 
@@ -199,6 +209,20 @@ module SC
           end
         end
 
+        # This is the root project, so we must also load the "include targets" used to
+        # make additional frameworks available to SC apps.
+        SC.include_targets.each {|target|
+          target_path = File.expand_path target[:path]
+          target_name = File.join "/", target[:name]
+
+          # Note: target names must begin with / to be valid.
+          t = ret.add_target target_name, :framework, { :source_root => target_path }
+
+          if t.config[:allow_nested_targets]
+            ret.find_targets_for(target_path, target_name, t.config)
+          end
+        }
+
         info "Loaded project at: #{ret.project_root}" unless ret.nil?
         @project = ret
       end
@@ -269,26 +293,6 @@ module SC
           targets = tar
         end
 
-        # If include required was specified, merge in all required bundles as
-        # well. Note that we do this whether --build-targets is specified or not.
-        if options[:'include-required']
-          tar = targets.clone
-          targets.each do |target|
-            required = target.expand_required_targets :theme => true,
-             :debug => target.config.load_debug,
-             :tests => target.config.load_tests
-
-            required.each {|t| 
-              t.config[:minify_javascript] = false if not targets.include? t
-            }
-
-            tar += required
-          end
-
-          targets = tar.flatten.uniq.compact
-        end
-
-
         targets
 
       end
@@ -342,35 +346,87 @@ module SC
           SC.logger.info "Using build numbers: #{numbers.map { |k,v| "#{k}: #{v}" }.join(',')}"
         end
       end
-
-      # Core method to process command line options and then build a manifest.
-      # Shared by sc-manifest, sc-build and sc-docs commands.
-      def build_manifests(*targets)
-
+      
+      def each_manifest_for_targets(*targets)
         # setup build numbers
         find_build_numbers(*targets)
 
         requires_project! # get project
+        
         targets = find_targets(*targets) # get targets
-        languages = find_languages(*targets) # get languages
 
         # log output
         SC.logger.info "Building targets: #{targets.map { |t| t.target_name } * ","}"
+        
+        languages = find_languages(*targets) # get languages
         SC.logger.info "Building languages: #{ languages * "," }"
+        
+        index = 1
+        count = targets.length * languages.length
+        SC.logger.info "Total target/language combinations to build: #{count}"
+        
+        targets.each {|target|
+          languages.each {|l|
+            manifest = target.manifest_for :language => l
+            SC.logger.info "Creating manifest #{index} of #{count} for: #{manifest.target.target_name}:#{manifest.language}"
+            
+            yield manifest
+            
+            index += 1
+          }
+        }
+        
+      end
 
-        # Now fetch the manifests to build.  One per target/language
-        manifests = targets.map do |target|
-          languages.map { |l| target.manifest_for :language => l }
-        end
-        manifests.flatten!
-
+      # Core method to process command line options and then build a manifest.
+      # Shared by sc-manifest, sc-build and sc-docs commands.
+      def build_manifests(*targets)
         # Build'em
-        manifests.each do |manifest|
-          SC.logger.info "Building manifest for: #{manifest.target.target_name}:#{manifest.language}"
+        each_manifest_for_targets(*targets) do |manifest|
           manifest.build!
+          
+          yield manifest
         end
+      end
+      
+      # Loops over all of the manifest's entries and builds all essential entries.
+      # Entries such as javascript.js are considered non-essential because they will
+      # not actually be used in a fully built app (except for modules).
+      #
+      # It also does a check to ensure that all JS being written is minified.
+      def build_entries_for_manifest(manifest, allow_comments)
+        if manifest.entries.size > 0
+          target = manifest.target
+          info "Building entries for #{target.target_name}:#{manifest.language}..."
+
+          # we ONLY generate non-packed javascript.js files for modules, which may need
+          # to lazily load them. Otherwise: NOPE!
+          generate_javascript = false
+          if target[:target_type] === :module
+            generate_javascript = true
+          end
 
-        return manifests
+          target_build_root = Pathname.new(manifest.target.project.project_root)
+          manifest.entries.each do |entry|
+            # Skip combined JS when it is a target that doesn't need it.
+            # We can't just skip all non-packed JS, because you can use sc_resource to split
+            # the JS out, and that won't work properly. :combine, likewise, is used for sc_resource.
+            # So, we skip the entry IF it is javascript.js--because that is how the pack task itself
+            # knows the difference.
+            next if not generate_javascript and entry[:filename] == 'javascript.js'
+
+            # For security, skip AND WARN about files which are not minified
+            if not SC.env[:dont_minify] and not allow_comments and entry[:entry_type] == :javascript and not entry[:minified]
+              SC.logger.fatal "SECURITY: Entry not minified: #{entry[:filename]}; target: #{target[:target_name]}"
+              SC.logger.fatal "All entries must be minified in a final build UNLESS --allow-commented-js argument is supplied."
+              exit(1)
+            end
+
+            dst = Pathname.new(entry.build_path).relative_path_from(target_build_root)
+            info "  #{entry.filename} -> #{dst}"
+            entry.build!
+          end
+        end
       end
 
       # Logs the contents of the passed file path to the logger

data/lib/sproutcore.rb

@@ -47,7 +47,12 @@ module SproutCore
   # where you will find the build mode among other things set by sc-build.
   #
   def self.env
-    @env ||= HashStruct.new(:build_mode => :debug, :buildfile_names => %w(Buildfile sc-config sc-config.rb))
+    @env ||= HashStruct.new(
+      :build_mode => :debug,
+      :buildfile_names => %w(Buildfile sc-config sc-config.rb),
+      :whitelist_name => "Whitelist",
+      :blacklist_name => "Blacklist"
+    )
   end
   def self.env=(hash); @env = HashStruct.new(hash); end
 
@@ -116,10 +121,30 @@ module SproutCore
     end
   end
 
-  def self.yui_jar
-    @yui_jar ||= begin
-      yui_root = File.expand_path("../../vendor/sproutcore/lib", __FILE__)
-      File.join(yui_root, 'yuicompressor-2.4.6.jar')
+  # Additional targets to be included in the project. Each item is a hash
+  # with :path and :name attributes
+  def self.include_targets
+    @include_targets ||= []
+  end
+
+  # Adds a target to be included in the project SproutCore builds.
+  #
+  # This is useful to make additional frameworks available to SproutCore apps.
+  def self.include_target(target_name, target_path)
+    include_targets << { :name => target_name, :path => target_path }
+  end
+
+  def self.html_jar
+    @html_jar ||= begin
+      yui_root = File.expand_path("../../vendor/sproutcore", __FILE__)
+      File.join(yui_root, 'SCCompiler.jar')
+    end
+  end
+  
+  def self.js_jar
+    @js_jar ||= begin
+      yui_root = File.expand_path("../../vendor/sproutcore", __FILE__)
+      File.join(yui_root, 'lib/yuicompressor-2.4.6.jar')
     end
   end
 

data/spec/buildtasks/helpers/accept_list

@@ -0,0 +1,22 @@
+TARGET /target1/abc
+file[0-9].js
+
+DENY
+# This will deny the files we don't want, and one we do
+file[2-9].js
+
+# This will add one back
+allow file4.js
+
+# this will remove it again
+file4.js
+
+# And finally, add back the one we want.
+ALLOW
+file2.js
+
+
+TARGET /target1/def
+allow all
+
+deny file2.js

data/spec/buildtasks/helpers/accept_list.rb

@@ -0,0 +1,128 @@
+require "spec_helper"
+
+WHITELIST_PATH = File.dirname(__FILE__) + '/list.json'
+ACCEPT_LIST_PATH = File.dirname(__FILE__) + '/accept_list'
+
+
+module FileRuleListSpec
+  class YesRule
+    def include?(f)
+      true
+    end
+  end
+  
+  class NoRule
+    def include?(f)
+      false
+    end
+  end
+end
+
+describe "FileRuleList" do
+  it "includes if ignore_list has not been unset" do
+    list = SproutCore::FileRuleList.new
+    list.include?("target1", "some_file.js").should be_true
+  end
+  
+  it "does not include when there are no rules" do
+    list = SproutCore::FileRuleList.new
+    list.ignore_list = false
+    list.include?("target1", "some_file.js").should be_false
+  end
+  
+  it "includes when there is an allow rule" do
+    list = SproutCore::FileRuleList.new
+    list.add_rule("target1", FileRuleListSpec::YesRule.new)
+    list.include?("target1", "some_file.js").should be_true
+  end
+  
+  it "does not include when there is both a yes and a no rule" do
+    list = SproutCore::FileRuleList.new
+    list.add_rule("target1", FileRuleListSpec::YesRule.new)
+    list.add_rule("target1", FileRuleListSpec::NoRule.new)
+    list.include?("target1", "some_file.js").should be_false
+  end
+  
+  it "includes when there is a yes rule, followed by a no, followed by a yes" do
+    list = SproutCore::FileRuleList.new
+    list.add_rule("target1", FileRuleListSpec::YesRule.new)
+    list.add_rule("target1", FileRuleListSpec::NoRule.new)
+    list.add_rule("target1", FileRuleListSpec::YesRule.new)
+    list.include?("target1", "some_file.js").should be_true
+  end
+  
+  it "maintains separate lists for each target" do
+    list = SproutCore::FileRuleList.new
+    list.add_rule("target1", FileRuleListSpec::YesRule.new)
+    list.add_rule("target2", FileRuleListSpec::NoRule.new)
+    list.include?("target1", "some_file.js").should be_true
+    list.include?("target2", "some_file.js").should be_false
+  end
+  
+  it "obeys allow_by_default" do
+    list = SproutCore::FileRuleList.new
+    list.allow_by_default = true
+    list.include?("target1", "some_file.js").should be_true
+  end
+  
+  it "always allows the ALWAYS_ACCEPTED_FILE_TYPES, no matter what" do
+    list = SproutCore::FileRuleList.new
+    list.add_rule("target1", FileRuleListSpec::NoRule.new)
+    
+    [
+      '.manifest',
+      '.htm',
+      '.html',
+      '.rhtml',
+      '.png',
+      '.jpg',
+      '.jpeg',
+      '.gif'
+    ].each {|name|
+      list.include?("target1", "a_file#{name}").should be_true
+    }
+    
+    list.include?("target1", "some_file.js").should be_false
+  end
+    
+  
+
+  
+  describe "#read_json" do
+    it "reads in allow mode properly" do
+      list = SproutCore::FileRuleList.new
+      list.read_json(WHITELIST_PATH, :allow)
+      
+      list.include?("/target1/abc", "file1.js").should be_true
+      list.include?("/target1/abc", "file3.js").should be_false
+      list.include?("/target1/def", "file2.js").should be_false
+      list.include?("/target1/def", "file4.js").should be_true
+    end
+    
+    it "reads in deny mode properly" do
+      list = SproutCore::FileRuleList.new
+      list.allow_by_default = true
+      list.read_json(WHITELIST_PATH, :deny)
+      
+      list.include?("/target1/abc", "file1.js").should be_false
+      list.include?("/target1/abc", "file3.js").should be_true
+      list.include?("/target1/def", "file2.js").should be_true
+      list.include?("/target1/def", "file4.js").should be_false
+    end
+  end
+  
+  describe "#read" do
+    it "reads the list properly" do
+      list = SproutCore::FileRuleList.new
+      list.read(ACCEPT_LIST_PATH)
+      
+      list.include?("/target1/abc", "file1.js").should be_true
+      list.include?("/target1/abc", "file3.js").should be_false
+      
+      # Target1/def denies exactly one file: file2.js. Everything else is allowed.
+      list.include?("/target1/def", "file2.js").should be_false
+      list.include?("/target1/def", "fadjfhakljdf.js").should be_true
+    end
+  end
+end
+

data/spec/buildtasks/helpers/list.json

@@ -0,0 +1,11 @@
+{
+  "/target1/abc": [
+    "file1.js",
+    "file2.js"
+  ],
+  
+  "/target1/def": [
+    "file3.js",
+    "file4.js"
+  ]
+}