sproutit-sproutcore 1.0.0.20090407205609

data/lib/sproutcore/models/target.rb

@@ -0,0 +1,403 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+  
+  # Defines a build target in a project.  A build target is a component that
+  # you might want to build separately such as an application or library.
+  #
+  # Targets make require other targets through their dependencies property.
+  # The property should name the other targets using either a relative or
+  # absolute target name.  An absolute target name begins with a forward
+  # slash (i.e. /sproutcore), where a relative begins with the target name
+  # itself.
+  #
+  # When you create a target you must pass at least the following two 
+  # parameters:
+  # 
+  #  target_name:: the name of the target, must start with a forward-slash
+  #  target_type:: a task namespace that can be used to invoke tasks for 
+  #    building the manifest and other commands
+  #
+  # In addition to the above required parameters, you may also pass options.
+  # These options will be simply set on the target and may be used by the 
+  # build tasks.  At least two options, however, have special meaning and 
+  # they should be set at some point before the task is used:
+  #
+  #  project:: This should point to the project the owns the target.  If you
+  #    create a target using the Project#add_target method, this will be set
+  #    for you.
+  #  source_root::  This should contain the absolute path to the source 
+  #    directory for the target.  If you do not set this option, then the
+  #    Target will not be able to load a Buildfile you define.  It is not 
+  #    strictly necessary to set this option however, as some targets may be
+  #    entirely synthesized from other sources.
+  #
+  class Target < HashStruct
+    
+    def initialize(target_name, target_type, opts={})
+      # Add target_name & type of options so they can be enumerated as part 
+      # of the hash
+      opts = opts.merge :target_name => target_name, 
+                        :target_type => target_type
+                        
+      # Remove the project since we do not want to enumerate that as part of
+      # the hash
+      @project = opts.delete(:project)
+      super(opts)
+    end
+    
+    attr_reader :project
+    
+    def inspect
+      "SC::Target(#{target_name})"
+    end
+    
+    # Invoke this method to make sure the basic paths for the target have
+    # been prepared.  This method is called on the target before it is 
+    # returned from any call target_for().  It will invoke the target:prepare
+    # build task.
+    #
+    # You can call this method as often as you want; it will only execute 
+    # once.
+    #
+    # === Returns 
+    #  Target
+    def prepare!
+      if !@is_prepared
+        @is_prepared = true
+        if buildfile.task_defined? 'target:prepare'
+          buildfile.invoke 'target:prepare', 
+            :target => self, :project => self.project, :config => self.config       
+        end
+      end
+      return self
+    end
+    
+    # Used for unit testing
+    def prepared?; @is_prepared || false; end
+    
+    ######################################################
+    # CONFIG
+    #
+    
+    # Returns the buildfile for this target.  The buildfile is a clone of 
+    # the parent target buildfile with any buildfile found in the current
+    # target's source_root merged over top of it. 
+    #
+    # === Returns
+    #  Buildfile
+    #
+    def buildfile 
+      @buildfile ||= parent_target.buildfile.dup.for_target(self).load!(self.source_root)
+    end
+    
+    # Returns the config for the current project.  The config is computed by 
+    # taking the merged config settings from the build file given the current
+    # build mode, then merging any environmental configs (set in SC::env)
+    # over the top.
+    #
+    # This is the config hash you should use to control how items are built.
+    def config
+      return @config ||= buildfile.config_for(target_name, SC.build_mode).merge(SC.env)
+    end
+    
+    # Clears the cached config, reloading it from the buildfile again.  This
+    # is mostly used for unit testing. 
+    def reload_config!
+      @config= nil
+      @is_prepared = false
+      prepare!
+      return self
+    end
+    
+
+    ######################################################
+    ## COMPUTED HELPER PROPERTIES
+    ##
+
+    # Returns all of the targets required by this target.  This will use the
+    # "required" config, resolving the target names using target_for().
+    #
+    # You may pass some additional options in which will select the set
+    # of targets you want returned.
+    #
+    # === Options
+    #  :debug:: if true, config.debug_required will be included
+    #  :test::  if true, config.test_required will also be included
+    #
+    # === Returns
+    #  Array of Targets
+    #
+    def required_targets(opts={})
+      
+      # compute cache key for these options
+      key = [:debug, :test, :theme].map do |k| 
+        opts[k] ? k : nil 
+      end
+      key = key.compact.join('.')
+      
+      # Return cache value if found
+      ret = (@required_targets ||= {})[key]
+      return ret unless ret.nil?
+      
+      # else compute return value, respecting options
+      ret = [config.required]
+      if opts[:debug] && config.debug_required
+        ret << config.debug_required 
+      end
+      if opts[:test] && config.test_required
+        ret << config.test_required
+      end 
+      if opts[:theme] && self.loads_theme? && config.theme
+        # verify theme is a theme target type - note that if no matching
+        # target is found, we'll just let this go through so the standard
+        # not found warning can show.
+        t = target_for(config.theme)
+        if t && t.target_type != :theme
+          SC.logger.warn "Target #{config.theme} was set as theme for #{target_name} but it is not a theme."
+        else
+          ret << config.theme
+        end
+      end
+      
+      ret = ret.flatten.compact.map do |n| 
+        if (t = target_for(n)).nil? 
+          SC.logger.warn "Could not find target #{n} that is required by #{target_name}"
+        end
+        t
+      end
+      ret = ret.compact.uniq
+      
+      @required_targets[key] = ret
+      return ret 
+    end
+
+    # Returns true if this target can load a theme.  Default returns true 
+    # only if the target_type == :app, but you can override this by setting
+    # the value yourself.
+    def loads_theme?;
+      ret = self[:loads_theme]
+      ret.nil? ? (target_type == :app) : ret
+    end
+    
+    # Returns the expanded list of required targets, ordered as they actually
+    # need to be loaded.
+    #
+    # This method takes the same options as required_targets to select the 
+    # targets to include.
+    #
+    # === Returns
+    #  Array of targets
+    #
+    def expand_required_targets(opts ={})
+      _expand_required_targets(opts, [self])
+    end
+    
+    def _expand_required_targets(opts, seen)
+      ret = []
+      required_targets(opts).each do |target|
+        next if seen.include?(target)
+        seen << target # avoid loading again
+        
+        # add required targets, if not already seend...
+        target._expand_required_targets(opts, seen).each do |required|
+          ret << required
+          seen << required
+        end
+        
+        # then add my own target...
+        ret << target
+      end
+      return ret.uniq.compact
+    end
+
+    # Returns true if the passed path appears to be a target directory 
+    # according to the target's current config.
+    def target_directory?(path, root_path=nil)
+      root_path = self.source_root if root_path.nil?
+      @target_names ||= self.config.target_types.keys
+      path = path.to_s.sub /^#{Regexp.escape root_path}\//, ''
+      @target_names.each do |name|
+        return true if path =~ /^#{Regexp.escape name.to_s}/
+      end
+      return false
+    end
+    
+    # Computes a unique build number for this target.  The build number is
+    # gauranteed to change anytime the contents of any source file changes 
+    # or anytime the build number of a required target changes.  Although 
+    # this will generate long strings, it will automatically ensure that 
+    # resources are properly cached when deployed.
+    #
+    # Note that this method does NOT set the build_number on the receiver;
+    # it just calculates a value and returns it.  You usually call this 
+    # method just to set the build_number on the target.
+    #
+    # === Returns
+    #  A build number string
+    #
+    def compute_build_number(seen=nil)
+      
+      # Look for a global build_numbers hash and try that
+      if (build_numbers = config.build_numbers)
+        build_number = build_numbers[target_name.to_s] || build_numbers[target_name.to_sym]
+      end
+
+      # Otherwise, use config build number specifically for this target, if 
+      # specified
+      build_number ||= config.build_number 
+
+      # Otherwise, actually compute a build number. 
+      if build_number.nil?
+        require 'digest/md5'
+
+        # Computes the build number based on the contents of the
+        # files.  It is not as fast as using an mtime, but it will remain
+        # constant from one machine to the next so it can be used when
+        # deploying across multiple build machines, etc.
+        digests = Dir.glob(File.join(source_root, '**', '*')).map do |path|
+          allowed = File.exists?(path) && !File.directory?(path)
+          allowed = allowed && !target_directory?(path)
+          allowed ? Digest::SHA1.hexdigest(File.read(path)) : nil
+        end
+        digests.compact!
+
+        # Get all required targets and add in their build number.
+        # Note the "seen" variable passed here will avoid circular references
+        # causing infinite loops.  Normally this should not be necessary, but
+        # we put this here to gaurd against misconfigured projects
+        seen ||= []
+        required_targets.each do |ct|
+          next if seen.include?(ct)
+          seen << ct
+          digests << (ct.build_number || ct.compute_build_number(seen))
+        end
+
+        # Finally digest the complete string - tada! build number
+        build_number = Digest::SHA1.hexdigest(digests.join)
+      end
+      
+      return build_number.to_s
+    end
+    
+    ######################################################
+    # MANIFEST
+    #
+
+    # An array of manifests for the target.  You can retrieve the manifest
+    # for a particular variation using the method manifest_for().
+    def manifests; @manifests ||= []; end
+    
+    # Returns the manifest matching the variation options.  If no matching
+    # manifest can be found, a new manifest will be created and prepared.
+    def manifest_for(variation={})
+      ret = manifests.find { |m| m.has_options?(variation) }
+      if ret.nil?
+        ret = Manifest.new(self, variation)
+        @manifests << ret
+      end
+      return ret 
+    end
+    
+    ######################################################
+    # TARGET METHODS
+    #
+    
+    # Finds the parent target for this target.  The parent target is the 
+    # target with a higher-level of hierarchy.
+    #
+    # For example, the parent of 'sproutcore/foundation' is 'sproutcore'
+    #
+    # If your target is a top-level target, then this will return the project
+    # itself.  If your target does not yet belong to a project, this will
+    # return nil
+    #
+    def parent_target
+      return @parent_target unless @parent_target.nil?
+      return nil if project.nil?
+      tname = target_name
+      while @parent_target.nil?
+        tname = tname.to_s.sub(/\/[^\/]+$/,'')
+        @parent_target = (tname.size>0) ? project.target_for(tname) : project
+      end
+      @parent_target
+    end
+    
+    # Find a target relative to the receiver target.  If you pass a regular 
+    # target name, this method will start by looking for direct children of 
+    # the receiver, then it will move up the hierarchy, looking in the parent
+    # target and on up until it reaches the top-level library.
+    #
+    # This 'scoped' search model allows you to next targets and then to 
+    # properly reference them.
+    #
+    # To absolutely reference a target (i.e. to name its part beginning from
+    # the project root, begin with a forward-slash.)
+    # 
+    # === Params
+    #  target_name:: the name of the target
+    #
+    # === Returns
+    #  found target or nil if no match could be found
+    #
+    def target_for(target_name)
+      if target_name =~ /^\// # absolute target
+        ret = project.target_for(target_name)
+      else # relative target...
+        
+        # look for any targets that are children of this target
+        ret = project.target_for([self.target_name, target_name].join('/'))
+        
+        # Ask my parent target to look for the target, and so on.
+        if ret.nil?
+          ret = parent_target.nil? ? project.target_for(target_name) : parent_target.target_for(target_name)
+        end
+      end
+      return ret 
+    end
+        
+    ######################################################
+    # LANGUAGE HELPER METHODS
+    #
+    
+    LONG_LANGUAGE_MAP = { :english => :en, :french => :fr, :german => :de, :japanese => :ja, :spanish => :es, :italian => :it }
+    SHORT_LANGUAGE_MAP = { :en => :english, :fr => :french, :de => :german, :ja => :japanese, :es => :spanish, :it => :italian }
+
+    # Returns the language codes for any languages actually found in this 
+    # target.
+    def installed_languages
+      ret = Dir.glob(File.join(source_root, '*.lproj')).map do |path|
+        next unless path =~ /\/([^\/]+)\.lproj/
+        (LONG_LANGUAGE_MAP[$1.downcase.to_sym] || $1).to_s
+      end
+      ret << config.preferred_language.to_s if config.preferred_language
+      ret.compact.uniq.sort { |a,b| a.downcase <=> b.downcase }.map { |l| l.to_sym }
+    end
+    
+    # Returns project-relative path to the lproj directory for the named 
+    # short language code
+    def lproj_for(language_code)
+      
+      # try code as passed
+      ret = "#{language_code}.lproj"
+      return ret if File.directory? File.join(source_root, ret)
+      
+      # try long language too...
+      language_code = SHORT_LANGUAGE_MAP[language_code.to_s.downcase.to_sym]
+      if language_code
+        ret = "#{language_code}.lproj"
+        return ret if File.directory? File.join(source_root, ret)
+      end
+      
+      # None found
+      return nil
+    end
+    
+  end
+  
+end

