sproutcore 1.0.1046 → 1.0.1049.pre.1

data/lib/sproutcore/rack/service.rb

@@ -9,14 +9,14 @@ module SC
   module Rack
 
     # Configures a standard set of Rack adaptors for serving SproutCore apps.
-    # Based on your config settings, this will configure appropriate 
+    # Based on your config settings, this will configure appropriate
     # middlewear apps for each incoming project.  Requests are then cascaded
     # through the projects to find one that can service the request.
     #
     class Service
-      
+
       cattr_accessor :filesystem
-      
+
       # Convenience method to start the rack service as a server.  You must
       # pass at least a :project => foo, or :projects => [foo, bar] option
       # to this method, but you may also pass a number of other config optios
@@ -29,7 +29,7 @@ module SC
       #  :pid:: if daemonizing, this is the path of the file to write pid to
       #
       def self.start(opts = {})
-        
+
         # load rack
         begin
           require 'rack'
@@ -37,7 +37,7 @@ module SC
           gem 'rack'
           require 'rack'
         end
-        
+
         # Guess.
         if ENV.include?("PHP_FCGI_CHILDREN")
           server = ::Rack::Handler::FastCGI
@@ -58,21 +58,21 @@ module SC
             end
           end
         end
-        
+
         opts[:Filesystem] ||= opts[:filesystem] || false # allow either case
         self.filesystem = opts[:Filesystem]
-        
+
         projects = opts.delete(:projects) || [opts.delete(:project)].compact
         app = self.new(*projects)
-        
+
         opts[:Host] ||= opts[:host] # allow either case.
         opts[:Port] ||= opts[:port] || '4020'
-        
+
         # If daemonize is set, do it...
         if opts[:daemonize]
           SC.logger.info "Daemonizing..."
           pid = opts[:pid]
-          
+
           if RUBY_VERSION < "1.9"
             return if fork
             Process.setsid
@@ -91,12 +91,12 @@ module SC
             at_exit { File.delete(pid) if File.exist?(pid) }
           end
         end
-        
+
         SC.logger << "Starting server at http://#{opts[:Host] || '0.0.0.0'}:#{opts[:Port]} in #{SC.build_mode} mode\n"
         SC.logger << "To quit sc-server, press Control-C\n"
         server.run app, opts
       end
-        
+
       def initialize(*projects)
         @projects = projects.flatten
 
@@ -108,48 +108,50 @@ module SC
         @app = ::Rack::Recursive.new(@app)
         @app = ::Rack::ConditionalGet.new(@app)
         #@app = ::Rack::Deflater.new(@app)
-        
+
       end
-      
+
       def call(env); @app.call(env); end
-      
+
       # Construct new middleware for the named project
       def middleware_for(project)
         apps = []
 
         # setup some conditional items...
         config = project.config
-        #if config.serve_test_runner || config.serve_docs
-          apps << SC::Rack::Dev.new(project) 
-        #end
-        if project.buildfile.proxies.size > 0
-          apps << SC::Rack::Proxy.new(project) 
-        end
 
-        # Add builder for the project itself
-        apps  << SC::Rack::Builder.new(project)
-        
-        # serve files out of the public directory if serve_public is 
+        # serve files out of the public directory if serve_public is
         # configures && the public directory exists
-        if config.serve_public
+        if config[:serve_public]
           pubdir = File.join(project.project_root, 'public')
           apps  << ::Rack::File.new(pubdir) if File.directory?(pubdir)
         end
-        
+
         if self.filesystem
           apps << SC::Rack::Filesystem.new(project)
         end
-        
+
+        #if config.serve_test_runner || config.serve_docs
+          apps << SC::Rack::Dev.new(project)
+        #end
+
+        # Add builder for the project itself
+        apps  << SC::Rack::Builder.new(project)
+
+        if project.buildfile.proxies.size > 0
+          apps << SC::Rack::Proxy.new(project)
+        end
+
         # Wrap'em in a cascade if needed.  This will return the first
         # app that does not return nil
-        app = apps.size == 1 ? apps.first : ::Rack::Cascade.new(apps) 
-        
+        app = apps.size == 1 ? apps.first : ::Rack::Cascade.new(apps)
+
         # Add show exceptions handler if enabled
-        app = ::Rack::ShowExceptions.new(app) if config.serve_exceptions
-        
+        app = ::Rack::ShowExceptions.new(app) if config[:serve_exceptions]
+
         return app # done!
       end
-      
+
     end
   end
-end
+end

data/lib/sproutcore/rack/test_runner.rb

@@ -8,17 +8,17 @@
 module SC
   module Rack
 
