sproutcore 1.5.0.pre.4 → 1.5.0.pre.4.1

data/lib/sproutcore/builders/html.rb

@@ -117,7 +117,7 @@ module SC
         $to_html5_manifest_networks = CONFIG[:html5_manifest_networks]
         @content_for_html5_manifest = true
       end
-      $to_minify << dst_path
+
       writelines dst_path, [self.render]
       
     end

data/lib/sproutcore/builders/minify.rb

@@ -54,24 +54,12 @@ module SC
 
     # Minify some javascript by invoking the YUI compressor.
     def build_javascript(dst_path)
-      a = Regexp.new('^'+MANIFEST.build_root)
-      if dst_path =~ a
-        # $to_minify << dst_path
-        FileUtils.mkdir_p(File.dirname(dst_path))
-        FileUtils.copy(entry.source_path, dst_path)
+      entry.source_entry.build!
+      # Minify module JavaScript immediately so it can be string-wrapped
+      if entry.target[:target_type] == :module
+        SC::Helpers::Minifier.minify! dst_path
       else
-        FileUtils.mkdir_p(File.dirname(dst_path)) # make sure loc exists...
-        filecompress = "java -Xmx128m -jar \"" + SC.yui_jar + "\" --js \"" + entry.source_path + "\" --js_output_file \"" + dst_path + "\" 2>&1"
-        SC.logger.info  'Compiling with YUI:  '+ filecompress + "..."
-
-        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
-          _report_error(output, entry.filename, entry.source_path)
-          SC.logger.fatal("!!!!YUI compiler failed, please check that your js code is valid")
-          SC.logger.fatal("!!!!Failed compiling ... "+ dst_path)
-        end
+        SC::Helpers::Minifier << dst_path
       end
     end
 

data/lib/sproutcore/builders/module.rb

@@ -53,7 +53,7 @@ module SC
         next if not string_entry
         string_url = string_entry.cacheable_url
 
