sproutit-sproutcore 1.0.0.20090407205609

data/lib/sproutcore/models/manifest_entry.rb

@@ -0,0 +1,232 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+require 'ostruct'
+
+module SC
+
+  # A manifest entry describes a single item that can be built by the build
+  # system.  A manifest entry can be assigned any properties you like during
+  # the manifest build process.
+  #
+  # A ManifestEntry must have at least the following properties to build:
+  #
+  #  bundle::       owner bundle
+  #  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_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
+      super(opts)
+    end
+    
+    # invoked whenever the manifest entry is first created.  This will invoke
+    # the entry:prepare task if defined.
+    def prepare!
+      if !@is_prepared
+        @is_prepared = true
+        buildfile = manifest.target.buildfile
+        if buildfile.task_defined? 'entry:prepare'
+          buildfile.invoke 'entry:prepare',
+            :entry => self,
+            :manifest => self.manifest,
+            :target => self.manifest.target,
+            :config => self.manifest.target.config,
+            :project => self.manifest.target.project
+        end
+      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?})"
+    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|
+          filtered[key] = value if only_keys.include?(key)
+        end
+        ret = filtered
+      end
+      
+      if except_keys = opts[:except]
+        filtered = {}
+        ret.each do |key, value|
+          filtered[key] = value unless except_keys.include?(key)
+        end
+        ret = filtered
+      end
+
+      return ret
+    end
+    
+    ######################################################
+    # CONVENIENCE METHODS
+    #
+    
+    # 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
+
+    # true if the manifest entry represents a composite resource built from
+    # 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
+    
+    # The owner manifest
+    attr_accessor :manifest
+
+    # The owner target
+    def target; @target ||= manifest.target; 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
+      if composite?
+        source_entries.map { |e| e.timestamp }.max
+      else
+        File.exist?(source_path) ? File.mtime(source_path).to_i : 0
+      end
+    end
+    
+    # Returns a URL with a possible timestamp token appended to the end of 
+    # the entry if the target's timestamp_url config is set.  Otherwise
+    # returns the URL itself.
+    def cacheable_url
+      ret = self.url
+      ret = [ret, self.timestamp].join('?') if target.config.timestamp_urls
+      return ret
+    end
+    
+    # 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
+    #
+    # === Example
+    #
+    #  entry.extract_content(/require\((.+)\)/) { |line| $1 }
+    #
+    def scan_source(regexp, &block)
+      if entries = self.source_entries
+        entries.each { |entry| entry.stage! }
+      end
+
+      if paths = self.source_paths
+        paths.each do |path|
+          next unless File.exist?(path)
+          File.readlines(path).each do |line|
+            line.scan(regexp) { |result| yield(result) }
+          end 
+        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 
+    # representing CSS or JavaScript resources.  It will yield undefined
+    # results on all other file types.
+    #
+    def discover_build_directives!
+      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
+        when 'require':
+          self.required << filename
+        when 'sc_resource'
+          self.resource = filename
+        end
+      end
+    end
+    
+    ######################################################
+    # BUILDING
+    #
+
+    # 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
+    end
+
+    # 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
+    end
+    
+    # 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 
+    end
+        
+    private 
+    
+    def build_to(dst_path)
+      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?
+      
+      # 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 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,
+        :dst_path => dst_path
+        
+      return self
+    end  
+
+  end
+  
+end

data/lib/sproutcore/models/project.rb

@@ -0,0 +1,270 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+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 
+  # 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 
+  # tasks.
+  # 
+  # == Examples
+  #
+  # Load a SproutCore-style project:
+  #
+  #  Project.load('myproject', :sproutcore)
+  #
+  # Load a standard gcc-build project:
+  #
+  #  Project.load('myproject', :cc)
+  #
+  # == How a Project is Loaded
+  #
+  # When you load a project, here is what happens:
+  #
+  # 1. Kocate and load Buildfiles, if any are found
+  # 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 
+    
+    def inspect
+      "SC::Project(#{File.basename(project_root || '')})"
+    end
+    
+    # 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.
+    #
+    # If you pass a parent project, then this project will start out with a
+    # clone of the parent project's buildfile and targets.
+    #
+    def initialize(project_root, opts ={})
+      @project_root = project_root
+      @parent_project = opts[:parent]
+      @buildfile = @targets = nil
+    end
+
+    # Attempts to find the nearest project root
+    def self.load_nearest_project(path, opts={})
+      candidate = nil
+      while path
+        if Buildfile.has_buildfile?(path)
+          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? 
+        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
+    end
+
+    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 
+    # buildfiles found in the current project.  Buildfiles include any file
+    # 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.
+    #
+    # === Returns
+    #  Buildfile instance
+    #
+    def buildfile
+      @buildfile ||= (parent_project.nil? ? Buildfile.new : parent_project.buildfile.dup).load!(project_root)
+    end
+
+    # The config for the current project.  The config is computed by merging
+    # the config settings from the current buildfile and then the current
+    # environment in the following order:
+    #
+    #  config for all modes, all targets +
+    #  config for current mode, all targets +
+    #  Current environment defined in SC.env
+    #
+    # This is the config hash you should access to determine general project
+    # wide settings that cannot be overridden by individual targets.
+    #
+    # === Returns
+    #  merged HashStruct
+    #
+    def config
+      return @config ||= buildfile.config_for(:all, SC.build_mode).merge(SC.env)
+    end
+
+    ################################################
+    ## TARGETS
+    ##
+
+    # A hash of the known targets for this project, including any targets
+    # inherited from a parent project.  Each target is stored in the hash
+    # by target_name.
+    #
+    # The first time this method is called, the project will automatically
+    # clone any targets from a parent project, and then calls 
+    # find_targets_for() on itself to recursively discover any targets in
+    # the project.
+    #
+    # If you need to change the way the project discovers project, override
+    # find_targets_for() instead of this method.
+    #
+    # === Returns
+    #  Hash of targets keyed by target_name
+    #
+    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_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.  
+    #
+    # === Params
+    #  target_name:: the target to lookup
+    #
+    # === Returns
+    #  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.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 
+    # want copied onto the target.  If a previous target was defined by the
+    # same name it will be replaced by this one.
+    #
+    # === Params
+    #  target_name:: the name of the target.
+    #  target_type:: the type of target
+    #
+    # === Options (any others allowed also)
+    #  source_root:: the absolute path to the target source
+    #
+    # === Returns
+    #  new target
+    #
+    def add_target(target_name, target_type, options={})
+      targets[target_name] = 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 
+    # "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 
+    # do whatever kind of changes you want.
+    #
+    # === Params
+    #  root_path:: The path to search for targets.
+    #  root_name:: The root target name
+    #  config::    The config hash to use for this.  Should come from target
+    #
+    # === Returns
+    #  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| 
+        target_types[key.to_s.downcase] = value
+      end
+
+      # look for directories matching a target type
+      Dir.glob(File.join(root_path, '*')).each do |dir_name|
+        target_type = target_types[File.basename(dir_name).to_s.downcase]
+        next if target_type.nil?
+        next unless File.directory?(dir_name)
+
+        # loop through each item in the directory.  
+        Dir.glob(File.join(dir_name,'*')).each do |source_root|
+          next unless File.directory?(source_root)
+
+          # compute target name and create target
+          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 
+          # override the default.
+          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 
+    
+    ################################################
+    ## 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 
+    
+    # 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
+      end
+    end
+        
+  end
+  
+end
+
+
+