sproutcore 1.0.1046 → 1.0.1049.pre.1

data/lib/sproutcore/models/hash_struct.rb

@@ -6,7 +6,7 @@
 # ===========================================================================
 
 module SC
-  
+
   # A HashStruct is a type of hash that can also be accessed as a structed
   # (like an OpenStruct).  It also treats strings and symbols as the same
   # for keys.
@@ -27,34 +27,37 @@ module SC
       end
       sibling
     end
-    
+
     # Returns true if the receiver has all of the options set
     def has_options?(opts = {})
       opts.each do |key, value|
-        return false if self[key] != value
+        this_value = self[key.to_sym]
+        return false if (this_value != value)
       end
       return true
     end
-    
+
     def to_hash
       ret = {}
       each { |key, value| ret[key] = value }
       return ret
     end
-    
+
     ######################################################
     # INTERNAL SUPPORT
     #
 
     # Pass in any options you want set initially on the manifest entry.
     def initialize(opts = {})
-      super
-      self.merge!(opts)
+      super()
+      opts.each do |k,v|
+        self[k.to_sym] = v
+      end
     end
 
     # Allow for method-like access to hash also...
-    def method_missing(method_name, *args)
-      method_name = method_name.to_s
+    def method_missing(id, *args)
+      method_name = id.to_s
       if method_name =~ /=$/
         # suppoert property? = true
         if method_name =~ /\?=$/
@@ -64,29 +67,41 @@ module SC
           method_name = method_name[0..-2]
           value = args[0]
         end
-        self[method_name] = value
-        
+        print_first_caller(method_name)
+        self[method_name.to_sym] = value
+
       # convert property? => !!self[:property]
       elsif method_name =~ /\?$/
-        !!self[method_name[0..-2]]
+        !!self[method_name[0..-2].to_sym]
       else
-        self[method_name]
+        print_first_caller(method_name)
+        self[method_name.to_sym]
       end
     end
-    
-    # Treat all keys like symbols
-    def [](key)
-      sym_key = key.to_sym rescue nil
-      raise "HashStruct cannot convert #{key} to symbol" if sym_key.nil?
-      fetch(sym_key, nil)
-    end
 
-    def []=(key, value)
-      sym_key = key.to_sym rescue nil
-      raise "HashStruct cannot convert #{key} to symbol" if sym_key.nil?
-      store(sym_key, value)
+    def print_first_caller(*extras)
+      return unless ENV["DEBUG_HS"]
+      first_caller = caller.find {|str| str !~ /hash_struct\.rb/ }
+
+      unless first_caller =~ %r{spec/.*(_spec|spec_helper).rb}
+        puts "---"
+        p extras
+        puts first_caller
+        puts "---"
+      end
     end
 
+    # When using the optimized #[] lookup form,require a Symbol
+    # def [](key) super end
+
+    #def []=(key, value)
+    #  print_first_caller(key, value) unless key.is_a?(Symbol)
+    #  sym_key = key.to_sym rescue nil
+    #  raise "HashStruct cannot convert #{key} to symbol" if sym_key.nil?
+    #
+    #  super(sym_key, value)
+    #end
+
     # Reimplement merge! to go through the []=() method so that keys can be
     # symbolized
     def merge!(other_hash)
@@ -96,14 +111,14 @@ module SC
       end
       return self
     end
-    
+
     # Reimplement to return a new HashStruct
     def merge(other_hash)
       ret = self.class.new.merge!(self)
       ret.merge!(other_hash) if other_hash != self
-      return ret 
+      return ret
     end
-    
+
   end
 end
 

data/lib/sproutcore/models/manifest.rb

@@ -8,35 +8,39 @@
 require 'set'
 
 module SC
-  
-  # A Manifest describes all of the files that should be found inside of a 
+
+  # A Manifest describes all of the files that should be found inside of a
   # single bundle/language.  A Manifest can have global properties assigned to
   # it which will be used by the manifest entries themselves.  This is largly
   # defined by the manifest build tasks.
   #
   class Manifest < HashStruct
