sproutcore 1.6.0.beta.2-x86-mingw32

data/lib/sproutcore/models/manifest_entry.rb

@@ -0,0 +1,362 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe 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
+      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!
+      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(#{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|
+          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
+
+    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
+
+    # deferred_modules targets, only applicable to module_info entries
+    def targets; self[:targets]; end
+
+    # variation for deferred_modules targets, only applicable to module_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
+      if dynamic? # MUST check for this first...
+        timestamps = targets.map do |t|
+          timestamps2 = t.manifest_for(variation).build!.entries.map do |e|
+            ts = e.timestamp
+            ts.nil? ? 0 : ts
+          end
+          timestamps2.max
+        end
+        timestamps.max
+
+      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
+    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, 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('')
+      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
+    # 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)
+
+          # fine all directives in the source.  use file cache to make this
+          # fast later on.
+          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
+    # 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
+      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
+
+      target.end_attr_changes
+
+    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
+
+    # Diagnostic function.  Indicates what will happen if you called build
+    def inspect_build_state
+      inspect_build_to self[:build_path]
+    end
+
+    def inspect_staging_state
+      inspect_build_to self[:staging_path]
+    end
+
+
+    def inline_contents
+      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])
+    end
+
+    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
+      self.source_paths.each do |path|
+        if path.nil?
+          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}"
+      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,267 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe 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. Locate 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').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
+    # 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.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
+    # "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