sproutit-sproutcore 1.0.20090721145281 → 1.0.20090721145282

data/lib/sproutcore/builders/html.rb

@@ -130,7 +130,14 @@ module SC
     #  self
     #
     def compile(render_engine, input_path, content_for_key = nil)
-      content_for_key = self.default_content_for_key if content_for_key.nil?
+      
+      if content_for_key.nil?
+        if @in_partial
+          content_for_key = :_partial_ 
+        else
+          content_for_key = self.default_content_for_key 
+        end
+      end
       
       if !File.exist?(input_path)
         raise "html_builder could compile file at #{input_path} because the file could not be found" 
@@ -140,6 +147,7 @@ module SC
       @renderer = render_engine  # save for capture...
       
       input = File.read(input_path)
+      
       content_for content_for_key do
         _render_compiled_template( render_engine.compile(input) )
       end
@@ -150,6 +158,25 @@ module SC
 
     private
     
+    # Renders an entry as a partial.  This will insert the results inline
+    # instead of into a content div.
+    def render_partial(entry) 
+
+      # save off
+      old_partial = @content_for__partial_
+      old_in_partial = @in_partial
+
+      @content_for__partial_ = ''
+      @in_partial = true
+      render_entry(entry)
+      ret = @content_for__partial_
+      @content_for__partial_ = old_partial
+      @in_partial = old_in_partial
+      
+      return ret
+      
+    end
+    
     # Renders a single entry.  The entry will be staged and then its 
     # render task will be executed.
     def render_entry(entry)

data/lib/sproutcore/builders/minify.rb

@@ -33,35 +33,101 @@ module SC
     end
     
     def build_css(dst_path)
-      	yui_root = File.expand_path(File.join(LIBPATH, '..', 'vendor', 'yui-compressor'))
-	    jar_path = File.join(yui_root, 'yuicompressor-2.4.2.jar')
-	    FileUtils.mkdir_p(File.dirname(dst_path)) # make sure loc exists...
-	    filecompress = "java -jar " + jar_path + " --charset utf-8 --line-break 0 --nomunge --preserve-semi --disable-optimizations " + entry.source_path + " -o " + dst_path
-	    SC.logger.info  'Compressing CSS with YUI .... '+ dst_path
-	    SC.logger.debug `#{filecompress}`
+      yui_root = File.expand_path(File.join(LIBPATH, '..', 'vendor', 'yui-compressor'))
+      jar_path = File.join(yui_root, 'yuicompressor-2.4.2.jar')
+      FileUtils.mkdir_p(File.dirname(dst_path)) # make sure loc exists...
+      filecompress = "java -jar " + jar_path + " --charset utf-8 --line-break 0 --nomunge --preserve-semi --disable-optimizations " + entry.source_path + " -o \"" + dst_path + "\" 2>&1"
+      SC.logger.info  'Compressing CSS with YUI .... '+ dst_path
+      SC.logger.debug `#{filecompress}`
 
-	    if $?.exitstatus != 0
-	      SC.logger.fatal("!!!!YUI compressor failed, please check that your css code is valid.")
-	      SC.logger.fatal("!!!!Failed compressing CSS... "+ dst_path)
-	    end    
-	end
+      if $?.exitstatus != 0
+        _report_error(output, entry.filename, entry.source_path)
+        SC.logger.fatal("!!!!YUI compressor failed, please check that your css code is valid.")
+        SC.logger.fatal("!!!!Failed compressing CSS... "+ dst_path)
+      end
+  	end
     
     # Minify some javascript by invoking the YUI compressor.
     def build_javascript(dst_path)
       yui_root = File.expand_path(File.join(LIBPATH, '..', 'vendor', 'yui-compressor'))
       jar_path = File.join(yui_root, 'yuicompressor-2.4.2.jar')
       FileUtils.mkdir_p(File.dirname(dst_path)) # make sure loc exists...
-      filecompress = "java -jar " + jar_path + " --charset utf-8 --line-break 80 " + entry.source_path + " -o " + dst_path
-      SC.logger.info  'Compressing with YUI .... '+ dst_path
-      SC.logger.debug `#{filecompress}`
-      
+      filecompress = "java -jar " + jar_path + " --charset utf-8 --line-break 80 " + entry.source_path + " -o \"" + dst_path + "\" 2>&1"
+      SC.logger.info  'Compressing with YUI:  '+ dst_path + "..."
+
+      output = `#{filecompress}`      # It'd be nice to just read STDERR, but
+                                      # I can't find a reasonable, commonly-
+                                      # installed, works-on-all-OSes solution.
       if $?.exitstatus != 0
