sproutcore 1.0.1046 → 1.0.1049.pre.1

data/lib/sproutcore/models/manifest_entry.rb

@@ -19,17 +19,25 @@ module SC
   #  build_rule::   name of the task to invoke to build this entry
   #  build_path::   absolute path to place built files
   #  staging_path:: absolute path to place staging files
-  #  source_path::  absolute path to source file  
+  #  source_path::  absolute path to source file
   #  source_paths:: arrays of source paths to use for build. alt to single
   #  is_hidden:: if true, entry is not included in build
   #
   class ManifestEntry < HashStruct
 
     def initialize(manifest, opts={})
-      @manifest = manifest # store manifest has ivar
+      @manifest = manifest
       super(opts)
     end
-    
+
+    def normalized_filename
+      @normalized_filename = self[:filename].to_s.downcase
+    end
+
+    def extensionless_filename
+      @extensionless_filename ||= normalized_filename.ext("")
+    end
+
     # invoked whenever the manifest entry is first created.  This will invoke
     # the entry:prepare task if defined.
     def prepare!
@@ -47,19 +55,19 @@ module SC
       end
       return self
     end
-    
+
     def prepared?; @is_prepared || false; end
-    
-    def inspect 
-      "SC::ManifestEntry(#{filename}, build_task=>#{self.build_task}, entry_type=>#{self.entry_type}, is_hidden=>#{self.hidden?})"
+
+    def inspect
+      "SC::ManifestEntry(#{self[:filename]}, build_task=>#{self[:build_task]}, entry_type=>#{self[:entry_type]}, is_hidden=>#{self.hidden?})"
     end
-    
+
     def to_hash(opts={})
       ret = super()
       if ret[:source_entries]
         ret[:source_entries] = ret[:source_entries].map { |e| e.to_hash(opts)}
       end
-      
+
       if only_keys = opts[:only]
         filtered = {}
         ret.each do |key, value|
@@ -67,7 +75,7 @@ module SC
         end
         ret = filtered
       end
-      
+
       if except_keys = opts[:except]
         filtered = {}
         ret.each do |key, value|
@@ -78,42 +86,53 @@ module SC
 
       return ret
     end
-    
+
     ######################################################
     # CONVENIENCE METHODS
     #
-    
-    # true if the current manifest entry should not be included in the 
+
+    # true if the current manifest entry should not be included in the
     # build.  The entry may still be used as an input for other entries and
     # it may still be referenced directly
     def hidden?; self[:hidden] ||= false; end
-    
+
     # Sets the entry's hidden? property to true
-    def hide!; self[:hidden] = true; self; end
+    def hide!
+      self[:hidden] = true
+      self
+    end
 
     # true if the manifest entry represents a composite resource built from
-    # one or more source entries.  Composite resources will have their 
+    # one or more source entries.  Composite resources will have their
     # source_entries staged before the entry itself is built to staged.
     def composite?; self[:composite]; end
-    
+
     # Marks the entry as composite.  Returns self
     def composite!; self[:composite] = true; self; end