-    # Rewrites relevant requests to load the SproutCore test runner for a 
+    # Rewrites relevant requests to load the SproutCore test runner for a
     # given project.
     class TestRunner
-      
+
       def initialize(project)
         @project = project
       end
-      
+
       def call(env)
         return [404, {}, "not found"]
       end
     end
   end
-end
+end

data/lib/sproutcore/render_engines/erubis.rb

@@ -19,7 +19,7 @@ module SC
         rescue
           raise "Cannot render ERB file because erubis is not installed. Try running 'sudo gem install erubis' and try again"
         end
-        
+
         ::Erubis::Eruby.new.convert(input)
       end
 
@@ -33,7 +33,7 @@ module SC
         rescue
           buffer = nil
         end
-        
+
         if buffer.nil?
           block.call(*args).to_s
         else

data/lib/sproutcore/render_engines/haml.rb

@@ -21,11 +21,11 @@ module SC
         end
         ::Haml::Engine.new(input).send(:precompiled_with_ambles, [])
       end
-      
+
       def concat(string, binding)
         eval("_hamlout", binding).push_text string
       end
-      
+
       def capture(*args, &block)
         if @html_context.respond_to?(:is_haml?) && @html_context.is_haml?
           @html_context.capture_haml(nil, &block)

data/lib/sproutcore/tools.rb

@@ -13,109 +13,106 @@ module SC
   # available from SproutCore. In general, each command line tool has a peer
   # class hosted in this module that implements the primary user interface.
   #
-  # Internally SproutCore tools that chain together subtools (such as 
+  # Internally SproutCore tools that chain together subtools (such as
   # sc-build) will actually call these classes directly instead of taking the
-  # time to instantiate a whole new process. 
+  # time to instantiate a whole new process.
   #
-  # Each Tool class is implemented as a Thor subclass.  You can override 
-  # methods in these classes in your own ruby code if you want to make a 
+  # Each Tool class is implemented as a Thor subclass.  You can override
+  # methods in these classes in your own ruby code if you want to make a
   # change to how these tools execute.  Any ruby you place in your Buildfile
-  # to modify one of these classes will actually be picked up by the 
+  # to modify one of these classes will actually be picked up by the
   # tool itself when it runs.
   #
   class Tools < ::Thor
+    check_unknown_options!
 
     def self.invoke(task_name)
       start([task_name.to_s] + ARGV)
     end
 
-    
-    # All sproutcore tools can take some standard options.  These are 
+    # All sproutcore tools can take some standard options.  These are
     # processed automatically when the tool is loaded
-    method_options({ '--project'        => :string,
-                     '--library'        => :string, # deprecated
-                     '--mode'           => :string,
-                     '--environment'    => :string, # deprecated
-                     '--logfile'        => :string,
-                     '--build'          => :string,
-                     ['--verbose', '-v']      => false,
-                     ['--very-verbose', '-V'] => false })
-    def initialize(options, *args)
+    class_option "project",      :type => :string
+    class_option "mode",         :type => :string
+    class_option "logfile",      :type => :string
+    class_option "build",        :type => :string
+    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
+
+    # This is the core entry method used to run every tool.  Extend this
+    # method with any standard preprocessing you want all tools to do before
+    # they do their specific thing.
+    def initialize(*)
       super
+      prepare_logger!
+      prepare_mode!
+      prepare_build_numbers!
     end
 
-    no_tasks do 
+    no_tasks do
 
       ################################################
       ## EXCEPTIONS
       ##
-    
+
       # Raise this type of exception when a fatal error occurs because the
-      # user did not pass the correct options.  This will be caught and 
-      # displayed at the top level before exiting.  Note that if you raise 
-      # an exception of some other type, then a backtrace may be displayed as 
+      # user did not pass the correct options.  This will be caught and
+      # displayed at the top level before exiting.  Note that if you raise
+      # an exception of some other type, then a backtrace may be displayed as
       # well (Which is not preferred)
       class FatalException < Exception
       end
-    
-      # Helper method.  Call this when an acception occurs that is fatal due 
+
+      # Helper method.  Call this when an acception occurs that is fatal due
       # to a problem with the user.
       def fatal!(description)
         raise FatalException, description
       end
-    
-      # Helper method.  Call this when you want to log an info message.  Logs 
+
+      # Helper method.  Call this when you want to log an info message.  Logs
       # to the standard logger.
       def info(description)
         SC.logger.info(description)
       end
-    
+
       # Helper method.  Call this when you want to log a debug message.
       def debug(description)
         SC.logger.debug(description)
       end
-    
+
       # Log this when you need to issue a warning.
       def warn(description)
         SC.logger.warn(description)
       end
