sproutcore 1.6.0.1-java → 1.7.1.beta-java

data/lib/sproutcore/rack/restrict_ip.rb

@@ -0,0 +1,67 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009-2011 Apple Inc.
+#            portions copyright @2006-2011 Strobe Inc.
+#            and contributors
+# ===========================================================================
+
+# For all those working in internet cafes...
+# We feel for you. Go to a real cafe instead. They have internet, too.
+module SC
+  module Rack
+    class RestrictIP
+      def initialize(app, allow_ips=[])
+        @app = app
+        @allow = allow_ips
+      end
+      
+      # checks if an IP, such as 127.0.0.1, matches a mask, such as 127.*.*.*
+      def ip_is_valid(ip, mask)
+        ip_parts = ip.split('.')
+        mask_parts = mask.split('.')
+        
+        if mask_parts.length != 4
+          SC.logger.fatal "Invalid IP mask: #{mask}\n"
+          exit
+        end
+        
+        ip_idx = 0
+        mask_parts.each {|mask_part|
+          ip_part = ip_parts[ip_idx]
+          
+          # * means anything matches
+          if mask_part == '*'
+            next
+          end
+          
+          if ip_part != mask_part
+            return false
+          end
+          
+          ip_idx = ip_idx + 1
+        }
+        
+        return true
+      end
+    
+      def call(env)
+        ip = env['REMOTE_ADDR']
+        
+        is_valid = false
+        @allow.each {|mask|
+          if ip_is_valid(ip, mask)
+            is_valid = true
+            break
+          end
+        }
+        
+        if is_valid
+          return @app.call(env)
+        else
+          SC.logger << "Blocked connection attempt by ip: #{ip}\n"
+          return [403, { 'Content-Type' => 'text/plain' }, "YOU CANNOT BEEZ HERE."]
+        end
+      end
+    end
+  end
+end

data/lib/sproutcore/rack/service.rb

@@ -59,7 +59,7 @@ module SC
         self.filesystem = opts[:Filesystem]
 
         projects = opts.delete(:projects) || [opts.delete(:project)].compact
-        app = self.new(*projects)
+        app = self.new(*projects, opts)
 
         opts[:Host] ||= opts[:host] # allow either case.
         opts[:Port] ||= opts[:port] || '4020'
@@ -93,7 +93,7 @@ module SC
         server.run app, opts
       end
 
-      def initialize(*projects)
+      def initialize(*projects, opts)
         @projects = projects.flatten
 
         # Get apps for each project & cascade if needed
@@ -105,6 +105,12 @@ module SC
         @app = ::Rack::ConditionalGet.new(@app)
         #@app = ::Rack::Deflater.new(@app)
 
+        # preprocess IPs so we can restrict properly
+        ips = opts[:allow_from_ips] || '127.0.0.1'
+        SC.logger << "Allowing access only from IPs: #{ips}. Use --allow-from-ips='*.*.*.*' to allow all\n"
+        ips = ips.split(',')
+
+        @app = SC::Rack::RestrictIP.new(@app, ips)
       end
 
       def call(env); @app.call(env); end

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/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