-    
     attr_reader :target
-    
-    def entries(opts={})
-      include_hidden = opts[:hidden] || false
-      return @entries if include_hidden
-      @entries.reject { |e| e.hidden? }
+
+    def entries(opts = {})
+      opts[:hidden] ? @entries : @entries.visible
+    end
+
+    class EntryList < Array
+      def visible
+        each.reject { |entry| entry.hidden? }
+      end
     end
-    
+
     def initialize(target, opts)
       super(opts)
-      @target = target 
-      @entries = []
+      @target = target
+      @entries = EntryList.new
+      @staging_uuid = 0
     end
 
     def inspect
       opts = variation.dup
-      opts[:target] = target.target_name
+      opts[:target] = target[:target_name]
       desc = opts.keys.sort { |a,b| a.to_s <=> b.to_s }.map { |k| [k, opts[k]].join("=") }.join(" ")
       "SC::Manifest(#{desc})"
     end
-    
+
     # Invoked just before a manifest is built.  If you load a manifest file
     # this method will not be invoked.
     # === Returns
@@ -47,19 +51,19 @@ module SC
         target.prepare!
         if target.buildfile.task_defined? 'manifest:prepare'
           target.buildfile.invoke 'manifest:prepare',
-            :manifest => self, 
-            :target => self.target, 
+            :manifest => self,
+            :target => self.target,
             :config => self.target.config,
             :project => self.target.project
         end
-      end 
+      end
       return self
     end
 
     def prepared?; @is_prepared || false; end
 
-    # Returns the options that select the current variation.  The current 
-    # implementation is hardcoded to return the language, but this may be 
+    # Returns the options that select the current variation.  The current
+    # implementation is hardcoded to return the language, but this may be
     # generalized in the future.
     #
     # You can use this method to select the same manifest in other targets.
@@ -67,11 +71,11 @@ module SC
     # === Examples
     #
     #   other_manifest = other_target.manifest_for(my_manifest.variation)
-    # 
+    #
     def variation
-      return { :language => self.language }
+      return { :language => self[:language] }
     end
-    
+
     # Builds the manifest if it has not been built yet.
     def build!
       prepare!
@@ -87,10 +91,10 @@ module SC
       end
       return self
     end
-    
+
     def built?; @is_built; end
-    
-    # Resets the manifest entries.  this is called before a build is 
+
+    # Resets the manifest entries.  this is called before a build is
     # performed. This will reset only the entries, none of the other props.
     #
     # === Returns
@@ -98,14 +102,14 @@ module SC
     #
     def reset_entries!
       @is_built = false
-      @entries = []
+      @entries = EntryList.new
       return self
     end
-      
+
     # Returns the manifest as a hash that can be serialized to json or yaml
     def to_hash(opts={})
       ret = super()
-      
+
       if only_keys = opts[:only]
         filtered = {}
         ret.each do |key, value|
@@ -116,7 +120,7 @@ module SC
 
       # Always include entries unless they are explicitly excluded
       ret[:entries] = entries(opts).map { |e| e.to_hash(opts) }
-      
+
       if except_keys = opts[:except]
         filtered = {}
         ret.each do |key, value|
@@ -129,7 +133,7 @@ module SC
       ret[:target_name] = target.target_name
       return ret
     end
-    
+
     # Loads a hash into the manifest, replacing whatever contents are
     # already here.
     #
@@ -142,12 +146,14 @@ module SC
     def load(hash)
       merge!(hash)
       entry_hashes = self.delete(:entries) || []
-      @entries = entry_hashes.map do |opts|
-        ManifestEntry.new(self, opts)
+      @entries = EntryList.new
+      entry_hashes.each do |opts|
+        @entries << ManifestEntry.new(self, opts)
       end