-    
+
       ################################################
-      ## GLOBAL OPTIONS 
+      ## GLOBAL OPTIONS
       ##
-    
-      # This is the core entry method used to run every tool.  Extend this
-      # method with any standard preprocessing you want all tools to do before
-      # they do their specific thing.
-      def invoke(*args)
-        prepare_logger!
-        prepare_mode!
-        prepare_build_numbers!
-        super
-      end
-      
+
       # Make the options hash a HashStruct so that we can access each variable
       # as a method
       def options; @tool_options ||= HashStruct.new(super); end
-    
-      # Configure the expected log level and log target.  Handles the 
+
+      # Configure the expected log level and log target.  Handles the
       # --verbose, --very-verbose and --logfile options
       def prepare_logger!
-        SC.env.log_level = options['very-verbose'] ? :debug : (options.verbose ? :info : :warn)
-        SC.env.logfile = File.expand_path(options.logfile) if options.logfile
+        SC.env[:log_level] = options[:'very-verbose'] ? :debug : (options[:verbose] ? :info : :warn)
+        SC.env[:logfile] = File.expand_path(options[:logfile]) if options[:logfile]
       end
 
-      # Configure the current build mode.  Handles the --mode and 
-      # --environment options.  (--environment is provided for backwards 
+      # Configure the current build mode.  Handles the --mode and
+      # --environment options.  (--environment is provided for backwards
       # compatibility)
       def prepare_mode!(preferred_mode = 'production')
-        build_mode = (options.mode || options.environment || preferred_mode).to_s.downcase.to_sym
+        build_mode = (options[:mode] || options[:environment] || preferred_mode).to_s.downcase.to_sym
         SC.build_mode = build_mode
       end
 
       # Configure the current build numbers.  Handles the --build option.
       def prepare_build_numbers!
-        return unless (numbers = options.build)
+        return unless (numbers = options[:build])
         numbers = numbers.split(',').map { |n| n.split(':') }
         if numbers.size==1 && numbers.first.size==1
           SC.env.build_number = numbers.first.first
@@ -130,36 +127,36 @@ module SC
       end
 
       ################################################
-      ## HELPER METHODS 
+      ## HELPER METHODS
       ##
-    
+
       # Set the current project.  This is used mostly for unit testing.
       def project=(a_project)
         @project = a_project
       end
-    
+
       def set_test_project(a_project)
         @project = a_project
         @discovered_project = true
       end
-      
+
       # The current project.  This is discovered based on the passed --project
-      # option or based on the current working directory.  If no project can 
+      # option or based on the current working directory.  If no project can
       # be found, this method will always return null.
       def project
         return @project if @discovered_project # cache - @project may be nil
         @discovered_project = true
 
         ret = nil
-        project_path = options.project || options.library
+        project_path = options[:project] || options[:library]
 
         # if no project_path is named explicitly, attempt to autodiscover from
         # working dir.  If none is found, just set project to nil
         unless project_path
           debug "No project path specified.  Searching for projects in #{Dir.pwd}"
           ret = SC::Project.load_nearest_project Dir.pwd, :parent => SC.builtin_project
-        
-        # if project path is specified, look there.  If no project is found 
+
+        # if project path is specified, look there.  If no project is found
         # die with a fatal exception.
         else
           debug "Project path specified at #{project_path}"
@@ -168,33 +165,33 @@ module SC
             fatal! "Could not load project at #{project_path}"
           end
         end
-      
+
         info "Loaded project at: #{ret.project_root}" unless ret.nil?
         @project = ret
       end
-       
+
       # Attempts to discover the current project.  If no project can be found
-      # throws a fatal exception.  Use this method at the top of your tool 
+      # throws a fatal exception.  Use this method at the top of your tool
       # method if you require a project to run.
       def requires_project!
         ret = project
         if ret.nil?
           fatal!("You do not appear to be inside of a project.  Try changing to your project directory or make sure your project as a Buildfile or sc-config")
         end
-        return ret 
+        return ret
       end
-      
-      # Find one or more targets with the passed target names in the current 
+
+      # Find one or more targets with the passed target names in the current
       # project.  Requires a project to function.
       def find_targets(*targets)
-      
+
         debug "finding targets with names: '#{targets * "','"}'"
         requires_project!
-      
-        # Filter out any empty target names.  Sometimes this happens when 
+
+        # Filter out any empty target names.  Sometimes this happens when
         # processing arguments.
         targets.reject! { |x| x.nil? || x.size == 0 }
-      
+
         # If targets are specified, find the targets project or parents...
         if targets.size > 0
           targets = targets.map do |target_name|