-        SC.logger.fatal("!!!!YUI compressor failed, please check that your js code is valid and doesn't contain reserved statements like debugger;")
+        _report_error(output, entry.filename, entry.source_path)
+        SC.logger.fatal("!!!!YUI compressor failed, please check that your js code is valid")
         SC.logger.fatal("!!!!Failed compressing ... "+ dst_path)
       end
       
     end
-    
-  end
   
+  
+    def _report_error(output, input_filename, input_filepath)
+      # The output might have some clues to what exactly was wrong, and it'll
+      # be convenient for users if we include the subset.  So we'll read the
+      # line numbers from any output lines that start with "[ERROR]" those
+      # lines, too.
+      if output
+        parsed_a_line = false
+        output.each_line { |output_line|
+          output_line = output_line.chomp
+          if (output_line =~ /^\[ERROR\] (\d+):(\d+):.*/) != nil
+            line_number = $1
+            position    = $2
+            parsed_a_line = true
+            if ( position  &&  position.to_i > 0 )
+              # Read just that line and output it.
+              # (sed -n '3{;p;q;}' would probably be faster, but not
+              # universally available)
+              line_number  = line_number.to_i
+              line_counter = 1
+              begin
+                file = File.new(input_filepath, "r")
+                outputted_line = false
+                previous_line = nil
+                while (file_line = file.gets)
+
+                  if ( line_counter == line_number )
+                    message = "YUI compressor error:  #{output_line} on line #{line_number} of #{input_filename}:\n"
+                    if !previous_line.nil?
+                      message += "        [#{line_number - 1}]  #{previous_line}"
+                    end
+                    message   += "   -->  [#{line_number}]  #{file_line}"
+                  
+                    SC.logger.error message
+                    outputted_line = true
+                    break
+                  else
+                    previous_line = file_line
+                  end
+                  line_counter += 1
+                end
+                file.close
+              rescue => err
+                SC.logger.error "Could not read the actual line from the file:  #{err}"
+              end
+            
+              if !outputted_line
+                SC.logger.error "YUI compressor error:  #{output_line}, but couldn't read that line in the input file"
+              end
+            end
+          end
+        }
+      
+        # If we didn't handle at least one line of output specially, then
+        # just output it all.
+        if !parsed_a_line
+          SC.logger.error output
+        end
+      end
+    end
+  
+
+  end
+    
 end

data/lib/sproutcore/builders/test.rb

@@ -48,7 +48,8 @@ module SC
     # conflict with any others.
     def render_jstest(entry)
       lines = readlines(entry.staging_path)
