sproutcore 0.9.0

data/lib/sproutcore/jsmin.rb

@@ -0,0 +1,247 @@
+# This version of jsmin has been adapted for use in a module.
+
+# jsmin.rb 2007-07-20
+# Author: Uladzislau Latynski
+# This work is a translation from C to Ruby of jsmin.c published by
+# Douglas Crockford.  Permission is hereby granted to use the Ruby
+# version under the same conditions as the jsmin.c on which it is
+# based.
+#
+# /* jsmin.c
+#    2003-04-21
+#
+# Copyright (c) 2002 Douglas Crockford  (www.crockford.com)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+# of the Software, and to permit persons to whom the Software is furnished to do
+# so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# The Software shall be used for Good, not Evil.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module SproutCore
+
+  class JSMin
+    EOF = -1
+    
+    # this will minify a single line 
+    def self.run(str)
+      minifier = SproutCore::JSMin.new(str)
+      minifier.jsmin
+      minifier.stdout
+    end
+    
+    def initialize(str) 
+      @theA = ""
+      @theB = ""
+      @str = str || ''
+      @loc = 0
+      @stdout = ''
+    end
+
+    def stdin_getc
+      ret = @str.nil? || (@loc >= @str.size) ? nil : @str[@loc]
+      @loc += 1
+      return ret 
+    end
+    
+    def stdin_ungetc(str)
+      @loc -= 1
+      @loc = 0 if @loc < 0
+    end
+    
+    def stdout_write(chr)
+      @stdout << chr
+    end
+    
+    def stdout
+      return @stdout
+    end
+    
+#### JSMIN
+## To update, replace the text below with the latest jsmin.rb. Then replace:
+## $theA => @theA, $theB => @theB, 
+## $stdin.getc => stdin_getc, $stdin.ungetc => stding_ungetc, 
+## $stdout.write => stdout_write
+
+    # isAlphanum -- return true if the character is a letter, digit, 
+    # underscore, dollar sign, or non-ASCII character
+    def isAlphanum(c)
+      return false if !c || c == EOF
+      return ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
+      (c >= 'A' && c <= 'Z') || c == '_' || c == '$' ||
+      c == '\\' || c[0] > 126)
+    end
+
+    # get -- return the next character from stdin. Watch out for lookahead. 
+    # If the character is a control character, translate it to a space or 
+    # linefeed.
+    def get()
+      c = stdin_getc
+      return EOF if(!c)
+      c = c.chr
+      return c if (c >= " " || c == "\n" || c.unpack("c") == EOF)
+      return "\n" if (c == "\r")
+      return " "
+    end
+
+    # Get the next character without getting it.
+    def peek()
+      lookaheadChar = stdin_getc
+      stdin_ungetc(lookaheadChar)
+      return lookaheadChar.chr
+    end
+
+    # mynext -- get the next character, excluding comments.
+    # peek() is used to see if a '/' is followed by a '/' or '*'.
+    def mynext()
+      c = get
+      if (c == "/")
+        if(peek == "/")
+          while(true)
+            c = get
+            if (c <= "\n")
+              return c
+            end
+          end
+        end
+        if(peek == "*")
+          get
+          while(true)
+            case get
+            when "*"
+              if (peek == "/")
+                get
+                return " "
+              end
+            when EOF
+              raise "Unterminated comment"
+            end
+          end
+        end
+      end
+      return c
+    end
+
+
+    # action -- do something! What you do is determined by the argument: 1
+    # Output A. Copy B to A. Get the next B. 2 Copy B to A. Get the next B.
+    # (Delete A). 3 Get the next B. (Delete B). action treats a string as a
+    # single character. Wow! action recognizes a regular expression if it is
+    # preceded by ( or , or =.
+    def action(a)
+      if(a==1)
+        stdout_write @theA
+      end
+      if(a==1 || a==2)
+        @theA = @theB
+        if (@theA == "\'" || @theA == "\"")
+          while (true)
+            stdout_write @theA
+            @theA = get
+            break if (@theA == @theB)
+            raise "Unterminated string literal" if (@theA <= "\n")
+            if (@theA == "\\")
+              stdout_write @theA
+              @theA = get
+            end
+          end
+        end
+      end
+      if(a==1 || a==2 || a==3)
+        @theB = mynext
+        if (@theB == "/" && (@theA == "(" || @theA == "," || @theA == "=" ||
+          @theA == ":" || @theA == "[" || @theA == "!" ||
+          @theA == "&" || @theA == "|" || @theA == "?" ||
+          @theA == "{" || @theA == "}" || @theA == ";" ||
+          @theA == "\n"))
+          stdout_write @theA
+          stdout_write @theB
+          while (true)
+            @theA = get
+            if (@theA == "/")
+              break
+            elsif (@theA == "\\")
+              stdout_write @theA
+              @theA = get
+            elsif (@theA <= "\n")
+              raise "Unterminated RegExp Literal"
+            end
+            stdout_write @theA
+          end
+          @theB = mynext
+        end
+      end
+    end
+
+    # jsmin -- Copy the input to the output, deleting the characters which are
+    # insignificant to JavaScript. Comments will be removed. Tabs will be
+    # replaced with spaces. Carriage returns will be replaced with linefeeds.
+    # Most spaces and linefeeds will be removed.
+    def jsmin
+      @theA = "\n"
+      action(3)
+      while (@theA != EOF)
+        case @theA
+        when " "
+          if (isAlphanum(@theB))
+            action(1)
+          else
+            action(2)
+          end
+        when "\n"
+          case (@theB)
+          when "{","[","(","+","-"
+            action(1)
+          when " "
+            action(3)
+          else
+            if (isAlphanum(@theB))
+              action(1)
+            else
+              action(2)
+            end
+          end
+        else
+          case (@theB)
+          when " "
+            if (isAlphanum(@theA))
+              action(1)
+            else
+              action(3)
+            end
+          when "\n"
+            case (@theA)
+            when "}","]",")","+","-","\"","\\", "'", '"'
+              action(1)
+            else
+              if (isAlphanum(@theA))
+                action(1)
+              else
+                action(3)
+              end
+            end
+          else
+            action(1)
+          end
+        end
+      end
+    end
+
+################ END JSMIN
+  end
+
+end