-      return self 
+
+      return self
     end
-    
+
     # Creates a new manifest entry with the passed options.  Will setup extra
     # tracking needed by entry.
     #
@@ -160,25 +166,25 @@ module SC
     def add_entry(filename, opts = {})
       opts[:filename] = filename
       @entries << (ret = ManifestEntry.new(self, opts)).prepare!
-      return ret 
+      return ret
     end
-    
+
     # Creates a composite entry with the passed filename.  Expects you to
     # a source_entries option.  This automatically hides the source entries
     # unless you pass the :hide_entries => false option.
     def add_composite(filename, opts = {})
       should_hide_entries = opts.delete(:hide_entries)
       should_hide_entries = true if should_hide_entries.nil?
-      
+
       opts[:filename] = filename
       opts[:source_entries] ||= []
       opts[:composite] = true
       @entries << (ret = ManifestEntry.new(self, opts)).prepare!
-      
-      ret.source_entries.each { |entry| entry.hide! } if should_hide_entries
-      return ret 
+
+      ret[:source_entries].each { |entry| entry.hide! } if should_hide_entries
+      return ret
     end
-    
+
     # Creates an entry with will apply a build task to the source entry. Use
     # this method when you need to apply a build task to an entry to convert
     # it into another format or to perform some kind of incremental build.
@@ -194,62 +200,65 @@ module SC
     #  :ext:: the new file extension. if you don't override, the build_path
     #    staging_path and filename will all be adjusted to have this ext.
     #  :hide_entry:: the source entry will be hidden unless set to false
-    # === Returns 
+    # === Returns
     #   the new ManifestEntry
-    # 
+    #
     def add_transform(entry, opts ={})
       should_hide_entries = opts.delete(:hide_entries) || opts.delete(:hide_entry)
       should_hide_entries = true if should_hide_entries.nil?
 
       # Clone important properties to new transform...
       opts = HashStruct.new(opts)
-      %w(filename build_path url).each do |key|
-        opts[key] ||= entry[key]
-      end
-      
-      # generate a unique staging path.  If the original entry has its 
+
+      opts[:filename]   ||= entry[:filename]
+      opts[:build_path] ||= entry[:build_path]
+      opts[:url]        ||= entry[:url]
+
+      # generate a unique staging path.  If the original entry has its
       # staging_path set == to source_root (optimization for build:copy), then
       # first rebase staging path against the staging root.
-      if (staging_path = entry.staging_path) == entry.source_path
-        staging_path = File.join(self.staging_root, entry.filename) 
+      if (staging_path = entry[:staging_path]) == entry[:source_path]
+        staging_path = File.join(self[:staging_root], entry[:filename])
       end
-      opts.staging_path ||= unique_staging_path(staging_path)
-      
-      # generate a unique cache path from the staging page.  just sub the 
+
+      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)
-      
+      opts[:cache_path] ||= unique_cache_path(entry[:cache_path])
+
       # copy other useful entries
-      opts.source_entry   = entry
-      opts.source_entries = [entry]
-      opts.composite      = true
-      opts.transform      = true # make .transform? = true
-      
+      opts[:source_entry]   = entry
+      opts[:source_entries] = [entry]
+      opts[:composite]      = true
+      opts[:transform]      = true # make .transform? = true
+
       # Normalize to new extension if provided.  else copy ext from entry...
-      if opts.ext
-        %w(filename build_path staging_path url).each do |key|
-          opts[key] = opts[key].ext(opts.ext)
-        end
-        opts.ext = opts.ext.to_s
+      if ext = opts[:ext]
+        opts[:url] = opts[:url].replace_ext(ext)
+        opts[:staging_path] = opts[:staging_path].replace_ext(ext)
+        opts[:build_path] = opts[:build_path].replace_ext(ext)
+        opts[:filename] = opts[:filename].replace_ext(ext)
       else