-      lines.unshift %[<script type="text/javascript">\nif (typeof SC !== "undefined") SC.mode = "TEST_MODE";\n(function() {\n]
+      pathname = entry.staging_path.gsub(/^.+\/staging\//,'').gsub(/"/, '\"')
+      lines.unshift %[<script type="text/javascript">\nif (typeof SC !== "undefined") {\n  SC.mode = "TEST_MODE";\n  SC.filename = "#{pathname}"; \n}\n(function() {\n]
       lines.push    %[\n})();\n</script>\n]
       @content_for_final = (@content_for_final || '') + lines.join("")
     end

data/lib/sproutcore/helpers/entry_sorter.rb

@@ -29,7 +29,22 @@ module SC
       def sort(entries)
         # first sort entries by filename - ignoring case
         entries = entries.sort do |a,b| 
-          (a.filename || '').to_s.downcase <=> (b.filename || '').to_s.downcase
+          a = (a.filename || '').to_s.downcase
+          b = (b.filename || '').to_s.downcase
+
+          # lproj/foo_page.js and main.js are loaded last
+          a_kind = (a =~ /lproj\/.+_page\.js$/) ? 1 : -1
+          a_kind = 2 if a =~ /main.js$/
+
+          b_kind = (b =~ /lproj\/.+_page\.js$/) ? 1 : -1
+          b_kind = 2 if b =~ /main.js$/
+          
+          if a_kind != b_kind
+            a_kind <=> b_kind
+          else
+            a <=> b
+          end
+          
         end
         all_entries = entries.dup # needed for sort...
        

data/lib/sproutcore/helpers/static_helper.rb

@@ -94,7 +94,7 @@ module SC
           
           # include either the entry URL or URL of ordered entries
           # depending on setup
-          if combine_javascript
+          if cur_target.config.combine_javascript
             urls << cur_entry.cacheable_url
           else
             urls += cur_entry.ordered_entries.map { |e| e.cacheable_url }
@@ -115,9 +115,27 @@ module SC
         urls.join("\n")
       end
 
+      # Attempts to render the named entry as a partial
+      #
+      # === Options
+      #  language:: the language to use. defaults to current
+      #
+      def partial(resource_name, opts = {})
+        resource_name = resource_name.to_s
+        m = self.manifest
+        if opts[:language]
+          m = target.manifest_for(:language => opts[:language]).build! 
+        end
+
+        entry = m.find_entry(resource_name, :hidden => true, :entry_type => :html)
+        return entry.nil? ? '' : render_partial(entry) 
+      end
+        
       # Returns the URL for the named resource
       def sc_static(resource_name, opts = {})
         
+        resource_name = resource_name.to_s
+        
         # determine which manifest to search.  if a language is explicitly
         # specified, lookup manifest for that language.  otherwise use 
         # current manifest.
@@ -127,10 +145,19 @@ module SC
         end
         
         entry = m.find_entry(resource_name)
-        entry.nil? ? '' : entry.cacheable_url
+        return '' if entry.nil?
+        return entry.friendly_url if opts[:friendly] && entry.friendly_url
+        return entry.cacheable_url
       end
       alias_method :static_url, :sc_static
 
+      # Returns the URL of the named target's index.html, if it has one
+      def sc_target(resource_name, opts = {})
+        opts[:friendly] = true
+        resource_name = "#{resource_name}:index.html"
+        sc_static(resource_name, opts)
+      end
+      
       # Allows you to specify HTML resource this html template should be
       # merged into.   Optionally also specify the layout file to use when
       # building this resource.
@@ -168,8 +195,9 @@ module SC
         return ret
       end
        
-      def title
-        target.config.title || target.target_name.to_s.sub(/^\//,'').gsub(/[-_\/]/,' ').split(' ').map { |x| x.capitalize }.join(' ')
+      def title(cur_target=nil)
+        cur_target = self.target if cur_target.nil?
+        cur_target.config.title || cur_target.target_name.to_s.sub(/^\//,'').gsub(/[-_\/]/,' ').split(' ').map { |x| x.capitalize }.join(' ')
       end
       
       private 

data/lib/sproutcore/helpers/tag_helper.rb

@@ -84,6 +84,71 @@ module SC
         fix_double_escape(html_escape(html.to_s))
       end
 
+      # Simple link_to can wrap a passed string with a link to a specified 
+      # target or static asset.  If you pass a block then the block will be
+      # invoked and its resulting content linked.  You can also pass 
+      # :popup, :title, :id, :class, and :style
+      def link_to(content, opts=nil, &block)
+        if block_given?
+          concat(link_to(capture(&block), content), block.binding);
+          return ''
+        end
+
+        if !content.instance_of?(String) && opts.nil?
+          opts = content
+          content = nil
+        end
+        
+        opts = { :href => opts } if opts.instance_of? String
+        opts = HashStruct.new(opts)
+        html_attrs = HashStruct.new
+        is_target = false
+        
+        if opts.href
+          html_attrs.href = opts.href
+        elsif opts.target
+
+          is_target = (target.target_name.to_sym == "/#{opts.target.to_s}".to_sym)
+
+          # supply title if needed
+          if content.nil?
+            cur_target = is_target ? target : target.target_for(opts.target)
+            content = title(cur_target) if cur_target
+            content = opts.target if content.nil?
+          end
+                    
+          # if current==false, then don't link if current target matches
+          if !opts.current.nil? && (opts.current==false) && is_target
+            return %(<span class="anchor current">#{content}</span>)
+          end
+
+          html_attrs.href = sc_target(opts.target, :language => opts.language)
+        elsif opts.static
+          html_attrs.href = sc_static(opts.static, :language => opts.language)
+        end
+        
+        if opts.popup
+          popup = opts.popup
+          html_attrs.target = popup.instance_of?(String) ? popup : '_blank'
+        end
+        
+        %w[title id class style].each do |key|
+          html_attrs[key] = opts[key] if opts[key]
+        end
+        
+        # add "current" class name
+        if is_target
+          html_attrs[:class] = [html_attrs[:class], 'current'].compact.join(' ')
+        end
+        
+        ret = ["<a "]
+        html_attrs.each { |k,v| ret << [k,'=','"',v,'" '].join('') }
+        ret << '>'
+        ret << content
+        ret << '</a>'
+        return ret.join('')
+      end
+          
       private
         def content_tag_string(name, content, options)
           tag_options = options ? tag_options(options) : ""

data/lib/sproutcore/models/manifest.rb

@@ -88,6 +88,8 @@ module SC
       return self
     end
     
+    def built?; @is_built; end
+    
     # Resets the manifest entries.  this is called before a build is 
     # performed. This will reset only the entries, none of the other props.
     #
@@ -213,6 +215,10 @@ module SC
       end
       opts.staging_path ||= unique_staging_path(staging_path)
       
+      # generate a unique cache path from the staging page.  just sub the 
+      # staging root for the cache root
+      opts.cache_path ||= unique_cache_path(entry.cache_path)
+      
       # copy other useful entries
       opts.source_entry   = entry
       opts.source_entries = [entry]
@@ -289,11 +295,28 @@ module SC
     #
     def find_entry(fragment, opts = {}, seen=nil)
       
+      entry_extname = entry_rootname = ret = target_name = nil
+      
+      # optionally you can specify an explicit target name
+      split_index = fragment.index(':') # find first index
+      unless split_index.nil?
+        target_name = '/' + fragment[0..(split_index-1)] if split_index>0
+        fragment    = fragment[(split_index+1)..-1] # remove colon
+      end
+      
+      # find the current manifest
+      if target_name
+        cur_target = self.target.target_for(target_name) || self.target
+        cur_manifest = cur_target.manifest_for(self.variation).build!
+      else
+        cur_manifest = self
+      end
+      
       extname = File.extname(fragment)
       rootname = fragment.sub(/#{extname}$/, '')
-      entry_extname = entry_rootname = nil
 
-      ret = entries(:hidden => opts[:hidden]).reject do |entry|
+      # look on our own target only if target is named
+      ret = cur_manifest.entries(:hidden => opts[:hidden]).reject do |entry|
         if entry.has_options?(opts)
           entry_extname = File.extname(entry.filename)
           entry_rootname = entry.filename.sub(/#{entry_extname}$/,'')
@@ -301,16 +324,17 @@ module SC
         else
           ext_match = false
         end
+      
         !(ext_match && (/#{rootname}$/ =~ entry_rootname))
       end
-
+      
       ret = ret.first
-
+        
       # if no match was found, search the same manifests in required targets
       if ret.nil?
         seen = Set.new if seen.nil?
-        seen << self.target
-        self.target.expand_required_targets.each do |t|
+        seen << cur_manifest.target
+        cur_manifest.target.expand_required_targets.each do |t|
           next if seen.include?(t) # avoid recursion
 
           manifest = t.manifest_for(self.variation).build!
@@ -330,6 +354,16 @@ module SC
       end
       return path
     end
+
+    # Finds a unique cache path starting with the root proposed staging
+    # path.
+    def unique_cache_path(path)
+      paths = entries(:hidden => true).map { |e| e.cache_path }
+      while paths.include?(path)
+        path = path.sub(/(__\$[0-9]+)?(\.\w+)?$/,"__$#{next_staging_uuid}\\2")
+      end
+      return path
+    end
     
     protected
     

data/lib/sproutcore/models/target.rb

@@ -241,7 +241,10 @@ module SC
     # === Returns
     #  A build number string
     #
-    def compute_build_number(seen=nil)
+    def compute_build_number(seen=nil, opts = {})
+
+      # reset cache if forced to recompute
+      build_number = nil if opts[:force]
       
       # Look for a global build_numbers hash and try that
       if (build_numbers = config.build_numbers)
@@ -272,10 +275,16 @@ module SC
         # causing infinite loops.  Normally this should not be necessary, but
         # we put this here to gaurd against misconfigured projects
         seen ||= []
-        required_targets.each do |ct|
+        
+        _targets = required_targets(:theme => true).sort do |a,b|
+          (a.target_name||'').to_s <=> (b.target_name||'').to_s
+        end
+        
+        _targets.each do |ct|
           next if seen.include?(ct)
+          ct.prepare!
           seen << ct
-          digests << (ct.build_number || ct.compute_build_number(seen))
+          digests << ct.compute_build_number(seen, :force => true)
         end
 
         # Finally digest the complete string - tada! build number

data/lib/sproutcore/rack/builder.rb

@@ -171,18 +171,70 @@ module SC
       # Reloads the project if reloading is enabled.  At maximum this will
       # reload the project every 5 seconds.  
       def reload_project!
+        
+        monitor_project!
+        
         # don't reload if no project or is disabled
         return if @project.nil? || !@project.config.reload_project
         
-        # reload after a delay of 5 sec
-        reload_delay = (Time.now - @last_reload_time)
-        
-        if reload_delay > 5
+        if @project_did_change
+          @project_did_change = false
           SC.logger.info "Rebuilding project manifest"
           @project.reload!
         end
       end
+
+      def monitor_project!
+        if !@should_monitor
+          @should_monitor = true
+          @project_root = @project.project_root
+          
+          # collect initial info on project
+          files = Dir.glob(@project_root / '**' / '*')
+          # follow 1-level of symlinks
+          files += Dir.glob(@project_root / '**' / '*' / '**' / '*')
+          tmp_path = /^#{Regexp.escape(@project_root / 'tmp')}/
+          files.reject! { |f| f =~ tmp_path }
+          files.reject! { |f| File.directory?(f) }
+          
+          @project_file_count = files.size
+          @project_mtime = files.map { |x| File.mtime(x).to_i }.max
+          
+          Thread.new do 
+            while @should_monitor
+              
+              # only need to start scanning again 2 seconds after the last 
+              # request was serviced. 
+              reload_delay = (Time.now - @last_reload_time)
+              if reload_delay > 2
+                files = Dir.glob(@project_root / '**' / '*')
+                # follow 1-level of symlinks
+                files += Dir.glob(@project_root / '**' / '*' / '**' / '*')
+                tmp_path = /^#{Regexp.escape(@project_root / 'tmp')}/
+                files.reject! { |f| f =~ tmp_path }
+                files.reject! { |f| File.directory?(f) }
+
+                cur_file_count = files.size
+                cur_mtime = files.map { |x| File.mtime(x).to_i }.max
+              
+                if (@project_file_count != cur_file_count) || (@project_mtime != cur_mtime)
+                  SC.logger.info "Detected project change.  Will rebuild manifest"
+                  @project_did_change = true
+                  @project_file_count = cur_file_count
+                  @project_mtime = cur_mtime
+                end
+              end
+              
+              sleep(5)
+            end
+          end
+        end
+      end
       
+      def stop_monitor!
+        @should_monitor = false
+      end
+              
       def target_for(url)
 
         # get targets

data/lib/sproutcore/tools/manifest.rb

@@ -16,6 +16,7 @@ module SC
                          :format        => :optional,
                          :output        => :output,
                          :all           => false,
+                         ['--build-numbers', '-B'] => :optional,
                          ['--include-required', '-r'] => false }
                      
     desc "manifest [TARGET..]", "Generates a manifest for the specified targets"

data/lib/sproutcore/tools/server.rb

@@ -39,6 +39,7 @@ module SC
         ARGV.clear # do not pass onto IRB
         IRB.start
       else
+        SC.logger << "SproutCore v#{SC::VERSION} Development Server\n"
         SC::Rack::Service.start(options.merge(:project => project))
       end
     end

data/lib/sproutcore/tools.rb

@@ -253,15 +253,35 @@ module SC
       if (languages = options.languages).nil?
         languages = targets.map { |t| t.installed_languages }
       else
-        languages = languages.split(':').map { |l| l.to_sym }
+        languages = languages.split(',').map { |l| l.to_sym }
       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)
+      if options['build-numbers']
+        numbers = {}
+        options['build-numbers'].split(',').each do |pair|
+          pair = pair.split(':')
+          if pair.length < 2
+            fatal! "Could not parse build numbers! #{options['build-numbers']}"
+          end
+          numbers["/#{pair[0]}"] = pair[1]
+        end
+        SC.env.build_numbers = numbers
+        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

data/lib/sproutcore.rb

@@ -125,6 +125,19 @@ module SproutCore
   def self.project; @project; end
   def self.project=(project); @project = project; end
   
+  # Attempts to load a project for the current working directory or from the
+  # passed directory location.  Returns nil if no project could be detected.
+  # This is just a shorthand for creating a Project object.  It is useful 
+  # when using the build tools as a Ruby library
+  def self.load_project(path = nil, opts = {})
+    path = File.expand_path(path.nil? ? Dir.pwd : path)
+    if FalseClass === opts[:discover]
+      SC::Project.load path, :parent => SC.builtin_project
+    else # attempt to autodiscover unless disabled
+      SC::Project.load_nearest_project path, :parent => SC.builtin_project
+    end
+  end
+    
 end  # module SC
 
 SC = SproutCore # alias