data/lib/sproutcore/library.rb

@@ -0,0 +1,258 @@
+require 'yaml'
+
+module SproutCore
+  
+  # Describes a single library that can contain one or more clients and frameworks. 
+  # This class is used to automatically locate all installed libraries and to register the
+  # clients within them.
+  # 
+  # Libraries are chained, with the child library replacing the parent library's settings.
+  # In general, the root library is always the current app while its parent libraries are 
+  # those found in the load path or explicitly stated in the configs.
+  class Library
+
+    # Creates a chained set of libraries from the passed location and the load path
+    def self.library_for(root_path, opts = {})
+      
+      # Find libraries in the search paths, build chain
+      root_path = File.expand_path(root_path)
+      paths = libraries_in($:).reject { |x| x == root_path }
+      paths.unshift(root_path)
+      ret = nil
+      
+      # Convert chain to library objects.  The last path processed should be
+      # the one passed in to this method.
+      while path = paths.pop 
+        ret = self.new(path, opts, ret)
+      end
+      
+      # Return library object for root_path
+      return ret 
+    end
+    
+    # Searches the array of paths, returning the array of paths that are actually libraries.
+    #
+    # ==== Params
+    # paths<Array>:: Array of libraries.
+    #
+    def self.libraries_in(paths)
+      ret = paths.map do |p|
+        p = File.expand_path(p) # expand
+        [p, p.gsub(/\/lib$/,'')].reject { |x| !is_library?(x) }
+      end
+      ret.flatten.compact.uniq
+    end
+    
+    # Heuristically determine if a particular location is a library.
+    def self.is_library?(path)
+      has_it = %w(clients frameworks environment.yml).map do |x|
+        File.exists?(File.join(path, x))
+      end
+      return false unless has_it.pop
+      has_it.each { |x| return true if x }
+      return false
+    end
+    
+    # The root path for this library
+    attr_reader :root_path
+    
+    # The raw environment hash loaded from disk.  Generally use computed_environment,
+    # which combines the parent.
+    attr_reader :environment
+    
+    # The parent library, used for load order dependency
+    attr_accessor :next_library
+    
+    # The client directories found in this library.  This usually maps directly to a 
+    # client name but it may not if you have set up some other options.
+    def client_directories
+      return @client_dirs unless @client_dirs.nil?
+      client_path = File.join(@root_path, 'clients') 
+      if File.exists?(client_path)
+        @client_dirs = Dir.entries(client_path).reject do |x| 
+          (/^\./ =~ x) || !File.directory?(File.join(client_path,x))
+        end
+      else
+        @client_dirs = []
+      end
+      
+      return @client_dirs
+    end
+
+    # The framework directories found in this library
+    def framework_directories
+      return @framework_dirs unless @framework_dirs.nil?
+      framework_path = File.join(@root_path, 'frameworks') 
+      if File.exists?(framework_path)
+        @framework_dirs = Dir.entries(framework_path).reject do |x| 
+          (/^\./ =~ x) || !File.directory?(File.join(framework_path,x))
+        end
+      else
+        @framework_dirs = []
+      end
+      
+      return @framework_dirs
+    end
+
+    # Returns all of the client names known to the current environment, including 
+    # through parent libraries.
+    def client_names
+      return @cache_client_names unless @cache_client_names.nil?
+      
+      ret = next_library.nil? ? [] : next_library.client_directories
+      ret += client_directories
+      return @cache_client_names = ret.compact.uniq.sort
+    end
+    
+    # Returns all of the framework names known to the current environment, including
+    # through parent libraries.
+    def framework_names
+      return @cache_framework_names unless @cache_framework_names.nil?
+      
+      ret = next_library.nil? ? [] : next_library.framework_directories
+      ret += framework_directories
+      return @cache_framework_names = ret.compact.uniq.sort
+    end  
+    
+    # ==== Returns
+    # A hash of all bundle names mapped to root url.  This method is optimized for frequent
+    # requests so you can use it to route incoming requests.
+    def bundles_grouped_by_url
+      return @cached_bundles_by_url unless @cached_bundles_by_url.nil?
+      ret = {}
+      bundles.each { |b| ret[b.url_root] = b; ret[b.index_root] = b }
+      return @cached_bundles_by_url = ret
+    end
+    
+    # ==== Returns
+    # A bundle for the specified name.  If the bundle has not already been created, then
+    # it will be created.
+    def bundle_for(bundle_name)
+      bundle_name = bundle_name.to_sym
+      @bundles ||= {}
+      return @bundles[bundle_name] ||= Bundle.new(bundle_name, environment_for(bundle_name))      
+    end
+    
+    # ==== Returns 
+    # All of the bundles for registered clients
+    def client_bundles
+      @cached_client_bundles ||= client_names.map { |x| bundle_for(x) }
+    end
+
+    # ==== Returns 
+    # All of the bundles for registered frameworks
+    def framework_bundles
+      @cached_framework_bundles ||= framework_names.map { |x| bundle_for(x) }
+    end
+    
+    # ==== Returns
+    # All known bundles, both framework & client
+    def bundles
+      @cached_all_bundles ||= (client_bundles + framework_bundles)
+    end
+    
+    # Build all of the bundles in the library.  This can take awhile but it is the simple
+    # way to get all of your code onto disk in a deployable state
+    def build(*languages)
+      (client_bundles + framework_bundles).each do |bundle|
+        puts "building: #{bundle.bundle_name}"
+        bundle.build(*languages)
+      end
+    end
+    
+    # Returns the computed environment for a particular client or framework.
+    # This will go up the chain of parent libraries, retrieving and merging any known
+    # environment settings.  The returned options are suitable for passing to the ClientBuilder
+    # for registration.
+    def environment_for(bundle_name)
+
+      is_local_client = client_directories.include?(bundle_name.to_s)
+      is_local_framework = framework_directories.include?(bundle_name.to_s)
+      ret = nil
+      
+      # CASE 1: If named client or framework is local, then use our local settings
+      if (is_local_client || is_local_framework)
+        
+        # start with local environment
+        ret = (environment[:all] || {}).dup
+        
+        # Now fill in some default values based on what we know
+        # This should be enough to make the bundle load
+        ret[:bundle_name] = bundle_name.to_sym
+        ret[:bundle_type] = is_local_framework ? :framework : :client
+        ret[:requires] = [:prototype, :sproutcore] if ret[:requires].nil?
+        
+        # Fill in the source_root since we know where this came from
+        ret[:source_root] = File.join(root_path, ret[:bundle_type].to_s.pluralize, bundle_name.to_s)
+          
+      # CASE 2: Otherwise, if we have a next library, see if the next library has something
+      else 
+        ret = next_library.nil? ? nil : next_library.environment_for(bundle_name)
+      end
+
+      # Final fixup
+      unless ret.nil?
+        # Always url_prefix & index_prefix are always used.
+        all = environment[:all] || {}
+        [:url_prefix, :all_prefix, :preferred_language].each do |key|
+          ret[key] = all[key] if all.include?(key)
+        end
+      
+        # Either way, if we have local settings for this specific client, they override whatever
+        # we cooked up just now.
+        local_settings = environment[bundle_name.to_sym] 
+        ret = ret.merge(local_settings) unless local_settings.nil?
+
+        # Always replace the library with self so that we get the correct root location for
+        # public paths, etc. 
+        ret[:library] = self
+      end
+      
+      
+      # CASE 3: Next library doesn't know about this client.  Neither do we.  Even if the
+      # user has provided some environmental options, there is no source content, so just 
+      # return nil
+      return ret 
+    end
+
+    protected
+    
+    # Load the library at the specified path.  Loads the environment.yml if it exists
+    # and then detects all clients and frameworks in the library.  If you pass any options,
+    # those will overlay any :all options you specify in your environment.yml file.
+    # 
+    # You cannot create a library directly using this method.  Instead is library_in()
+    #
+    def initialize(rp, opts = {}, next_lib = nil)
+      @root_path = rp
+      @next_library = next_lib
+      @load_opts = opts
+      load_environment!(opts)
+    end
+    
+    # Internal method loads the actual environment
+    def load_environment!(opts=nil)
+      env_path = File.join(root_path, 'environment.yml')
+      env = {}
+      if File.exists?(env_path)
+        f = File.open(env_path)
+        env = YAML::load(f) rescue nil
+        f.close
+      end
+      env = {} if env.nil?
+
+      # symbolize
+      @environment = {}
+      env.each do |k,v|
+        @environment[k.to_sym] = v.respond_to?(:symbolize_keys) ? v.symbolize_keys : v 
+      end
+      
+      # Overlay :all opts, if passed
+      @environment[:all] = (@environment[:all] || {}).merge(opts) unless opts.nil?
+    end
+    
+  end
+  
+end
+
+  