data/lib/sproutcore/rack/builder.rb

@@ -0,0 +1,269 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+require 'thread'
+
+module SC
+  module Rack
+    
+    # A Rack application for serving dynamically-built SproutCore projects.
+    # Most of the time you will use this application as part of the sc-server
+    # command to dynamically build your SproutCore project while you develop
+    # it.
+    #
+    # If you are deploying some Ruby-based infrastructure in your production
+    # environment, you could also use this application to dynamically build
+    # new versions of your SproutCore apps when you deploy them.  This would
+    # allow you to potentially bypass the pre-deployment build step using 
+    # sc-build. 
+    #
+    # While this model is supported by the Rack adaptor, it is generally 
+    # recommended that you instead build you app without using this adaptor
+    # since the build step will help catch possible errors in your code before
+    # you go live with your project.  Sometimes, however, dynamically building
+    # content is useful, and that is what this adaptor is for.
+    #
+    # === Using This Application
+    #
+    # When you instantiate a builder, you must provide one or more projects
+    # that contain the resources you want to load.  Each incoming request url 
+    # will be mapped to an entriy in a project manifest.  The entry is then 
+    # built and the resulting file returned.  Once a file has been built, it
+    # will not be rebuilt unless the source file it represents has changed.
+    #
+    # In addition to dynamically building entries, the Builder can also 
+    # forwards requests onto an SC::Rack::Proxy app to handle proxies 
+    # requests.
+    #
+    # === Config Settings
+    #
+    # This app respects several options that you can name in your config file
+    # (in addition to proxy configs), that can affect the app performance.
+    # Normally reasonable defaults for these settings are built into the
+    # SproutCore buildfile, but you may choose to override them if you are
+    # deploying into a production environment.
+    #
+    #  :reload_project::  If set to true, then the builder will reload the
+    #    projects to look for changed files before servicing incoming 
+    #    requests.  You will generally want this option while working in 
+    #    debug mode, but you may want to disable it for production, since it
+    #    can slow down performance.  
+    #
+    #  :use_cached_headers:: If set to true, then the builder will return
+    #    static assets with an "Expires: <10-years>" header attached.  This
+    #    will yield excellent performance in production systems but it may
+    #    interfere with loading the most recent copies of files when in 
+    #    development mode.
+    #
+    #  :combine_javascript:: If set, the generated html will reference a 
+    #    combined version of the javascript for elgible targets.  This will
+    #    yield better performance in production, but slows down load time in
+    #    development mode.
+    #
+    #  :combine_stylesheets:: Ditto to combine_javascript 
+    #
+    class Builder
+      
+      # used to set expires header.
+      ONE_YEAR = 365 * 24 * 60 * 60
+      
+      # When you create a new builder, pass in one or more projects you want
+      # the builder to monitor for changes.
+      def initialize(project)
+        @project = project
+        @last_reload_time = Time.now 
+      end
+      
+      # Main entry point for this Rack application.  Returns 404 if no
+      # matching entry could be found in the project.
+      def call(env)
+        
+        # define local variables so they will survive the mutext contexts 
+        # below...
+        ret = url = target = language = cacheable = manifest = entry = nil
+        build_path = nil
+        
+        project_mutex.synchronize do 
+          reload_project! # if needed
+
+          # collect some standard info
+          url = env['PATH_INFO']
+      
+          # look for a matching target
+          target = target_for(url)
+          ret = not_found("No matching target") if target.nil?
+      
+          # normalize url to resolve to entry & extract the language
+          if ret.nil?
+            url, language, cacheable = normalize_url(url, target)
+            ret = not_found("Target requires language") if language.nil?
+          end
+      
+          # lookup manifest
+          if ret.nil?
+            language = language.to_s.downcase.to_sym # normalize
+            manifest = target.manifest_for(:language => language).build!
+      
+            # lookup entry by url
+            unless entry = manifest.entries.find { |e| e.url == url }
+              ret = not_found("No matching entry in target")
+            end
+          end
+
+          if ret.nil?
+            # Clean the entry so it will rebuild if we are serving an html 
+            # file
+            entry.clean! if [:html, :test].include?(entry.entry_type)
+        
+            # Now build entry and return a file object
+            build_path = entry.build!.build_path
+          end
+
+          # Update last reload time.  This way if any other requests are
+          # waiting, they won't rebuild their manifest.
+          @last_reload_time = Time.now
+        end
+
+        return ret unless ret.nil?
+        
+        unless File.file?(build_path) && File.readable?(build_path)
+          return not_found("File could not build (entry: #{entry.filename} - build_path: #{build_path}")
+        end
+        
+        SC.logger.info "Serving #{target.target_name.to_s.sub(/^\//,'')}:#{entry.filename}"
+
+        # define response headers
+        file_size = File.size(build_path)
+        headers = {
+          "Last-Modified"  => File.mtime(build_path).httpdate,
+          "Etag"           => File.mtime(build_path).to_i.to_s,
+          "Content-Type"   => mime_type(build_path),
+          "Content-Length" => file_size.to_s,
+          "Expires"        => (cacheable ? (Time.now + ONE_YEAR) : Time.now).httpdate
+        }
+        [200, headers, File.open(build_path, 'rb')]
+      end
+      
+      attr_reader :project
+      
+      protected
+
+      # Mutex used while updating the project and retrieving the entry to
+      # build.
+      def project_mutex; @project_mutex ||= Mutex.new; end
+      
+      # Mutex used while building an entry...
+      def build_mutex; @build_mutex ||= Mutex.new; end
+      
+      # Invoked when a resource cannot be found for some reason
+      def not_found(reason)
+        reason = "<html><body><p>#{reason}</p></body></html>"
+        return [404, {
+          "Content-Type"   => "text/html",
+          "Content-Length" => reason.size.to_s     
+        }, reason]
+      end
+      
+      # Reloads the project if reloading is enabled.  At maximum this will
+      # reload the project every 5 seconds.  
+      def reload_project!
+        # don't reload if no project or is disabled
+        return if @project.nil? || !@project.config.reload_project
+        
+        # reload after a delay of 5 sec
+        reload_delay = (Time.now - @last_reload_time)
+        
+        if reload_delay > 5
+          SC.logger.info "Rebuilding project manifest"
+          @project.reload!
+        end
+      end
+      
+      def target_for(url)
+
+        # get targets
+        targets = project.targets.values.dup
+        targets.each { |t| t.prepare! }
+        
+        # split the url into parts.  pop parts until we find a matching 
+        # target.  This ensures that we end up with the deepest matching
+        # target.
+        url_parts = url.split '/'
+        ret = nil
+        while url_parts.size>0 && ret.nil?
+          url = url_parts.join '/'
+          ret = targets.find { |t| t.url_root == url || t.index_root == url }
+          url_parts.pop
+        end
+        return ret 
+      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 the url.  In particular, this will look 
+      # for all the different ways you can request an index.html file and 
+      # convert it to a canonical form
+      #
+      # Returns the normalized url, the language extracted from the url and
+      # a boolean indicating whether the url is considered cacheable or not.
+      # any url beginning with the target's url_root is considered cacheable
+      # and will therefore be returned with an expires <10years> header set.
+      #
+      # === Params
+      #  url:: the url to normalize
+      #  target:: the suspected target url
+      #
+      # === Returns
+      #  [normalized url, matched language, cacheable]
+      #
+      def normalize_url(url, target)
+
+        cacheable = true 
+        
+        # match
+        # /foo - /foo/index.html
+        # /foo/en - /foo/en/index.html
+        # /foo/en/build_number - /foo/en/build_number/index.html
+        # /foo/en/CURRENT/resource-name
+        matched = url.match(/^#{Regexp.escape target.index_root}(\/([^\/\.]+))?(\/([^\/\.]+))?(\/(.*))?$/)
+        unless matched.nil?
+          matched_language = matched[2] || target.config.preferred_language
+          
+          matched_build_number = matched[4]
+          if matched_build_number.blank? || matched_build_number == 'current'
+            matched_build_number = target.build_number
+          end
+          
+          resource_name = matched[6]
+          resource_name = 'index.html' if resource_name.blank?
+
+          # convert to url root based
+          url = [target.url_root, matched_language, matched_build_number, 
+                 resource_name] * '/'
+          cacheable = false # index_root based urls are not cacheable
+          
+        # otherwise, just get the language -- url_root-based urls must be 
+        # fully qualified
+        else
+          matched = url.match(/^#{Regexp.escape  target.url_root}\/([^\/\.]+)/)
+          matched_language = matched ? matched[1] : nil
+        end
+
+        return [url, matched_language, cacheable]
+      end
+      
+      # Returns the mime type.  Basically this is the Rack mime mapper with
+      # a few bug fixes.
+      def mime_type(build_path)
+        ext = File.extname(build_path)
+        (ext == '.js') ? 'text/javascript' : ::Rack::Mime.mime_type(ext, 'text/plain')
+      end
+      
+    end
+    
+  end
+end