-    
+
+    def extension
+      @extension ||= File.extname(self[:filename])
+    end
+
+    def rootname
+      @rootname ||= self[:filename].sub(/#{extension}$/, '')
+    end
+
     # The owner manifest
     attr_accessor :manifest
-    
+
     def dynamic?; self[:dynamic]; end
-    
+
     # The owner target
     def target; @target ||= manifest.target; end
-    
+
     # dynamic_required targets, only applicable to bundle_info entries
     def targets; self[:targets]; end
-    
+
     # variation for dynamic_required targets, only applicable to bundle_info
     # entries
     def variation; self[:variation]; end
-    
+
     # Returns a timestamp for when this file was last changed.  This will
     # reach back to the source entries, finding the latest original entry.
     def timestamp
@@ -128,37 +147,37 @@ module SC
         timestamps.max
       elsif composite?
 
-        source_entries.map { |e| e.timestamp || 0 }.max || Time.now.to_i
+        self[:source_entries].map { |e| e.timestamp || 0 }.max || Time.now.to_i
       else
-        File.exist?(source_path) ? File.mtime(source_path).to_i : 0
+        File.exist?(self[:source_path]) ? File.mtime(self[:source_path]).to_i : 0
       end
     end
-    
-    # Returns a URL with a possible timestamp token appended to the end of 
+
+    # Returns a URL with a possible timestamp token appended to the end of
     # the entry if the target's timestamp_url config is set, or with a randomly
     # assigned domain name prepended if hyper-domaining is turned on.  Otherwise
     # returns the URL itself.
     def cacheable_url
-      ret = self.url
-      ret = [ret, self.timestamp].join('?') if target.config.timestamp_urls
-      if target.config.hyper_domaining
-        ret = [self.hyperdomain_prefix(ret), ret].join('') 
+      ret = self[:url]
+      ret = [ret, self.timestamp].join('?') if target.config[:timestamp_urls]
+      if target.config[:hyper_domaining]
+        ret = [self.hyperdomain_prefix(ret), ret].join('')
       end
       return ret
     end
-    
+
     # If the hyper_domaining config is an array of strings, this will select
     # one of them based on the hash of the URL, and provide an absolute URL
     # to the entry. The hyperdomain includes the protocol. (http://, etc)
     def hyperdomain_prefix(url)
       hyperdomains = target.config.hyper_domaining
       index = url.hash % hyperdomains.length
-      
+
       return "#{hyperdomains[index]}"
     end
-    
-    
-    # Scans the source paths (first staging any source entries) for the 
+
+
+    # Scans the source paths (first staging any source entries) for the
     # passed regex.  Your block will be executed with each line that matched.
     # Returns the results of each block
     #
@@ -167,126 +186,125 @@ module SC
     #  entry.extract_content(/require\((.+)\)/) { |line| $1 }
     #
     def scan_source(regexp, &block)
-      if entries = self.source_entries
+      if entries = self[:source_entries]
         entries.each { |entry| entry.stage! }
       end
 
-      if paths = self.source_paths
+      if paths = self[:source_paths]
         paths.each do |path|
           next unless File.exist?(path)
-          
-          # fine all directives in the source.  use file cache to make this 
+
+          # fine all directives in the source.  use file cache to make this
           # fast later on.
-          results = target.file_attr('scan_source', path) do
-            ret = []
-            File.readlines(path).each do |line|
-              if (line.valid_encoding?)
-                line.scan(regexp) { |result| ret << result }
-              end
-            end 
-            ret
+          begin
+            results = target.file_attr('scan_source', path) do
+              File.read(path).scan(regexp)
+            end
+          rescue ArgumentError
+            puts path
+            raise
           end
-          
+
           results.each { |result| yield(result) }
-          
+
         end
       end
     end
 
     BUILD_DIRECTIVES_REGEX = /(sc_require|require|sc_resource)\(\s*(['"])(.+)['"]\s*\)/
-    
+
     # Scans the source paths for standard build directives and annotates the
-    # entry accordingly.  You should only call this method on entries 
+    # entry accordingly.  You should only call this method on entries
     # representing CSS or JavaScript resources.  It will yield undefined
     # results on all other file types.
     #
     def discover_build_directives!
-      
+
       target.begin_attr_changes
-      
-      self.required = []
-      entry = self.transform? ? self.source_entry : self
+
+      self[:required] = []
+      entry = self.transform? ? self[:source_entry] : self
       entry.scan_source(BUILD_DIRECTIVES_REGEX) do |matches|
         # strip off any file ext
         filename = matches[2].ext ''
         case matches[0]
         when 'sc_require'
-          self.required << filename
+          self[:required] << filename
         when 'require'
-          self.required << filename
+          self[:required] << filename
         when 'sc_resource'
-          self.resource = filename
+          self[:resource] = filename
         end
       end
-      
+
       target.end_attr_changes
-      
+
     end
-    
+
     ######################################################
     # BUILDING
     #
 
-    # Invokes the entry's build task to build to its build path.  If the 
+    # Invokes the entry's build task to build to its build path.  If the
     # entry has source entries, they will be staged first.
     def build!
-      build_to self.build_path
+      build_to self[:build_path]
     end
 
-    # Builds an entry into its staging path.  This method can be invoked on 
+    # Builds an entry into its staging path.  This method can be invoked on
     # any entry whose output is required by another entry to be built.
     def stage!
-      build_to self.staging_path
+      build_to self[:staging_path]
     end
-    
-    # Removes the build and staging files for this entry so the next 
+
+    # Removes the build and staging files for this entry so the next
     # build will rebuild.
     #
     # === Returns
     #  self
     def clean!
-      FileUtils.rm(self.build_path) if File.exist?(self.build_path)
-      FileUtils.rm(self.staging_path) if File.exist?(self.staging_path)
-      return self 
+      FileUtils.rm(self[:build_path]) if File.exist?(self[:build_path])
+      FileUtils.rm(self[:staging_path]) if File.exist?(self[:staging_path])
+      return self
     end
-        
+
     # Diagnostic function.  Indicates what will happen if you called build
     def inspect_build_state
-      inspect_build_to self.build_path
+      inspect_build_to self[:build_path]
     end
-    
+
     def inspect_staging_state
-      inspect_build_to self.staging_path
+      inspect_build_to self[:staging_path]
     end
-    
-    
+
+
     def inline_contents
-      unless File.exists?(self.staging_path)
-    
+      unless File.exists?(self[:staging_path])
+
         # stage source entries if needed...
         (self.source_entries || []).each { |e| e.stage! } if composite?
-    
+
         # get build task and build it
         buildfile = manifest.target.buildfile
         if !buildfile.task_defined?(self.build_task)
           raise "Could not build entry #{self.filename} because build task '#{self.build_task}' is not defined"
         end
-    
+
         buildfile.invoke 'build:minify:inline_javascript',
           :entry => self,
           :manifest => self.manifest,
           :target => self.manifest.target,
           :config => self.manifest.target.config,
           :project => self.manifest.target.project,
-          :src_path => self.source_path,
-          :src_paths => self.source_paths,
-          :dst_path => self.staging_path
-      end
-      File.readlines(self.staging_path)
+          :src_path => self[:source_path],
+          :src_paths => self[:source_paths],
+          :dst_path => self[:staging_path]
+        end
+      File.readlines(self[:staging_path])
     end
-     
-    private 
-    
+
+    private
+
     def inspect_build_to(dst_path)
       return "#{filename}: dst #{dst_path} not found" if !File.exist?(dst_path)
       dst_mtime = File.mtime(dst_path).to_i
@@ -295,43 +313,43 @@ module SC
           puts "WARN: nil path in #{filename}"
           next
         end
-        
+
         return "#{filename}: src #{path} not found" if !File.exist?(path)
-        
+
         src_mtime = File.mtime(path).to_i
         return "#{filename}: src #{path} is newer [#{dst_mtime} < #{src_mtime}]" if dst_mtime < src_mtime
       end
       return "#{filename}: will not build"
     end
-    
+
     def build_to(dst_path)
-      if self.build_task.nil?
-        raise "no build task defined for #{self.filename}" 
+      if self[:build_task].nil?
+        raise "no build task defined for #{self.filename}"
       end
 
       # stage source entries if needed...
-      (self.source_entries || []).each { |e| e.stage! } if composite?
-      
+      (self[:source_entries] || []).each { |e| e.stage! } if composite?
+
       # get build task and build it
       buildfile = manifest.target.buildfile
-      if !buildfile.task_defined?(self.build_task)
-        raise "Could not build entry #{self.filename} because build task '#{self.build_task}' is not defined"
+      if !buildfile.task_defined?(self[:build_task])
+        raise "Could not build entry #{self[:filename]} because build task '#{self[:build_task]}' is not defined"
       end
-      
-      buildfile.invoke self.build_task,
+
+      buildfile.invoke self[:build_task],
         :entry => self,
         :manifest => self.manifest,
         :target => self.manifest.target,
         :config => self.manifest.target.config,
         :project => self.manifest.target.project,
-        :src_path => self.source_path,
-        :src_paths => self.source_paths,
+        :src_path => self[:source_path],
+        :src_paths => self[:source_paths],
         :dst_path => dst_path
-        
+
       return self
     end
-    
+
 
   end
-  
+
 end

data/lib/sproutcore/models/project.rb

@@ -6,13 +6,13 @@
 # ===========================================================================
 
 module SC
-  
+
   # A project describes a collection of targets that you can build.  Normally
-  # you instantiate a project by calling Project.load() method.  You should 
+  # you instantiate a project by calling Project.load() method.  You should
   # pass in the path of the project and the project type.  The project type
-  # will determine the namespace used in the buildfile to detect and load 
+  # will determine the namespace used in the buildfile to detect and load
   # tasks.
-  # 
+  #
   # == Examples
   #
   # Load a SproutCore-style project:
@@ -28,25 +28,25 @@ module SC
   # When you load a project, here is what happens:
   #
   # 1. Locate and load Buildfiles, if any are found
-  # 2. Run project_type:target:find for all targets defined for the project.  
+  # 2. Run project_type:target:find for all targets defined for the project.
   #    this will locate and define the targets for the project
   # 3. If you request a build of a particular resource, a manifest will be
   #    built for the target.  This manifest contains a series of rules that
   #    can be invoked in order to build the named resource.
   #
   class Project
-    
+
     # the path of this project
     attr_reader :project_root
-    
+
     # Parent project this project shoud inherit build rules and targets from
-    attr_reader :parent_project 
-    
+    attr_reader :parent_project
+
     def inspect
       "SC::Project(#{File.basename(project_root || '')})"
     end
-    
-    # When a new project is created, you may optionally pass either a 
+
+    # When a new project is created, you may optionally pass either a
     # :parent option or a :paths options.  If you pass the paths option, then
     # this class will search the paths for projects and initialize them as
     # parent projects to this one.
@@ -65,19 +65,19 @@ module SC
       candidate = nil
       while path
         if Buildfile.has_buildfile?(path)
-          candidate = path 
-          
-          # If we find a buildfile and the buildfile explicitly states 
+          candidate = path
+
+          # If we find a buildfile and the buildfile explicitly states
           # that it is a project, then just stop here..
-          break if Buildfile.load(path).project? 
+          break if Buildfile.load(path).project?
         end
-            
+
         new_path = File.dirname(path)
         path = (new_path == path) ? nil : new_path
       end
       (candidate) ? self.new(candidate, opts) : nil
     end
-    
+
     # Returns a new project loaded from the specified path
     def self.load(project_root, opts={})
       new project_root, opts
@@ -86,11 +86,11 @@ module SC
     def reload!
       @buildfile = @targets = nil
     end
-    
+
     # The current buildfile for the project.  The buildfile is calculated by
-    # merging any parent project buildfile with the contents of any 
+    # merging any parent project buildfile with the contents of any
     # buildfiles found in the current project.  Buildfiles include any file
-    # named "Buildfile", "sc-config", or "sc-config.rb".  You can also 
+    # named "Buildfile", "sc-config", or "sc-config.rb".  You can also
     # specify your own buildfile names with the "buildfile_names" config in
     # the SC.env.
     #
@@ -128,7 +128,7 @@ module SC
     # by target_name.
     #
     # The first time this method is called, the project will automatically
-    # clone any targets from a parent project, and then calls 
+    # clone any targets from a parent project, and then calls
     # find_targets_for() on itself to recursively discover any targets in
     # the project.
     #
@@ -140,19 +140,19 @@ module SC
     #
     def targets
       return @targets unless @targets.nil?
-      
+
       # Create an empty targets hash or clone from parent project
       @targets = HashStruct.new
       dup_targets(parent_project.targets) if parent_project
 
-      # find targets inside project.  
+      # find targets inside project.
       find_targets_for(project_root, nil, self.config)
-      
+
       return @targets
     end
 
-    # Returns the target with the specified target name.  The target name 
-    # may be absolute path or not, both will lookup from the top.  
+    # Returns the target with the specified target name.  The target name
+    # may be absolute path or not, both will lookup from the top.
     #
     # === Params
     #  target_name:: the target to lookup
@@ -161,12 +161,12 @@ module SC
     #  a Target instance or nil if no matching target could be found
     #
     def target_for(target_name)
-      ret = (targets[target_name.to_s.sub(/^([^\/])/,'/\1')])
+      ret = (targets[target_name.to_s.sub(/^([^\/])/,'/\1').to_sym])
       ret.nil? ? nil : ret
     end
-    
+
     # Adds a new target to the project with the passed target name.  Include
-    # the source_root for the target as well as any additional options you 
+    # the source_root for the target as well as any additional options you
     # want copied onto the target.  If a previous target was defined by the
     # same name it will be replaced by this one.
     #
@@ -181,20 +181,20 @@ module SC
     #  new target
     #
     def add_target(target_name, target_type, options={})
-      targets[target_name] = Target.new(target_name.to_sym, 
+      targets[target_name.to_sym] = Target.new(target_name.to_sym,
           target_type.to_sym, options.merge(:project => self))
     end
 
-    # Called by project to discover any targets within the project itself.  
-    # The default implementation will search the project root directory for 
-    # any directories matching those named in the "target_types" config. (See 
-    # Buildfile for documentation).  It will then recursively descend into 
-    # each target looking for further nested targets unless you've set the 
+    # Called by project to discover any targets within the project itself.
+    # The default implementation will search the project root directory for
+    # any directories matching those named in the "target_types" config. (See
+    # Buildfile for documentation).  It will then recursively descend into
+    # each target looking for further nested targets unless you've set the
     # "allow_nested_targets" config to false.
     #
     # If you need to change the way the project autodiscovers its own targets
-    # you can either change the "target_types" and "allow_nested_targets" 
-    # configs or you can override this method in your own ruby code to 
+    # you can either change the "target_types" and "allow_nested_targets"
+    # configs or you can override this method in your own ruby code to
     # do whatever kind of changes you want.
     #
     # === Params
@@ -206,11 +206,11 @@ module SC
     #  self
     #
     def find_targets_for(root_path, root_name, config)
-      
+
       # look for directories matching the target_types keys and create target
       # with target_types value as type. -- normalize to lowercase string
       target_types = {}
-      (config.target_types || {}).each do |key, value| 
+      (config[:target_types] || {}).each do |key, value|
         target_types[key.to_s.downcase] = value
       end
 
@@ -220,7 +220,7 @@ module SC
         next if target_type.nil?
         next unless File.directory?(dir_name)
 
-        # loop through each item in the directory.  
+        # loop through each item in the directory.
         Dir.glob(File.join(dir_name,'*')).each do |source_root|
           next unless File.directory?(source_root)
 
@@ -228,40 +228,40 @@ module SC
           target_name = [root_name, File.basename(source_root)] * '/'
           target = self.add_target target_name, target_type,
             :source_root => source_root
-          
+
           # if target's config allows nested targets, then call recursively
-          # asking the target's config allows the target's Buildfile to 
+          # asking the target's config allows the target's Buildfile to
           # override the default.
-          if target.config.allow_nested_targets
+          if target.config[:allow_nested_targets]
             find_targets_for(source_root, target_name, target.config)
           end
         end # Dir.glob
       end # target_type.each
       return self
-    end 
-    
+    end
+
     ################################################
     ## GENERATOR SUPPORT
     ##
-    
+
     # Attempts to discover and load a generator with the specified name from
     # the current project.  If the generator cannot be found, this method will
     # return nil.
     def generator_for(generator_name, opts={})
       opts[:target_project] = self
       return SC::Generator.load(generator_name, opts)
-    end 
-    
-    private 
-    
+    end
+
+    private
+
     # Loops through the hash of targets and adds them to the receiver.  This
     # is how we inherit inherit targets from a parent project.
     def dup_targets(to_dup)
       to_dup.each do | target_name, target |
-        add_target target_name, target.target_type, target.to_hash
+        add_target target_name, target[:target_type], target.to_hash
       end
     end
-        
+
   end
-  
-end
+
+end