-        module_info = t.module_info({ :debug => entry[:debug], :test => entry[:test], :theme => entry[:theme], :variation => entry[:variation] })
+        module_info = t.module_info({ :variation => entry[:variation] })
 
         output << eruby.evaluate({
           :target_name => t[:target_name].to_s.sub(/^\//,''),
@@ -61,7 +61,7 @@ module SC
           :styles      => module_info[:css_urls].map{ |url| "'#{url}'" },
           :script      => script_url,
           :string      => string_url,
-          :prefetched  => t[:prefetched]
+          :prefetched  => t[:prefetched_module]
         })
       end
       writelines dst_path, [output]

data/lib/sproutcore/builders/string_wrapper.rb

@@ -15,27 +15,25 @@ module SC
   class Builder::StringWrapper < Builder::Base
 
     def build(dst_path)
-      entries = entry[:source_entries]
+      src_path = entry.source_entry[:build_path]
+      entry.source_entry.build!
 
-      entries.each do |entry|
-        src_path = entry.stage![:staging_path]
-        return if not File.exist? src_path
+      return if not File.exist? src_path
 
-        # Normalize the target name by removing any initial forward slash
-        target = entry.target
-        target_name = target[:target_name].to_s.sub(/^\//,'')
+      # Normalize the target name by removing any initial forward slash
+      target = entry.target
+      target_name = target[:target_name].to_s.sub(/^\//,'')
 
-        # Set the source property of the module's SC.MODULE_INFO hash to the
-        # JSON-escaped contents of the file.
-        output = "SC.MODULE_INFO['#{target_name}'].source = "
+      # Set the source property of the module's SC.MODULE_INFO hash to the
+      # JSON-escaped contents of the file.
+      output = "SC.MODULE_INFO['#{target_name}'].source = "
 
-        content = readlines(src_path)
-        output += content.join.to_json
+      content = readlines(src_path)
+      output += content.join.to_json
 
-        output += ";"
+      output += ";"
 
-        writeline dst_path, output
-      end
+      writeline dst_path, output
     end
 
   end

data/lib/sproutcore/helpers.rb

@@ -7,5 +7,5 @@ require "sproutcore/helpers/packed_optimizer"
 require "sproutcore/helpers/static_helper"
 require "sproutcore/helpers/tag_helper"
 require "sproutcore/helpers/text_helper"
-
+require "sproutcore/helpers/minifier"
 

data/lib/sproutcore/helpers/minifier.rb

@@ -0,0 +1,56 @@
+module SC::Helpers
+
+  # Helper to minify JavaScript files. You can either call the class method
+  # minify!, or add paths using <<, then call minify_queue! to minify all files
+  # at once (which improves performance significantly.)
+
+  class Minifier
+    @@queue = []
+
+    def self.<<(item)
+      @@queue << item
+    end
+
+    def self.queue
+      @@queue
+    end
+
+    # Minifies a path or an array of paths
+    def self.minify!(paths)
+        yui_root = File.expand_path("../../../../vendor/sproutcore", __FILE__)
+        jar_path = File.join(yui_root, 'SCCompiler.jar')
+
+        # Convert to string if an array
+        if paths.respond_to? :join
+          paths = paths * "\" \""
+        end
+
+        if SC.env[:yui_minification]
+          command = "java -Xmx256m -jar \"" + jar_path + "\" -yuionly \"" + paths + "\" 2>&1"
+        else
+          command = "java -Xmx256m -jar \"" + jar_path + "\" \"" + paths + "\" 2>&1"
+        end
+
+        SC.logger.info  'Minifying...'
+        SC.logger.info  command
+
+        output = `#{command}`     # It'd be nice to just read STDERR, but
+                                  # I can't find a reasonable, commonly-
+                                  # installed, works-on-all-OSes solution.
+        SC.logger.info output
+        if $?.exitstatus != 0
+          SC.logger.fatal(output)
+          SC.logger.fatal("!!!! Minifying failed, please check that your js code is valid")
+          SC.logger.fatal("!!!! Failed compiling ... " + paths)
+          exit(1)
+        end
+    end
+
+    # Minimizes the files in the queue, then empties the queue
+    def self.minify_queue!
+      SC::Helpers::Minifier.minify! @@queue
+      @@queue = []
+    end
+
+  end
+end

data/lib/sproutcore/helpers/static_helper.rb

@@ -19,28 +19,65 @@ module SC
       # client will be used.
       #
       # bundle_name = the name of the bundle to render or nil to use the
-      # current :language => the language to render. defaults to current
-      # language
+      # current
+      #
+      # :language   => the language to render. defaults to current language
+      # :x2         => if true, returns URLs for 2x stylesheets.
       #
       def stylesheets_for_client(target_name = nil, opts = nil)
 
+        urls = stylesheet_urls_for_client(target_name, opts)
+        
         # normalize params
         if target_name.kind_of?(Hash) && opts.nil?
           opts = target_name
           target_name = nil
         end
         opts = {} if opts.nil?
+        
+        # process options
+        include_method = opts[:include_method] ||= :link
+        
+        # Convert to HTML and return
+        urls = urls.map do |url|
+          if include_method == :import
+            %(  @import url('#{url}');)
+          else
+            %(  <link href="#{url}" rel="stylesheet" type="text/css" />)
+          end
+        end
 
+        # if include style is @import, surround with style tags
+        if include_method == :import
+          %(<style type="text/css">\n#{urls * "\n"}</style>)
+        else
+          urls.join("\n")
+        end
+      end
+      
+      # This method will return the urls of all the stylesheets
+      # required by the named bundle.
+      def stylesheet_urls_for_client(target_name = nil, opts = nil)
+        
+        # normalize params
+        if target_name.kind_of?(Hash) && opts.nil?
+          opts = target_name
+          target_name = nil
+        end
+        opts = {} if opts.nil?
+        
         # process options
         include_method = opts[:include_method] ||= :link
         t = target_name ? target.target_for(target_name) : target
 
+        # figure out stylesheet name (whether it is x2 or not)
+        name = "stylesheet"
+        name += "@2x" if opts[:x2]
+
         # collect urls from entries
         urls = []
         combine_stylesheets = t.config[:combine_stylesheets]
-        combined_entries(t, opts, 'stylesheet.css', 'stylesheet-packed.css') do |cur_target, cur_entry|
-
-          $to_minify << cur_entry[:build_path]
+        combined_entries(t, opts, name + '.css', name + '-packed.css') do |cur_target, cur_entry|
 
           # include either the entry URL or URL of ordered entries
           # depending on setup
@@ -49,26 +86,13 @@ module SC
           else
             urls += cur_entry[:ordered_entries].map { |e| e.cacheable_url }
           end
-
+          
           # add any stylesheet libs from the target
           urls += (cur_target.config[:stylesheet_libs] || [])
         end
-
-        # Convert to HTML and return
-        urls = urls.map do |url|
-          if include_method == :import
-            %(  @import url('#{url}');)
-          else
-            %(  <link href="#{url}" rel="stylesheet" type="text/css" />)
-          end
-        end
-
-        # if include style is @import, surround with style tags
-        if include_method == :import
-          %(<style type="text/css">\n#{urls * "\n"}</style>)
-        else
-          urls.join("\n")
-        end
+        
+        urls
+        
       end
 
       # This method will return the HTML to link to all the javascripts
@@ -80,6 +104,26 @@ module SC
       #
       def javascripts_for_client(target_name = nil, opts = {})
 
+        urls = javascript_urls_for_client(target_name, opts)
+
+        # Convert to HTML and return
+        urls = urls.map do |url|
+          %(  <script type="text/javascript" src="#{url}"></script>)
+        end
+        
+         # Add preferred language definition, before other scripts...
+        urls.insert(0, %(<script type="text/javascript">String.preferredLanguage = "#{language}";</script>))
+        
+        urls.join("\n")
+      end
+      
+      # This method will return an array of all the javascripts
+      # required by the client.
+      #
+      # client_name = the name of the client to render or nil to use the
+      # current :language => the language to render. defaults to @language.
+      #
+      def javascript_urls_for_client(target_name = nil, opts = {})
         # normalize params
         if target_name.kind_of?(Hash) && opts.nil?
           opts = target_name
@@ -95,9 +139,6 @@ module SC
         combine_javascript = t.config[:combine_javascript]
       
         combined_entries(t, opts, 'javascript.js', 'javascript-packed.js') do |cur_target, cur_entry|
-
-          $to_minify << cur_entry[:build_path]
-          
           # include either the entry URL or URL of ordered entries
           # depending on setup
           if cur_target.config[:combine_javascript]
@@ -109,16 +150,9 @@ module SC
           # add any stylesheet libs from the target
           urls += (cur_target.config[:javascript_libs] || [])
         end
-
-        # Convert to HTML and return
-        urls = urls.map do |url|
-          %(  <script type="text/javascript" src="#{url}"></script>)
-        end
-
-         # Add preferred language definition, before other scripts...
-        urls.insert(0, %(<script type="text/javascript">String.preferredLanguage = "#{language}";</script>))
-          
-        urls.join("\n")
+        
+        urls
+        
       end
 
       # Detects and includes any bootstrap code
@@ -272,11 +306,11 @@ module SC
       # theme framework, if set.
       def theme_name(opts ={})
         ret = opts[:default] || 'sc-theme'
-        if target.config[:css_theme]
-          ret = target.config[:css_theme]
+        if target.config[:theme_name]
+          ret = target.config[:theme_name]
         elsif target.config[:theme]
           if theme_target = target.target_for(target.config[:theme])
-            ret = theme_target.config[:css_theme] || ret
+            ret = theme_target.config[:theme_name] || ret
           end
         end
         return ret
@@ -361,7 +395,13 @@ module SC
 
           # get the stylesheet or js entry for it...
           entry = cur_manifest.entry_for packed_entry_name
-          next if entry.nil? || !entry.composite? # no stylesheet or js
+
+          # It used to be like this:
+          # next if entry.nil? || !entry.composite? # no stylesheet or js
+          # But the @2x css file is not composite. There does not seem to be
+          # a reason to check for composite entries, either. So, the composite
+          # check has been removed.
+          next if entry.nil? # no stylesheet or js
 
           yield(t, entry)
         end
@@ -372,7 +412,13 @@ module SC
 
           # get the stylesheet or js entry for it...
           entry = cur_manifest.entry_for entry_name
-          next if entry.nil? || !entry.composite? # no stylesheet or js
+
+          # It used to be like this:
+          # next if entry.nil? || !entry.composite? # no stylesheet or js
+          # But the @2x css file is not composite. There does not seem to be
+          # a reason to check for composite entries, either. So, the composite
+          # check has been removed.
+          next if entry.nil? # no stylesheet or js
 
           yield(t, entry)
         end

data/lib/sproutcore/models/generator.rb

@@ -51,6 +51,9 @@ module SC
   #  namespace::
   #    The classified version of the target name.  example: "AddressBook"
   #
+  #  css_name::
+  #    The CSS class name version of the target name. example: 'address-book'
+  #
   #  class_name::
   #    The classified version of the filename.  example: "Contact"
   #
@@ -405,17 +408,25 @@ module SC
     #   snake_case("CNN")              #=> "cnn"
     #   snake_case("innerHTML")        #=> "inner_html"
     #   snake_case("Foo_Bar")          #=> "foo_bar"
+    #   snake_case("Foo-Bar")          #=> "foo_bar"
     #
     # === Params
     #
     #  str:: the string to snake case
     #
     def snake_case(str='')
+      str = str.gsub(/-/, '_')
       str = str.gsub(/([^A-Z_])([A-Z][^A-Z]?)/,'\1_\2') # most cases
       str = str.gsub(/([^_])([A-Z][^A-Z])/,'\1_\2') # HeadlineCNNNews
       str.downcase
     end
 
+    # Converts a string to CSS case. This method will accept CamelCase or snake case
+    # and normalize into a format that can be converted to CSS case.
+    def css_case(str='')
+      snake_case(str).gsub(/_/, '-')
+    end
+
     ABBREVIATIONS = %w(html css xml)
 
     # Converts a string to CamelCase.  If you pass false for the second param
@@ -469,6 +480,11 @@ module SC
         self.namespace = camel_case(parts[0] || self.target_name)
       end
 
+      # css_name is first part css cased if defined
+      if (parts[0] || self.target_name) && self.css_name.nil?
+        self.css_name = css_case(parts[0] || self.target_name)
+      end
+
       # filename is second part snake_cased, unless already defined
       if parts[1] && self.filename.nil?
         self.filename = snake_case(parts[1])

data/lib/sproutcore/models/manifest_entry.rb

@@ -145,9 +145,16 @@ module SC
           timestamps2.max
         end
         timestamps.max
-      elsif composite?
 
+      elsif composite?
         self[:source_entries].map { |e| e.timestamp || 0 }.max || Time.now.to_i
+
+      elsif self[:timestamp]
+        # for certain entries, such as the Chance entry, we can't use composite entry
+        # but still need to have a timestamp to prevent caching. To do this, we allow
+        # the entry to specify the timestamp directly; it will calculate it on its own.
+        self[:timestamp]
+
       else
         File.exist?(self[:source_path]) ? File.mtime(self[:source_path]).to_i : 0
       end

data/lib/sproutcore/models/target.rb

@@ -160,7 +160,7 @@ module SC
       return ret unless ret.nil?
 
       # else compute return value, respecting options
-      ret = [config[:required]]
+      ret = [config[:required], config[:inlined_modules]]
       if opts[:debug] && config[:debug_required]
         ret << config[:debug_required]
       end
@@ -192,16 +192,55 @@ module SC
       end
       ret = ret.compact.uniq
 
+      if self[:target_type].eql? :app
+        reqs = self.find_required_modules
+
+        if reqs.empty?
+          reqs = project.targets.values.select { |target| target[:target_type] == :module }
+
+          reqs = reqs.select do |target|
+            target[:target_name].match(/^\/?#{self[:target_name]}/)
+          end
+
+          ret = ret.concat(reqs)
+        end
+      end
+
       @required_targets[key] = ret
       return ret
     end
 
-    # Returns all of the targets dynamically required by this target.  This
-    # will use the "deferred_modules" config, resolving the target names using
-    # target_for().
+    # Returns the recursive list of required modules for this target.
+    #
+    # === Returns
+    #  Array of targets
+    #
+    def find_required_modules(opts ={})
+      _find_required_modules(opts, [self])
+    end
+
+    def _find_required_modules(opts, seen)
+      ret = []
+      modules(opts).each do |target|
+        next if seen.include?(target)
+        seen << target # avoid loading again
+
+        # add required targets, if not already seend...
+        target._find_required_modules(opts, seen).each do |required|
+          ret << required
+          seen << required
+        end
+
+        # then add my own target...
+        ret << target
+      end
+      return ret.uniq.compact
+    end
+
+    # Returns all of the modules under this target.  This
+    # will use the deferred_modules, prefetched_modules, and inlined_modules config
+    # options from the Buildfile.
     #
-    # You may pass some additional options in which will select the set
-    # of targets you want returned.
     #
     # === Options
     #  :debug:: if true, config.debug_required will be included
@@ -218,41 +257,36 @@ module SC
       key = key.compact.join('.')
 
       # Return cache value if found
-      ret = (@dynamic_targets ||= {})[key]
+      ret = (@modules ||= {})[key]
       return ret unless ret.nil?
 
-      # Get the list of targets that should be treated as prefetched modules
-      # from the Buildfile
+      # Get the list of targets that should be treated as prefetched, deferred
+      # or inline modules from the Buildfile
       prefetched_modules = config[:prefetched_modules]
+      deferred_modules = config[:deferred_modules]
+      inlined_modules = config[:inlined_modules]
+
+      # else compute return value, respecting options
+      ret = [deferred_modules, prefetched_modules, inlined_modules]
+      return [] if ret.compact.empty?
+
       if prefetched_modules
-        # Go through each module and mark it as prefetched.
-        # This way, we can later distinguish between deferred and prefetched
-        # modules when generating the module_info.js file.
-        prefetched_modules.each do |m|
-          target = target_for(m)
-          target[:prefetched] = true
-        end
+        ret << find_dependencies_for_modules(prefetched_modules, opts, :prefetched_module)
       end
 
-      # else compute return value, respecting options
-      ret = [config[:deferred_modules], config[:prefetched_modules]]
+      if deferred_modules
+        ret << find_dependencies_for_modules(deferred_modules, opts, :deferred_module)
+      end
 
-      if opts[:debug] && config[:debug_deferred_modules]
-        ret << config[:debug_deferred_modules]
+      if inlined_modules
+        ret << find_dependencies_for_modules(inlined_modules, opts, :inlined_module)
       end
-      if opts[:test] && config[:test_deferred_modules]
-        ret << config[:test_deferred_modules]
+
+      if opts[:debug] && config[:debug_required]
+        ret << config[:debug_required]
       end
-      if opts[:theme] && self.loads_theme? && config[:theme]
-        # verify theme is a theme target type - note that if no matching
-        # target is found, we'll just let this go through so the standard
-        # not found warning can show.
-        t = target_for(config[:theme])
-        if t && t[:target_type] != :theme
-          SC.logger.warn "Target #{config[:theme]} was set as theme for #{target_name} but it is not a theme."
-        else
-          ret << config[:theme]
-        end
+      if opts[:test] && config[:test_required]
+        ret << config[:test_required]
       end
 
       ret = ret.flatten.compact.map do |n|
@@ -263,7 +297,32 @@ module SC
       end
       ret = ret.compact.uniq
 
-      @dynamic_targets[key] = ret
+      @modules[key] = ret
+      return ret
+    end
+
+    # For each module in the modules array, set the 'type' property to true,
+    # and return an array of their dependencies, one level deep.
+    def find_dependencies_for_modules(modules, opts, type)
+      ret = []
+
+      modules.each do |m|
+        target = target_for(m)
+
+        if target == nil
+          SC.logger.warn "Could not find target #{m} that is required by #{self[:target_name]}"
+          return
+        end
+
+        target[type] = true
+
+        target.required_targets(opts).flatten.compact.each do |dependency|
+          if dependency[:target_type] == :module
+            ret << dependency[:target_name]
+          end
+        end
+      end
+
       return ret
     end
 
@@ -499,6 +558,15 @@ module SC
       if self[:target_type] == :app
         raise "module_info called on an app target"
       else
+
+        # Majd: I added this because modules shouldn't have the debug_required
+        # and test_required frameworks applied to them since a module shouldn't
+        # require a framework if the module is either deferred or prefetched
+        if self[:deferred_module] or self[:prefetched_module]
+          opts[:debug] = false
+          opts[:test] = false
+        end
+
         requires = required_targets(opts) # only go one-level deep!
 
         # Targets that aren't pre-loaded can't be packed together. That leaves