sproutcore 0.9.4 → 0.9.5

data/lib/sproutcore/build_tools/html_builder.rb

@@ -2,8 +2,6 @@ require 'erubis'
 require 'sproutcore/helpers'
 require 'sproutcore/view_helpers'
 
-puts "LOADED HTML_BUILDER"
-
 module SproutCore
   
   module BuildTools
@@ -49,9 +47,7 @@ module SproutCore
         @entries.reject! { |entry| entry.composite? || (entry.type == :html && !entry.localized?) }
         
         # Load any helpers before we continue
-        puts "*************REQUIRE"
         bundle.all_required_bundles.each do |cur_bundle|
-          puts "requiring: #{cur_bundle.bundle_name}"
           require_helpers(nil, cur_bundle)
         end
           
@@ -63,11 +59,13 @@ module SproutCore
 
         @layout_path = bundle.layout_path
         
-        # Render each filename.  By default, the output goes to the resources string
+        # Render each filename.  By default, the output goes to the resources 
+        # string
         @content_for_resources = ''
         entries.each { |fn| _render_one(fn) }
         
-        # Finally, render the layout.  This should produce the final output to return
+        # Finally, render the layout.  This should produce the final output to 
+        # return
         input = File.read(@layout_path)
         return eval(Erubis::Eruby.new.convert(input))
       end

data/lib/sproutcore/build_tools/resource_builder.rb

@@ -53,12 +53,23 @@ module SproutCore
         return join(lines)
       end
       
-      # Join the lines together.  This is one last chance to do some prep of the data
-      # (such as minifcation and comment stripping)
+      # Join the lines together.  This is one last chance to do some prep of 
+      # the data (such as minifcation and comment stripping)
       def join(lines); lines.join; end
       