@@ -204,7 +201,7 @@ module SC
               SC.logger.fatal("Exception when searching for target #{target_name}.  Perhaps your Buildfile is configured wrong?")
               raise e
             end
-          
+
             if ret.nil?
               fatal! "No target named #{target_name} could be found in PROJECT:#{project.project_root}"
             else
@@ -212,7 +209,7 @@ module SC
             end
             ret
           end
-        
+
         # IF no targets are specified, then just get all targets in project.
         # If --all option was specified, include those that do not autobuild
         else
@@ -220,47 +217,47 @@ module SC
           unless options.all?
             targets.reject! { |t| !t.config.autobuild? }
           end
-        end 
+        end
 
-        # If include required was specified, merge in all required bundles as 
+        # If include required was specified, merge in all required bundles as
         # well.
-        if options['include-required']
-          targets.each do |target| 
+        if options[:'include-required']
+          targets.each do |target|
             targets += target.expand_required_targets :theme => true,
              :debug => target.config.load_debug,
              :tests => target.config.load_tests
           end
-        
+
           targets = targets.flatten.uniq.compact
         end
-      
+
         return targets
       end
 
-      # Wraps around find_targets but raises an exception if no target is 
+      # Wraps around find_targets but raises an exception if no target is
       # specified.
       def requires_targets!(*target_names)
         if target_names.size == 0
-          fatal! "You must specify a target with this command" 
+          fatal! "You must specify a target with this command"
         end
 
         targets = find_targets(*target_names)
         if targets.size == 0
           fatal! "No targets matching #{target_names * ","} were found."
         end
-      
+
         targets
       end
-    
+
       # Requires exactly one target.
       def requires_target!(*targets)
         requires_targets!(*targets).first
       end
-    
+
       # Discovers the languages requested by the user for a build.  Uses the
       # --languages command line option or disovers in targets.
       def find_languages(*targets)
-        # Use passed languages.  If none are specified, merge installed 
+        # Use passed languages.  If none are specified, merge installed
         # languages for all app targets.
         unless (languages = options.languages)
           languages = targets.map { |t| t.installed_languages }
@@ -269,7 +266,7 @@ module SC
         end
         languages.flatten.uniq.compact
       end
-    
+
       # Discovers build numbers requested for the build and sets them in the
       # in the env if needed.
       def find_build_numbers(*targets)
@@ -286,14 +283,14 @@ 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)
-      
+
         # setup build numbers
         find_build_numbers(*targets)
-      
+
         requires_project! # get project
         targets = find_targets(*targets) # get targets
         languages = find_languages(*targets) # get languages
@@ -301,39 +298,39 @@ module SC
         # log output
         SC.logger.info "Building targets: #{targets.map { |t| t.target_name } * ","}"
         SC.logger.info "Building languages: #{ languages * "," }"
-      
+
         # 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!
-      
+
         # Build'em
-        manifests.each do |manifest| 
+        manifests.each do |manifest|
           SC.logger.info "Building manifest for: #{manifest.target.target_name}:#{manifest.language}"
           manifest.build!
         end
-      
+
         return manifests
       end
-    
+
       # Logs the contents of the passed file path to the logger
       def log_file(path)
-        if !File.exists?(path) 
+        if !File.exists?(path)
           warn "Could not display #{File.basename(path)} at #{File.dirname(path)} because it does not exist."
         end
         file_text = File.read(path)
         SC.logger << file_text
         SC.logger << "\n"
       end
-      
+
       ################################################
       ## MAIN ENTRYPOINT
       ##
-    
+
       # Fix start so that it treats command-name like command_name
       def self.start(args = ARGV)
-        # manually check for verbose in case we don't get far enough in 
+        # manually check for verbose in case we don't get far enough in
         # regular processing to actually set the verbose mode.
         is_verbose = %w(-v -V --verbose --very-verbose).any? { |x| args.include?(x) }
         begin
@@ -343,14 +340,21 @@ module SC
           if is_verbose && !e.kind_of?(FatalException)
             SC.logger.fatal("BACKTRACE:\n#{e.backtrace.join("\n")}\n")
           end
-          exit(1) 
+          exit(1)
         end
       end
-      
+
     end # no_tasks
-    
+
   end
-  
+
 end
 
-SC.require_all_libs_relative_to(__FILE__)
+require "sproutcore/tools/build"
+require "sproutcore/tools/build_number"
+require "sproutcore/tools/docs"
+require "sproutcore/tools/gen"
+require "sproutcore/tools/init"
+require "sproutcore/tools/manifest"
+require "sproutcore/tools/server"
+