RubyGems - sproutcore - Versions diffs - 0.9.23 → 1.0.1003 - Mend

sproutcore 0.9.23 → 1.0.1003

Files changed (1668) hide show

data/lib/sproutcore/bundle_manifest.rb DELETED Viewed

@@ -1,574 +0,0 @@
-require 'yaml'
-require 'digest/md5'
-module SproutCore
-  # A Bundle Manifest describes all of the resources in a bundle, including
-  # mapping their source paths, destination paths, and urls.
-  #
-  # A Bundle will create a manifest for every language and platform you
-  # request from it. If you invoke reload! on the bundle, it will dispose of
-  # its manifests and rebuild them.
-  #
-  class BundleManifest
-    CACHED_TYPES    = [:javascript, :stylesheet, :fixture, :test]
-    SYMLINKED_TYPES = [:resource]
-    PLATFORM_MATCH  = /^([^\/]+)\.platform\//
-    LPROJ_MATCH     = /^([^\/]+\.platform\/)?([^\/]+\.lproj)\//
-    NORMALIZED_TYPE_EXTENSIONS = {
-      :stylesheet => { :sass => :css },
-      :test => { '[^\/\.]+' => :html }
-    }
-    attr_reader :bundle, :language, :build_mode, :platform
-    def initialize(bundle, language, build_mode, platform)
-      @bundle = bundle
-      @language = language
-      @build_mode = build_mode
-      @platform = platform
-      @entries_by_type = {} # entries by type
-      @entries_by_filename = {} # entries by files
-      build!
-    end
-    def bundle_name; bundle.nil? ? nil : bundle.bundle_name; end
-    # ==== Returns
-    # All entries as an array
-    #
-    def entries; @entries_by_filename.values; end
-    # ==== Returns
-    # All of the entries matching the specified type
-    #
-    def entries_for(resource_type)
-      @entries_by_type[resource_type] || []
-    end
-    # ==== Returns
-    # Entry for the resource with the specified name
-    #
-    def entry_for(resource_name)
-      @entries_by_filename[resource_name] || nil
-    end
-    def to_a; @entries_by_filename.values.map { |x| x.to_hash }; end
-    def to_hash; @entries_by_type; end
-    def to_s; @entries_by_filename.to_yaml; end
-    # ==== Returns
-    # true if javascripts should be combined
-    def combine_javascript?
-     modes = bundle.library.combine_javascript_build_modes(bundle_name)
-     modes.include?(build_mode)
-    end
-    # ==== Returns
-    # true if stylesheets should be combined
-    def combine_stylesheets?
-      modes = bundle.library.combine_stylesheets_build_modes(bundle_name)
-      modes.include?(build_mode)
-    end
-    # ==== Returns
-    # true if stylesheets should be combined
-    def include_fixtures?
-      modes = bundle.library.include_fixtures_build_modes(bundle_name)
-      modes.include?(build_mode)
-    end
-    # ==== Returns
-    # true if debug code should be included in the build
-    def include_debug?
-      modes = bundle.library.include_debug_build_modes(bundle_name)
-      modes.include?(build_mode)
-    end
-    protected
-    # Builds a manifest for the bundle and the specified language
-    def build!
-      # STEP 1: Catalog all of the files in the project, including the target
-      # language and the default language.  This will filter out resources not
-      # used in this language.
-      entries = catalog_entries
-      # STEP 2: Combine the HTML file paths into a single entry, unless this
-      # is a framework
-      working = entries[:html] ||= []
-      if bundle.can_have_html?
-        working << build_entry_for('index.html', :html, working)
-      else
-        working.each { |x| x.hidden = true }
-      end
-      # STEP 3: Handle special build modes...
-      #  a. Merge fixture types into JS types if fixtures should be included
-      if self.include_fixtures? && !entries[:fixture].nil?
-        entries[:javascript] = (entries[:javascript] || []) + entries[:fixture]
-      else
-        entries.delete(:fixture)
-      end
-      #  b. Merge debug types into JS types if debug should be included
-      if self.include_debug? && !entries[:debug].nil?
-        entries[:javascript] = (entries[:javascript] || []) + entries[:debug]
-      else
-        entries.delete(:debug)
-      end
-      #  c. Rewrite all of the JS & CSS file paths and URLs to point to
-      # cached versions in development mode only.
-      # (Cached versions are written to _cache/filename-ctime.ext)
-      if self.build_mode == :development
-        (entries[:javascript] ||= []).each do | entry |
-          setup_timestamp_token(entry)
-        end
-        (entries[:stylesheet] ||= []).each do | entry |
-          setup_timestamp_token(entry)
-        end
-      #  c. Remove the entries for anything that is not JS, CSS, HTML or
-      #     Resource in non-development modes
-      else
-        entries.delete(:test)
-      end
-      #  d. Rewrite the URLs for all other resources to go through the _src
-      #     symlink
-      ## -----> Already done build_entry_for()
-      #  STEP 4: Generate entry for combined Javascript and CSS if needed
-      #  a. Combine the JS file paths into a single entry for the
-      #  javascript.js if required for this build mode
-      hide_composite = self.combine_javascript?
-      if (working = entries[:javascript]) && working.size>0
-        entry = build_entry_for('javascript.js', :javascript, working, hide_composite)
-        setup_timestamp_token(entry) if self.build_mode == :development
-        entry.hidden = true unless hide_composite
-        working << entry
-      end
-      #  b. Combine the CSS file paths into a single entry for the
-      #  stylesheet.css if required for this build mode
-      hide_composite = self.combine_stylesheets?
-      if (working = entries[:stylesheet]) && working.size>0
-        entry = build_entry_for('stylesheet.css', :stylesheet, working, hide_composite)
-        setup_timestamp_token(entry) if self.build_mode == :development
-        entry.hidden = true unless hide_composite
-        working << entry
-      end
-      # Save entries into hashes
-      @entries_by_type = entries
-      @entries_by_filenames = {}
-      entries.values.flatten.each do |entry|
-        @entries_by_filename[entry.filename] = entry
-      end
-    end
-    # Build a catalog of entries for this manifest.  This will simply filter
-    # out the files that don't actually belong in the current language or
-    # platform
-    def catalog_entries
-      # Entries arranged by resource filename
-      entries = {}
-      default_lproj_entries = {}
-      target_lproj_entries = {}
-      # Get the name of the lproj dirs for the default and current languages
-      default_lproj = bundle.lproj_for(bundle.preferred_language)
-      target_lproj = bundle.lproj_for(language)
-      # Any files living in the two lproj dirs will be shunted off into these
-      # arrays and processed later to make sure we process them in the right
-      # order
-      default_lproj_files = []
-      target_lproj_files = []
-      # Now, glob all the files and sort through them
-      old_wd = Dir.getwd; Dir.chdir(bundle.source_root)
-      Dir.glob(File.join('**','*')).each do | src_path |
-        # Get source type.  Skip any without a useful type
-        next if (src_type = type_of(src_path)) == :skip
-        # Get target platform (if there is one).  Skip is not target platform
-        if current_platform = src_path.match(PLATFORM_MATCH).to_a[1]
-          next if current_platform.to_sym != platform
-        end
-        # Get current lproj (if there is one).  Skip if not default or current
-        if current_lproj = src_path.match(LPROJ_MATCH).to_a[2]
-          next if (current_lproj != default_lproj) && (current_lproj != target_lproj)
-        end
-        # OK, pass all of our validations.  Go ahead and build an entry for
-        # this. Add entry to list of entries for appropriate lproj if
-        # localized.
-        #
-        # Note that entries are namespaced by platform.  This way non-platform
-        # specific entries will not be overwritten by platfor-specific entries
-        # of the same name.
-        #
-        entry = build_entry_for(src_path, src_type)
-        entry_key = [current_platform||'', entry.filename].join(':')
-        case current_lproj
-        when default_lproj
-          default_lproj_entries[entry_key] = entry
-        when target_lproj
-          target_lproj_entries[entry_key] = entry
-        else
-          # Be sure to mark any
-          entries[entry_key] = entry
-        end
-      end
-      Dir.chdir(old_wd) # restore wd
-      # Now, merge in default and target lproj entries.  This will overwrite
-      # entries that exist in both places.
-      entries.merge!(default_lproj_entries)
-      entries.merge!(target_lproj_entries)
-      # Finally, entries will need to be grouped by type to allow further
-      # processing.
-      ret = {}
-      entries.values.each { |entry| (ret[entry.type] ||= []) << entry }
-      return ret
-    end
-    # Determines the type for this manifest entry.  Should be one of:
-    #
-    # stylesheet::   a CSS file
-    # javascript::   a JavaScript file
-    # html::         an HTML file
-    #
-    # test::         a test file (inside of /tests)
-    # fixture::      a fixture file (inside of /fixtures)
-    #
-    # resource::     any other file inside an lproj dir
-    # skip::      any other file outside of an lproj dir directories
-    #
-    # If you need to handle additional types of resources in the future, this is the place to
-    # put it.
-    #
-    # ==== Params
-    #
-    # src_path:: The source path, relative to source_root.
-    #
-    def type_of(src_path)
-      return :skip if File.directory?(src_path)
-      case src_path
-      when /^([^\/\.]+\.platform\/)?tests\/.+/
-        :test
-      when /^([^\/\.]+\.platform\/)?fixtures\/.+\.js$/
-        :fixture
-      when /^([^\/\.]+\.platform\/)?debug\/.+\.js$/
-        :debug
-      when /\.rhtml$/
-        :html
-      when /\.html.erb$/
-        :html
-      when /\.haml$/
-        :html
-      when /\.css$/
-        :stylesheet
-      when /\.sass$/
-        :stylesheet
-      when /\.js$/
-        :javascript
-      when /\.lproj\/.+/
-        :resource
-      else
-        :skip
-      end
-    end
-    # Build an entry for the resource at the named src_path (relative to the
-    # source_root) This should assume we are in going to simply build each
-    # resource into the build root without combining files, but not using our
-    # _src symlink magic.
-    #
-    # +Params+
-    #
-    # src_path:: the source path, relative to the bunlde.source_root
-    # src_type:: the detected source type (from type_of())
-    # composite:: Array of entries that should be combined to form this or nil
-    # hide_composite:: Makes composit entries hidden if !composite.nil?
-    #
-    # +Returns: Entry
-    #
-    def build_entry_for(src_path, src_type, composite=nil, hide_composite = true)
-      ret = ManifestEntry.new
-      ret.ext = File.extname(src_path)[1..-1] || '' # easy stuff
-      ret.type = src_type
-      ret.original_path = src_path
-      ret.hidden = false
-      ret.language = language
-      ret.platform = platform
-      ret.use_digest_tokens = bundle.use_digest_tokens
-      # the filename is the src_path less any lproj or platform in the front
-      ret.filename = src_path.gsub(LPROJ_MATCH,'')
-      # the source path is just the combine source root + the path
-      # Composite entries do not have a source path b/c they are generated
-      # dynamically.
-      ret.source_path = composite.nil? ? File.join(bundle.source_root, src_path) : nil
-      # set the composite property.  The passed in array should contain other
-      # entries if hide_composite is true, then hide the composite items as
-      # well.
-      unless composite.nil?
-        composite.each { |x| x.hidden = true } if hide_composite
-        # IMPORTANT:  The array of composite entries passed in here can come
-        # directly from the entries hash, which will later be updated to
-        # include the composite entry (ret) itself.  Dup the array here to
-        # make sure the list of composites maintained here does not change.
-        ret.composite = composite.dup
-      end
-      # PREPARE BUILD_PATH and URL
-      # The main index.html file is served from the index_Root.  All other
-      # resourced are served from the URL root.
-      url_root = (src_path == 'index.html') ? bundle.index_root : bundle.url_root
-      # Setup special cases.  Certain types of files are processed and then
-      # cached in development mode (i.e. JS + CSS).  Other resources are
-      # simply served up directly without any processing or building.  See
-      # constants for types.
-      cache_link = nil; use_source_directly =false
-      if (self.build_mode == :development) #&& composite.nil?
-        cache_link = '_cache' if CACHED_TYPES.include?(src_type)
-        use_source_directly = true if SYMLINKED_TYPES.include?(src_type)
-      end
-      # If this resource should be served directly, setup both the build_path
-      # and URL to point to a special URL that maps directly to the resource.
-      # This is only useful in development mode
-      ret.use_source_directly = use_source_directly
-      if use_source_directly
-        path_parts = [bundle.build_root, language.to_s, '_src', src_path]
-        ret.build_path = File.join(*(path_parts.compact))
-        path_parts[0] = url_root
-        ret.url = path_parts.compact.join('/')
-      # If the resource is not served directly, then calculate the actual
-      # build path and URL for production mode.  The build path is the
-      # build root + language + platform + (cache_link || build_number) +
-      # filename
-      #
-      # The URL is the url_root + current_language + current_platform + (cache_link)
-      else
-        path_parts = [bundle.build_root, language.to_s,
-           (cache_link || bundle.build_number.to_s), ret.filename]
-        ret.build_path = File.join(*path_parts.compact)
-        path_parts[0] = url_root
-        ret.url = path_parts.compact.join('/')
-        path_parts[2] = 'current' # create path to "current" build
-        ret.current_url = path_parts.compact.join('/')
-      end
-      # Convert the input source type an output type.
-      if sub_type = NORMALIZED_TYPE_EXTENSIONS[ret.type]
-        sub_type.each do | matcher, ext |
-          matcher = /\.#{matcher.to_s}$/; ext = ".#{ext.to_s}"
-          ret.build_path.sub!(matcher, ext)
-          ret.url.sub!(matcher, ext)
-        end
-      end
-      # Done.
-      return ret
-    end
-    # Lookup the timestamp on the source path and interpolate that into the
-    # filename URL and build path.  This should only be called on entries
-    # that are to be cached (in development mode)
-    def setup_timestamp_token(entry)
-      timestamp = bundle.use_digest_tokens ? entry.digest : entry.timestamp
-      # add timestamp or digest to URL
-      extname = File.extname(entry.url)
-      entry.url.gsub!(/#{extname}$/,"-#{timestamp}#{extname}")
-      # add timestamp or digest to build path
-      extname = File.extname(entry.build_path)
-      entry.build_path.gsub!(/#{extname}$/,"-#{timestamp}#{extname}")
-    end
-  end
-  # describes a single entry in the Manifest:
-  #
-  # filename::     path relative to the built language (e.g. sproutcore/en) less file extension
-  # ext::          the file extension
-  # source_path:: absolute paths into source that will comprise this resource
-  # url::          the url that should be used to reference this resource in the current build mode.
-  # current_url::  the url that can be used to reference this resource, substituting "current" for a build number
-  # build_path::   absolute path to the compiled resource
-  # type::         the top-level category
-  # original_path:: save the original path used to build this entry
-  # hidden::       if true, this entry is needed internally, but otherwise should not be used
-  # use_source_directly::  if true, then this entry should be handled via the build symlink
-  # language::     the language in use when this entry was created
-  # composite::    If set, this will contain the filenames of other resources that should be combined to form this resource.
-  # bundle:: the owner bundle for this entry
-  # platform:: the target platform for the entry, if any
-  #
-  class ManifestEntry < Struct.new(:filename, :ext, :source_path, :url, :build_path, :type, :original_path, :hidden, :use_source_directly, :language, :use_digest_tokens, :platform, :current_url)
-    def to_hash
-      ret = {}
-      self.members.zip(self.values).each { |p| ret[p[0]] = p[1] }
-      ret.symbolize_keys
-    end
-    def composite; @composite; end
-    def composite=(ary); @composite=ary; end
-    def hidden?; !!hidden; end
-    def use_source_directly?; !!use_source_directly; end
-    def composite?; !!composite; end
-    def localized?; !!source_path.match(/\.lproj/); end
-    # Returns true if this entry can be cached even in development mode.
-    # Composite resources and tests need to be regenerated whenever you get
-    # this.
-    def cacheable?
-      !composite? && (type != :test)
-    end
-    def composite_filenames
-      @composite_filenames ||= (composite || []).map { |x| x.filename }
-    end
-    # Returns the mtime of the source_path.  If this entry is a composite
-    # return the latest mtime of the items or if the source file does not
-    # exist, returns nil
-    def source_path_mtime
-      return @source_path_mtime unless @source_path_mtime.nil?
-      if composite?
-        mtimes = (composite || []).map { |x| x.source_path_mtime }
-        ret = mtimes.compact.sort.last
-      else
-        ret = (File.exists?(source_path)) ? File.mtime(source_path) : nil
-      end
-      return @source_path_mtime = ret
-    end
-    # Returns a timestamp based on the source_path_mtime.  If
-    # source_path_mtime is nil, always returns a new timestamp
-    def timestamp
-      (source_path_mtime || Time.now).to_i.to_s
-    end
-    # Returns an MD5::digest of the file.  If the file is composite, returns
-    # the MD5 digest of all the composite files.
-    def digest
-      return @digest unless @digest.nil?
-      if composite?
-        digests = (composite || []).map { |x| x.digest }
-        ret = Digest::SHA1.hexdigest(digests.join)
-      else
-        ret = (File.exists?(source_path)) ? Digest::SHA1.hexdigest(File.read(source_path)) : '0000'
-      end
-      @digest = ret
-    end
-    # Returns the content type for this entry.  Based on a set of MIME_TYPES
-    # borrowed from Rack
-    def content_type
-      MIME_TYPES[File.extname(build_path)[1..-1]] || 'text/plain'
-    end
-    # Returns a URL that takes into account caching requirements.
-    def cacheable_url
-      url
-      #token = (use_digest_tokens) ? digest : timestamp
-      #[url, token].compact.join('?')
-    end
-    # :stopdoc:
-    # From WEBrick.
-    MIME_TYPES = {
-      "ai"    => "application/postscript",
-      "asc"   => "text/plain",
-      "avi"   => "video/x-msvideo",
-      "bin"   => "application/octet-stream",
-      "bmp"   => "image/bmp",
-      "class" => "application/octet-stream",
-      "cer"   => "application/pkix-cert",
-      "crl"   => "application/pkix-crl",
-      "crt"   => "application/x-x509-ca-cert",
-     #"crl"   => "application/x-pkcs7-crl",
-      "css"   => "text/css",
-      "dms"   => "application/octet-stream",
-      "doc"   => "application/msword",
-      "dvi"   => "application/x-dvi",
-      "eps"   => "application/postscript",
-      "etx"   => "text/x-setext",
-      "exe"   => "application/octet-stream",
-      "gif"   => "image/gif",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "rhtml" => "text/html",
-      "jpe"   => "image/jpeg",
-      "jpeg"  => "image/jpeg",
-      "jpg"   => "image/jpeg",
-      "lha"   => "application/octet-stream",
-      "lzh"   => "application/octet-stream",
-      "mov"   => "video/quicktime",
-      "mpe"   => "video/mpeg",
-      "mpeg"  => "video/mpeg",
-      "mpg"   => "video/mpeg",
-      "pbm"   => "image/x-portable-bitmap",
-      "pdf"   => "application/pdf",
-      "pgm"   => "image/x-portable-graymap",
-      "png"   => "image/png",
-      "pnm"   => "image/x-portable-anymap",
-      "ppm"   => "image/x-portable-pixmap",
-      "ppt"   => "application/vnd.ms-powerpoint",
-      "ps"    => "application/postscript",
-      "qt"    => "video/quicktime",
-      "ras"   => "image/x-cmu-raster",
-      "rb"    => "text/plain",
-      "rd"    => "text/plain",
-      "rtf"   => "application/rtf",
-      "sgm"   => "text/sgml",
-      "sgml"  => "text/sgml",
-      "tif"   => "image/tiff",
-      "tiff"  => "image/tiff",
-      "txt"   => "text/plain",
-      "xbm"   => "image/x-xbitmap",
-      "xls"   => "application/vnd.ms-excel",
-      "xml"   => "text/xml",
-      "xpm"   => "image/x-xpixmap",
-      "xwd"   => "image/x-xwindowdump",
-      "zip"   => "application/zip",
-      "js"    => "text/javascript",
-      "json"  => "text/json"
-    }
-    # :startdoc:
-  end
-end