data/lib/sproutcore/merb/bundle_controller.rb

@@ -0,0 +1,179 @@
+require 'sproutcore/jsdoc'
+
+module SproutCore
+  module Merb
+   
+    # A subclass of this controller handles all incoming requests for the location it is
+    # mounted at.  For index.html requests, it will rebuild the html file everytime it is
+    # requested if you are in development mode.  For all other requests, it will build the
+    # resource one time and then return the file if it already exists.
+    class BundleController < ::Merb::Controller
+      
+      def self.library_for_class(klass)
+        (@registered_libraries ||= {})[klass]
+      end
+      
+      def self.register_library_for_class(library, klass)
+        (@registered_libraries ||= {})[klass] = library
+      end
+        
+      # Entry point for all requests routed through the SproutCore controller.  Example
+      # the request path to determine which bundle should handle the request.
+      def main
+
+        # Before we do anything, set the build_mode for the bundles.  This shouldn't change
+        # during execution, but if we set this during the router call, the Merb.environment
+        # is sometimes not ready yet.
+        if ::Merb.environment.to_sym == :production
+          Bundle.build_mode = :production
+        else
+          ::SproutCore.logger.level = Logger::DEBUG
+        end
+        
+        # Make sure we can service this with a bundle
+        raise(NotFound, "No SproutCore Bundle registered at this location.") if current_bundle.nil?
+
+        # Check for a few special urls that need to be rewritten
+        url = request.path
+        puts "BEFORE URL: #{url} current_bundle: #{current_bundle.bundle_name}"
+        if request.method == :get 
+          url = rewrite_bundle_if(url, /^#{current_bundle.index_root}\/-tests/, :sc_test_runner)
+          url = rewrite_bundle_if(url, /^#{current_bundle.index_root}\/-docs/, :sc_docs)
+        end
+
+        # If we are in development mode, reload bundle first
+        current_bundle.reload! if current_bundle.build_mode == :development
+
+        puts "AFTER URL: #{url} current_bundle: #{current_bundle.bundle_name}"
+
+        # Get the normalized URL for the requested resource
+        url = current_bundle.normalize_url(url)
+
+        
+        # Check for a few special urls for built-in services and route them off
+        case url
+        when "#{current_bundle.url_root}/-tests/index.js"
+          ret = handle_test(url)
+        when "#{current_bundle.index_root}/-docs"
+          ret = (request.method == :post) ? handle_doc(url) : handle_resource(url)
+
+        when "#{current_bundle.url_root}/-docs"
+          ret = (request.method == :post) ? handle_doc(url) : handle_resource(url)
+
+        else
+          ret = handle_resource(url)
+        end
+        
+        # Done!
+        return ret
+      end
+      
+      # Invoked whenever you request a regular resource
+      def handle_resource(url)
+        
+        # Get the entry for the resource.  
+        entry = current_bundle.entry_for_url(url, :hidden => :include)
+        raise(NotFound, "No matching entry in #{current_bundle.bundle_name}") if entry.nil?
+
+        
+        build_path = entry.build_path
+
+        # Found an entry, build the resource.  If the resource has already been built, this
+        # will not do much.  If this the resource is an index.html file, force the build.
+        is_index = /\/index\.html$/ =~ url
+        puts "building: #{url} - is_index: #{is_index}"
+        
+        current_bundle.build_entry(entry, :force => is_index, :hidden => :include)
+
+        # Move to final build path if necessary
+        if (build_path != entry.build_path) && File.exists?(entry.build_path)
+          FileUtils.mv(entry.build_path, build_path)
+        end
+
+        # And return the file.  Set the content type using a mime-map borroed from Rack.
+        headers['Content-Type'] = entry.content_type
+        headers['Content-Length'] = File.size(build_path).to_s
+        ret = File.open(build_path)
+        
+        
+        # In development mode only, immediately delete built composite resources.  We want 
+        # each request to come directly to us.
+        if (current_bundle.build_mode == :development) && (!entry.cacheable?)
+          FileUtils.rm(build_path)
+        end
+        
+        return ret
+      end
+
+      # Returns JSON containing all of the tests
+      def handle_test(url)
+        test_entries = current_bundle.entries_for(:test, :hidden => :include)
+        content_type = :json
+        ret = test_entries.map do |entry| 
+          { :name => entry.filename.gsub(/^tests\//,''), :url => "#{entry.url}?#{entry.timestamp}" }
+        end
+        return ret.to_json
+      end
+
+      # If you POST to this URL, regenerates the docs.
+      def handle_doc(url)
+        JSDoc.generate :bundle => current_bundle
+        return "OK"
+      end
+      
+      ######################################################################
+      ## Support Methods
+      ##
+      
+      # Returns the library for this class
+      def library
+        ::SproutCore::Merb::BundleController.library_for_class(self.class)
+      end
+      
+      
+      # Returns the bundle for this request
+      def current_bundle
+        return @current_bundle unless @current_bundle.nil?
+
+        # Tear down the URL, looking for the first bundle 
+        bundle_map = library.bundles_grouped_by_url
+        url = request.path.split('/')
+        ret = nil
+        while url.size > 0 && ret.nil?
+          ret = bundle_map[url.join('/')]
+          url.pop
+        end
+        
+        # Try root path if nothing found
+        ret = bundle_map['/'] if ret.nil?
+        
+        # Return
+        return (@current_bundle = ret)
+      end
+
+      # This method is used to redirect certain urls to an alternate bundle.  If the 
+      # match phrase matches the url, then both the url we use to fetch resources and the
+      # current_bundle will be swapped out.
+      #
+      # ===== Params
+      # url<String>:: The url to check
+      # match<Regex>:: The pattern to match and optionally later replace
+      # new_bundle_name<Symbol>:: The name of the new bundle to swap in if matched
+      #
+      # ===== Returns
+      # The rewritten url.  May also change the value of current_bundle
+      #
+      def rewrite_bundle_if(url, match, new_bundle_name)
+        return url unless match =~ url
+        new_bundle = library.bundle_for(new_bundle_name)
+        if new_bundle
+          url = url.gsub(match, new_bundle.index_root)
+          @current_bundle = new_bundle
+        end
+        return url
+      end
+      
+    end
+    
+  end
+end