-        opts.ext = entry.ext
+        opts[:ext] = entry[:ext]
       end
 
       # Create new entry and hide old one
       @entries << (ret = ManifestEntry.new(self, opts)).prepare!
+
       entry.hide! if should_hide_entries
-      
+
       # done!
-      return ret 
+      return ret
     end
-    
+
     # Finds the first visible entry with the specified filename.  You may also
-    # pass any number of additional options which will be used to further 
+    # pass any number of additional options which will be used to further
     # restrict your search.  If you pass :hidden => true only hidden entries
     # will be returned.  Otherwise, only visible entries will be returned.
     #
     # You may also include the name of the target you would like to search.
-    # The target name should be relative to the target you are requesting 
+    # The target name should be relative to the target you are requesting
     # from.
     #
     # === Examples
@@ -265,7 +274,7 @@ module SC
     #
     # === Params
     #   filename:: the filename to search
-    # 
+    #
     # === Options
     #   :hidden:: if true, include hidden entries
     #
@@ -283,12 +292,12 @@ module SC
         manifest = _manifest_target.manifest_for(self.variation)
         manifest.build!
       end
-      
-      manifest.entries(:hidden => opts[:hidden]).find do |entry| 
-        (entry.filename == filename) && entry.has_options?(opts)
+
+      manifest.entries(opts).find do |entry|
+        (entry[:filename] == filename) && entry.has_options?(opts)
       end
     end
-    
+
     # Attempts to find any entry matching the specified static URL fragment.
     # the fragment you pass may contain only a portion of the url, and it may
     # exclude the file extension if you choose.  The filter will select the
@@ -297,16 +306,16 @@ module SC
     # This is the root search method used by static_url().
     #
     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
@@ -314,66 +323,63 @@ module SC
       else
         cur_manifest = self
       end
-      
+
       extname = File.extname(fragment)
+      extname = nil if extname.empty?
+
       rootname = fragment.sub(/#{extname}$/, '')
 
       # 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}$/,'')
-          ext_match = (extname.nil? || extname.size == 0) || (entry_extname == extname)
-        else
-          ext_match = false
-        end
-      
-        !(ext_match && (/#{rootname}$/ =~ entry_rootname))
+      ret = cur_manifest.entries(opts).find do |entry|
+        next unless entry.has_options?(opts)
+        next if extname && (entry.extension != extname)
+
+        entry.rootname[-rootname.length, rootname.length] == rootname
       end
-      
-      ret = ret.first
-        
+
+      return ret if ret
+
       # if no match was found, search the same manifests in required targets
-      if ret.nil?
-        seen = Set.new if seen.nil?
-        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!
-          ret = manifest.find_entry(fragment, opts, seen)
-          break unless ret.nil?
-        end
+      seen ||= Set.new
+      seen << cur_manifest.target
+
+      cur_manifest.target.expand_required_targets(:theme => true).each do |t|
+        next if seen.include?(t) # avoid recursion
+
+        manifest = t.manifest_for(self.variation).build!
+        ret = manifest.find_entry(fragment, opts, seen)
+        return ret if ret
       end
-      return ret
+
+      nil
     end
-    
+
     # Finds a unique staging path starting with the root proposed staging
     # path.
     def unique_staging_path(path)
-      paths = entries(:hidden => true).map { |e| e.staging_path }
-      while paths.include?(path)
-        path = path.sub(/(__\$[0-9]+)?(\.\w+)?$/,"__#{next_staging_uuid}\\2")
-      end
+      # paths = entries(:hidden => true).map { |e| e[:staging_path] }
+      # while paths.include?(path)
+      #   path = path.sub(/(__\$[0-9]+)?(\.\w+)?$/,"__#{next_staging_uuid}\\2")
+      # 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
+      # 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
-    
+
     def next_staging_uuid
-      self.staging_uuid = (self.staging_uuid || 0) + 1
+      @staging_uuid += 1
     end
-    
+
   end
-  
+
 end