-      # Tries to build a single resource.  This may call itself recursively to handle
-      # requires.
+      # Rewrites any inline content such as static urls.  Subclasseses can
+      # override this to rewrite any other inline content.
+      #
+      # The default will rewrite calls to static_url().
+      def rewrite_inline_code(line, filename)
+        line.gsub(/static_url\([\'\"](.+)[\'\"]\)/) do | rsrc |
+          entry = bundle.find_resource_entry($1, :language => language)
+          static_url(entry.nil? ? '' : entry.url)
+        end
+      end
+      
+      # Tries to build a single resource.  This may call itself recursively to 
+      # handle requires.
       #
       # ==== Returns
       # [lines, required] to be passed into the next call
@@ -77,19 +88,19 @@ module SproutCore
         io = (entry.source_path.nil? || !File.exists?(entry.source_path)) ? [] : File.new(entry.source_path)
         io.each do | line |
           
-          # check for requires.  Only follow a require if the require is in the list
-          # of filenames.
+          # check for requires.  Only follow a require if the require is in 
+          # the list of filenames.
           required_file = _require_for(filename, line) 
           unless required_file.nil? || !filenames.include?(required_file)
             lines, required = _build_one(required_file, lines, required, link_only)
           end
           
-          file_lines << _rewrite_static_urls(line) unless link_only 
+          file_lines << rewrite_inline_code(line, filename) unless link_only 
         end
 
-        # The list of already required filenames is slightly out of order from the actual
-        # load order.  Instead, we use the lines array to hold the list of filenames as they
-        # are processed.
+        # The list of already required filenames is slightly out of order from 
+        # the actual load order.  Instead, we use the lines array to hold the 
+        # list of filenames as they are processed.
         if link_only
           lines << filename
           
@@ -104,16 +115,8 @@ module SproutCore
       # Overridden by subclasses to choose first filename.
       def next_filename; filenames.delete(filenames.first); end
 
-      # This will look for calls to static_url() and rewrite them with an actual
-      # string to the URL. Assumes the input text is JavaScript or CSS.
-      def _rewrite_static_urls(line)
-        line.gsub(/static_url\([\'\"](.+)[\'\"]\)/) do | rsrc |
-          entry = bundle.find_resource_entry($1, :language => language)
-          static_url(entry.nil? ? '' : entry.url)
-        end
-      end
-
-      # Overridden by subclass to handle static_url() in a language specific way.
+      # Overridden by subclass to handle static_url() in a language specific 
+      # way.
       def static_url(url); "url('#{url}')"; end
       
       # check line for required() pattern.  understands JS and CSS.
@@ -156,6 +159,15 @@ module SproutCore
         lines.join
       end
       
+      # If the file is a strings.js file, then remove server-side strings...
+      def rewrite_inline_code(line, filename)
+        if filename == 'strings.js'
+          line = line.gsub(/["']@@.*["']\s*?:\s*?["'].*["'],\s*$/,'')
+        end
+        
+        super(line, filename)
+      end
+      
       def static_url(url); "'#{url}'"; end
       def filename_for_require(ret); "#{ret}.js"; end
       

data/lib/sproutcore/bundle.rb

@@ -234,7 +234,11 @@ module SproutCore
     #
     def entries_for(resource_type, opts={})
       with_hidden = opts[:hidden] || :none
-      manifest = manifest_for(opts[:language] || preferred_language)
+      
+      language = opts[:language] || preferred_language
+      mode = opts[:build_mode] || build_mode
+      manifest = manifest_for(language, mode)
+
       ret = manifest.entries_for(resource_type)
       
       case with_hidden
@@ -257,7 +261,11 @@ module SproutCore
     #
     def entry_for(resource_name, opts={})
       with_hidden = opts[:hidden] || :none
-      manifest = manifest_for(opts[:language] || preferred_language)
+      
+      language = opts[:language] || preferred_language
+      mode = opts[:build_mode] || build_mode
+      manifest = manifest_for(language, mode)
+
       ret = manifest.entry_for(resource_name)
 
       case with_hidden
@@ -269,26 +277,43 @@ module SproutCore
       return ret
     end
 
-    # Returns the entry for the specified URL.  This will extract the language from the URL.
+    # Returns the entry for the specified URL.  This will extract the language 
+    # from the URL and try to get the entry from both the manifest in the
+    # current build mode and in the production build mode (if one is
+    # provided)
     #
     # ==== Params 
     # url<String>:: The url
     #
     # ==== Options
     # hidden::     Use :include,:none,:only to control hidden options
-    # language::   Explicitly include the language.  Leave this out to autodetect from URL.
+    # language::   Explicitly include the language.  Leave this out to 
+    #   autodetect from URL.
     #
     def entry_for_url(url, opts={})
       # get the language
-      opts[:language] ||= url.match(/^#{url_root}\/([^\/]+)\//).to_a[1] || preferred_language
+      opts[:language] ||= url.match(/^#{url_root}\/([^\/]+)\//).to_a[1] || url.match(/^#{index_root}\/([^\/]+)\//).to_a[1] || preferred_language
+
+      # use the current build mode
+      opts[:build_mode] = build_mode
       entries(opts).each do |entry|
         return entry if entry.url == url
       end
+      
+      # try production is necessary...
+      if (build_mode != :production) 
+        opts[:build_mode] = :production
+        entries(opts).each do |entry|
+          return entry if entry.url == url
+        end
+      end
+        
       return nil # not found!
     end
     
-    # Helper method.  This will normalize a URL into one that can map directly to an
-    # entry in the bundle.  If the URL is of a format that cannot be converted, returns nil.
+    # Helper method.  This will normalize a URL into one that can map directly 
+    # to an entry in the bundle.  If the URL is of a format that cannot be 
+    # converted, returns nil.
     # 
     # ==== Params
     # url<String>:: The URL
@@ -299,7 +324,7 @@ module SproutCore
       if (url == index_root)
         url = [index_root, preferred_language.to_s, 'index.html'].join('/')
 
-      # Requests to url_root/lang should have index.html appended to them
+      # Requests to index_root/lang should have index.html appended to them
       elsif /^#{index_root}\/[^\/\.]+$/ =~ url
         url << '/index.html'
       end
@@ -315,7 +340,11 @@ module SproutCore
     #
     def entries(opts ={})
       with_hidden = opts[:hidden] || :none
-      manifest = manifest_for(opts[:language] || preferred_language)
+
+      language = opts[:language] || preferred_language
+      mode = opts[:build_mode] || build_mode
+      manifest = manifest_for(language, mode)
+
       ret = manifest.entries
 
       case with_hidden
@@ -327,9 +356,9 @@ module SproutCore
       return ret
     end
 
-    # Does a deep search of the entries, looking for a resource that is a close
-    # match of the specified resource.  This does not need to match the filename
-    # exactly and it can omit the extension
+    # Does a deep search of the entries, looking for a resource that is a 
+    # close match of the specified resource.  This does not need to match the 
+    # filename exactly and it can omit the extension
     def find_resource_entry(filename, opts={}, seen=nil)
       extname = File.extname(filename)
       rootname = filename.gsub(/#{extname}$/,'')
@@ -420,14 +449,15 @@ module SproutCore
       @seen = nil if created_seen
     end
     
-    # Easy singular form of build_entries().  Take same parameters except for a single entry
-    # instead of an array.
+    # Easy singular form of build_entries().  Take same parameters except for 
+    # a single entry instead of an array.
     def build_entry(entry, opts={})
       build_entries([entry], opts)
     end
 
-    # Invoked by build tools when they build a dependent entry. This will add the entry
-    # to the list of seen entries during a build so that it will not be rebuilt.
+    # Invoked by build tools when they build a dependent entry. This will add 
+    # the entry to the list of seen entries during a build so that it will not 
+    # be rebuilt.
     def did_build_entry(entry)
       @seen << entry unless @seen.nil?
     end
@@ -439,8 +469,9 @@ module SproutCore
       SC.logger.debug("~ Done.\n")
     end
     
-    # This will perform a complete build for all languages that have a matching lproj.
-    # You can also pass in an array of languages you would like to build
+    # This will perform a complete build for all languages that have a 
+    # matching lproj. You can also pass in an array of languages you would 
+    # like to build
     def build(*languages)
       
       # Get the installed languages (and the preferred language, just in case)
@@ -512,22 +543,87 @@ module SproutCore
       
       return cached[:contents] 
     end
+
+    ######################################################
+    ## LOCALIZATION
+    ##
+    
+    # Returns all of the strings.js entries for this bundle and any required
+    # bundles.  The return array is in the order the entries should be 
+    # processed to build the strings hash.
+    #
+    # ==== Options
+    # language: optional language.  otherwise preferred language is used.
+    #
+    def strings_entries(opts = {})
+      opts[:hidden] = true # include hidden files for prod mode.
+      all_required_bundles.map { |q| q.entry_for('strings.js', opts) }.compact
+    end
+    
+    # This will load a strings resource and convert it into a hash of key
+    # value pairs.
+    def strings_for_entry(strings_entry)
+      source_path = strings_entry.source_path
+      return {} if !File.exists?(source_path)
+      
+      # read the file in and strip out comments...
+      str = File.read(source_path)
+      str = str.gsub(/\/\/.*$/,'').gsub(/\/\*.*\*\//m,'')
+      
+      # Now build the hash
+      ret = {}
+      str.scan(/['"](.+)['"]\s*:\s*['"](.+)['"],?\s*$/) do |x,y| 
+        # x & y are JS strings that must be evaled as such..
+        #x = eval(%("#{x}"))
+        y = eval(%("#{y}"))
+        ret[x] = y 
+      end
+      
+      return ret
+    end
+    
+    # Strings the string hash for the current bundle.  If this strings hash
+    # has not been loaded yet, it will be loaded now.
+    #
+    # ==== Options
+    # language: optional language.  otherwise preferred language is used.
+    #
+    def strings_hash(opts={})
+      
+      build_mode = opts[:build_mode] ||= build_mode
+      language = opts[:language] ||= preferred_language
+      key = [build_mode.to_s, language.to_s].join(':').to_sym
+      
+      @strings_hash ||= {}
+      if @strings_hash[key].nil?
+        ret = {} 
+        strings_entries(opts).each do |entry|
+          ret.merge! strings_for_entry(entry)
+        end
+        @strings_hash[key] = ret 
+      end
+      
+      return @strings_hash[key]
+    end
     
     ######################################################
     ## MANIFESTS
     ##
 
-    # Invoke this method whenever you think the bundle's contents on disk might have changed
-    # this will throw away any cached information in bundle.  This is generally a cheap
-    # operation so it is OK to call it often, though it will be less performant overall.
+    # Invoke this method whenever you think the bundle's contents on disk 
+    # might have changed this will throw away any cached information in 
+    # bundle.  This is generally a cheap operation so it is OK to call it 
+    # often, though it will be less performant overall.
     def reload!
       @manifests = {}
+      @strings_hash = {}
     end
     
-    # Returns the bundle manifest for the specified language.  The manifest will be created
-    # if it does not yet exist.
-    def manifest_for(language)
-      @manifests[language.to_sym] ||= BundleManifest.new(self, language.to_sym)
+    # Returns the bundle manifest for the specified language and build mode.  
+    # The manifest will be created if it does not yet exist.
+    def manifest_for(language, build_mode)
+      manifest_key = [build_mode.to_s, language.to_s].join(':').to_sym
+      @manifests[manifest_key] ||= BundleManifest.new(self, language.to_sym, build_mode.to_sym)
     end
     
     # ==== Returns
@@ -541,8 +637,9 @@ module SproutCore
       ret.compact.map { |x| LONG_LANGUAGE_MAP[x.to_sym] || x.to_sym }.uniq
     end
     
-    # Finds the actual lproj directory (in the source) for the language code.  If the named
-    # language does not exist, returns the lproj for the preferred language.
+    # Finds the actual lproj directory (in the source) for the language code.  
+    # If the named language does not exist, returns the lproj for the 
+    # preferred language.
     def lproj_for(language)
       
       # try language as passed in.
@@ -561,12 +658,13 @@ module SproutCore
         return ret if File.exists?(File.join(source_root,ret))
       end
       
-      # failed, return using preferred_language unless this is the preferred language
+      # failed, return using preferred_language unless this is the preferred 
+      # language
       ret = (language != preferred_language) ? lproj_for(preferred_language) : nil
       return ret unless ret.nil?
       
-      # Super-ultra massive fail.  Possible that no localized resources exist at all.
-      # Return english.lproj and hope for the best
+      # Super-ultra massive fail.  Possible that no localized resources exist 
+      # at all. Return english.lproj and hope for the best
       return 'english.lproj' 
     end
     
@@ -577,8 +675,8 @@ module SproutCore
     
     protected
     
-    # Converts the named path to a fully qualified path name using the library root, if it
-    # does not begin with a slash
+    # Converts the named path to a fully qualified path name using the library 
+    # root, if it does not begin with a slash
     def normalize_path(path)
       (path[0] == '/'[0]) ? path : File.join(library_root, path)
     end

data/lib/sproutcore/bundle_manifest.rb

@@ -2,22 +2,24 @@ require 'yaml'
 
 module SproutCore
   
-  # A Bundle Manifest describes all of the resources in a bundle, including mapping their
-  # source paths, destination paths, and urls.
+  # A Bundle Manifest describes all of the resources in a bundle, including 
+  # mapping their source paths, destination paths, and urls.
   #
-  # A Bundle will create a manifest for every language you request from it.  If you invoke
-  # reload! on the bundle, it will dispose of its manifests and rebuild them.
+  # A Bundle will create a manifest for every language you request from it.  
+  # If you invoke reload! on the bundle, it will dispose of its manifests and 
+  # rebuild them.
   #
   class BundleManifest
     
     CACHED_TYPES = [:javascript, :stylesheet, :fixture, :test]
     SYMLINKED_TYPES = [:resource]
     
-    attr_reader :bundle, :language
+    attr_reader :bundle, :language, :build_mode
     
-    def initialize(bundle, language)
+    def initialize(bundle, language, build_mode)
       @bundle = bundle
       @language = language
+      @build_mode = build_mode
       @entries_by_type = {} # entries by type
       @entries_by_filename = {} # entries by files
       build!
@@ -67,15 +69,16 @@ module SproutCore
       end
       
       # STEP 3: If in development build mode:
-      if bundle.build_mode == :development
+      if self.build_mode == :development
         
         #  a. Merge fixture types into JS types & tests
         unless entries[:fixture].nil?
           entries[:javascript] = (entries[:javascript] || []) + entries[:fixture]  
         end
       
-        #  b. Rewrite all of the JS & CSS file paths and URLs to point to cached versions
-        #     (Cached versions are written to _cache/filename-ctime.ext)
+        #  b. Rewrite all of the JS & CSS file paths and URLs to point to 
+        # cached versions 
+        # (Cached versions are written to _cache/filename-ctime.ext)
         (entries[:javascript] ||= []).each do | entry |
           setup_timestamp_token(entry)
         end
@@ -99,7 +102,7 @@ module SproutCore
       # STEP 5: Add entry for javascript.js & stylesheet.js.  If in production mode, set
       # these to visible and hide the composite.  If in dev mode, do the opposite.
       
-      hide_composite = (bundle.build_mode != :development)
+      hide_composite = (self.build_mode != :development)
   
       #  a. Combine the JS file paths into a single entry for the javascript.js
       if (working = entries[:javascript]) && working.size>0
@@ -204,8 +207,6 @@ module SproutCore
         :test
       when /^fixtures\/.+\.js$/
         :fixture
-      when /\.html$/
-        :html
       when /\.rhtml$/
         :html
       when /\.html.erb$/
@@ -221,9 +222,10 @@ module SproutCore
       end
     end
     
-    # Build an entry for the resource at the named src_path (relative to the source_root)
-    # This should assume we are in going to simply build each resource into the build root
-    # without combining files, but not using our _src symlink magic.
+    # Build an entry for the resource at the named src_path (relative to the 
+    # source_root) This should assume we are in going to simply build each 
+    # resource into the build root without combining files, but not using our 
+    # _src symlink magic.
     def build_entry_for(src_path, src_type, composite=nil, hide_composite = true)
       ret = ManifestEntry.new
       ret.ext = File.extname(src_path)[1..-1] || '' # easy stuff
@@ -248,15 +250,15 @@ module SproutCore
       
       # The build path is the build_root + the filename
       # The URL is the url root + the language code + filename
-      # also add in _cache or _sym in certain cases.  This is just more efficient than doing
-      # it later.
+      # also add in _cache or _sym in certain cases.  This is just more 
+      # efficient than doing it later.
       url_root = (src_path == 'index.html') ? bundle.index_root : bundle.url_root
       cache_link = nil
       use_symlink =false
       
-      # Note: you can only access real resources via the cache.  If the entry is a composite
-      # then do not go through cache.
-      if (bundle.build_mode == :development) && composite.nil?
+      # Note: you can only access real resources via the cache.  If the entry 
+      # is a composite then do not go through cache.
+      if (self.build_mode == :development) && composite.nil?
         cache_link = '_cache' if CACHED_TYPES.include?(src_type)
         use_symlink = true if SYMLINKED_TYPES.include?(src_type)
       end
@@ -293,7 +295,8 @@ module SproutCore
   # filename::     path relative to the built language (e.g. sproutcore/en) less file extension
   # ext::          the file extension
   # source_path:: absolute paths into source that will comprise this resource
-  # url::          the url that should be used to reference this resource
+  # url::          the url that should be used to reference this resource in the current mode.
+  # build_url::    the url that will be used to referene this resource in production.  
   # build_path::   absolute path to the compiled resource
   # type::         the top-level category
   # original_path:: save the original path used to build this entry