sproutcore 1.6.0.beta.2-x86-mingw32

data/lib/sproutcore/rack/filesystem.rb

@@ -0,0 +1,324 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Mike Subelsky
+#            portions copyright @2006-2011 Strobe Inc.
+#            and contributors
+# ===========================================================================
+
+require 'rubygems'
+require 'rack'
+require 'rack/request'
+require 'rack/utils'
+require 'rack/file'
+require 'find'
+module SC
+  module Rack
+
+    # Sends and modifies files in the local file system. Uses Rack::Rack::File to
+    # transfer the file, which makes this work with rack/sendfile and other
+    # middleware. Some code originally adapted from Rack::Rack::File.
+    class Filesystem
+
+      def initialize(project)
+        @project = project
+        @ignore_directories = ['tmp', 'scripts', 'sproutcore'];
+      end
+
+      def root_dir
+        unless @root_dir
+          @root_dir = @project.project_root
+        end
+        return @root_dir
+      end
+
+      # Accepts the following commands
+      #
+      # GET /foo/bar/blah
+      # - send blah back to the client
+      #
+      # POST /foo/bar/blah with no "action" body parameter
+      # - also sends contents of blah back to the client (defeats caching)
+      #
+      # POST to /foo/bar/blah with "action=save" and "file" body parameters
+      # - create a file named "blah" with contents  of file  OR overwrite
+      #   "blah" with contents of file; create /foo/bar if needed
+      #
+      # POST to /foo/bar/blah with "action=touch" body parameter
+      # - create an empty file named "blah" OR update the timestamp of blah;
+      #   create /foo/bar if needed
+      #
+      # POST to /foo/bar/blah with "action=makedir" body parameter
+      # - create a directory named "blah" and create parent directories if
+      #   needed
+      #
+      # POST to /foo/bar/blah with "action=append" and "file" body parameters
+      # - append the contents of the file body parameter to the blah file;
+      #   return error if "blah" doesn't exist
+      #
+      # POST to /foo/bar/blah with "action=remove" body parameter
+      # - delete a file or directory named "blah"; will fail if directory is
+      #   not empty
+      def call(env)
+        regex = /^\/sproutcore\/fs/
+        rqust = ::Rack::Request.new(env)
+        params = rqust.params
+        body = rqust.body.read()
+        path = env["PATH_INFO"]
+
+        return [404, {}, "not found"] unless path =~ regex
+
+        path = path.sub regex, '' # remove path prefix
+        action = params['action']
+
+        #Missing:
+        #need a way to rename/move files and folders
+
+        case action
+        when nil #sends the contents of the file
+          send_file(path)
+        when 'list' #returns folder structure
+          list_files(path)
+        when 'save' #doesn't do anything useful
+          save_file(path,params)
+        when 'overwrite'  #overwrites file's contents with whatever is sent
+          overwrite_file(path,params,body)
+        when 'append' #does nothing
+          append_file(path,params)
+        when 'touch' #creates a file
+          touch_file(path)
+          overwrite_file(path,params,body) if body
+        when 'mkdir' #creates a folder
+          make_directory(path)
+        when 'remove' #removes the file
+          remove_path(path)
+        else
+          forbidden("Unknown action #{params['action']}")
+        end
+      rescue StandardError
+        return forbidden("Cannot #{action} #{path} due to #{$!.message}")
+      end
+
+      private
+
+      def list_files(original_path)
+        results = []
+        @id = 0
+        with_sanitized_path(original_path) do |root_path|
+          results = folder_contents(root_path)
+        end
+        success(results.to_json)
+      end
+
+      def folder_contents(dir)
+        results = []
+
+        Dir.new(dir).each do |path|
+          name = path
+          path = dir + path
+          sc_path = dir.gsub(root_dir,"")
+          if FileTest.directory?(path)
+            if not (File.basename(path)[0] == ?. or @ignore_directories.include?(File.basename(path)))
+              results<< {:type => :Dir, :dir => sc_path, :name =>name,
+                          :contents=> folder_contents(path+"/"), :id => @id+=1}
+            end
+          else #just a regular file
+            results<< {:type => :File, :dir => sc_path, :name => name, :id => @id+=1 }
+          end
+        end
+        return results
+      end
+
+      # This method will blast the current file
+      #
+      # @param current_file_path | the path of the current file
+      # @param params | the contents of the file
+      def overwrite_file(current_file_path, params, body)
+        with_sanitized_path(current_file_path) do |file_path|
+            blast_current_file(file_path, params, body)
+            success("Saved your changes to #{file_path}")
+        end
+      end
+
+      def send_file(original_path)
+        with_sanitized_path(original_path) do |sanitized_path|
+          with_readable_path(sanitized_path) do |readable_path|
+            send_file_response(readable_path)
+          end
+        end
+      end
+
+      def save_file(original_path,params)
+        with_sanitized_path(original_path) do |sanitized_path|
+          with_modifiable_path(sanitized_path) do |dest_path|
+            save_to_file(dest_path,params)
+            success("Saved #{dest_path}")
+          end
+        end
+      end
+
+      def append_file(original_path,params)
+        with_sanitized_path(original_path) do |sanitized_path|
+          with_modifiable_path(sanitized_path) do |dest_path|
+            append_to_file(dest_path,params)
+            success("Appended to #{dest_path}")
+          end
+        end
+      end
+
+      def touch_file(original_path)
+        with_sanitized_path(original_path) do |sanitized_path|
+          with_modifiable_path(sanitized_path) do |dest_path|
+            FileUtils.touch(dest_path)
+            success("Touched #{original_path}")
+          end
+        end
+      end
+
+      def make_directory(original_path)
+        with_sanitized_path(original_path) do |sanitized_path|
+          with_modifiable_path(sanitized_path) do |dest_path|
+            FileUtils.mkdir(dest_path)
+              # with_modifiable_path call takes care of any parent directories
+            success("Created directory #{original_path}")
+          end
+        end
+      end
+
+      # will raise SystemCallError if the path to be removed is a non-empty
+      # directory
+
+      def remove_path(original_path)
+        with_sanitized_path(original_path) do |destroy_path|
+          return not_found(original_path) unless File.exist?(destroy_path)
+          return forbidden(
+            "Cannot modify #{destroy_path}"
+          ) unless File.writable?(destroy_path)
+          if File.directory?(destroy_path)
+            Dir.rmdir(destroy_path)
+            success("Removed directory #{destroy_path}")
+          else
+            File.delete(destroy_path)
+            success("Removed file #{destroy_path}")
+          end
+        end
+      end
+
+      def save_to_file(dest_path,params)
+        with_tempfile_path(params['file']) do |tempfile_path|
+          puts "moving #{tempfile_path} to #{dest_path}"
+          FileUtils.mv(tempfile_path,dest_path)
+        end
+      end
+
+      def blast_current_file(dest_path, params, body)
+        return not_found(dest_path) unless File.exist?(dest_path)
+        return forbidden("Cannot modify #{dest_path}") unless File.writable?(dest_path)
+        return forbidden("No content body for #{dest_path}") unless body
+        File.open(dest_path, 'w') do |f|
+          f.puts(body)
+        end
+      end
+
+      def append_to_file(dest_path,params)
+        with_tempfile_path(params['file']) do |tempfile_path|
+          ::Rack::File.open(dest_path,'a') do |dest_file|
+            ::Rack::File.open(tempfile_path,'r') do |source_file|
+              FileUtils.copy_stream(source_file,dest_file)
+            end
+          end
+        end
+      end
+
+      def with_tempfile_path(file_param)
+        return forbidden("Did not receive a file") unless file_param
+        tempfile = file_param[:tempfile]
+        return forbidden("File was not uploaded") unless tempfile
+        yield tempfile.path
+      end
+
+      def send_file_response(path)
+        if size = File.size?(path)
+          # use Rack::File so streaming works and for max compatibility with
+          # other handlers
+          # TODO we could make this work with Rack::Sendfile pretty easily if
+          # the server supports it
+          body = ::Rack::File::new(root_dir)
+          body.path = path
+          body
+        else
+          # file does not provide size info via stat, so we have to read it
+          # into memory
+          body = [File.read(path)]
+          size = ::Rack::Utils.bytesize(body.first)
+        end
+
+        [200, {
+          "Last-Modified"  => File.mtime(path).httpdate,
+          "Content-Type" =>
+            ::Rack::Mime.mime_type(File.extname(path), 'text/plain'),
+          "Content-Length" => size.to_s
+        }, body]
+      end
+
+      def with_readable_path(path)
+        return not_found(path) unless File.file?(path)
+        return forbidden("Cannot read #{path}") unless File.readable?(path)
+        yield path
+      end
+
+      def with_sanitized_path(orig_path)
+        path = ::Rack::Utils.unescape(orig_path)
+        return forbidden("Illegal path #{path}") if path.include?("..")
+
+        yield File.join(root_dir, path)
+      end
+
+      def not_found(path)
+        body = "Path not found: #{path}\n"
+        [404, {
+          "Content-Type" => "text/plain",
+          "Content-Length" => body.size.to_s},
+          [body]
+        ]
+      end
+
+      def forbidden(body)
+        body += "\n" unless body =~ /\n$/
+        [403, {
+          "Content-Type" => "text/plain",
+          "Content-Length" => body.size.to_s},
+          [body]
+        ]
+      end
+
+      def success(msg)
+        [ 200, { 'Content-Type' => 'text/html' }, msg ]
+      end
+
+      def with_modifiable_path(path)
+        # can't use File.dirname here as it only recognizes Unix separators
+        path_parts = path.split(::File::SEPARATOR)
+        dir_name = File.join(path_parts[0..-2])
+
+        begin
+          FileUtils.mkdir_p(dir_name)
+        rescue Errno::EACCES
+          return forbidden(
+            "Cannot create directory #{dir_name} due to #{$!.message}"
+          )
+        end
+
+        return forbidden(
+          "Cannot write to directory #{dir_name}"
+        ) unless File.writable?(dir_name)
+
+        if File.file?(path) && !File.writable?(path)
+          return forbidden("Cannot write to file #{path}")
+        end
+
+        yield path
+      end
+
+    end
+  end
+end

data/lib/sproutcore/rack/proxy.rb

@@ -0,0 +1,165 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe Inc.
+#            and contributors
+# ===========================================================================
+
+begin
+  require 'net/https'
+  SC::HTTPS_ENABLED = true
+rescue LoadError => e
+  require 'net/http'
+  SC::HTTPS_ENABLED = false
+end
+
+module SC
+  module Rack
+
+    # Rack application proxies requests as needed for the given project.
+    class Proxy
+
+      def initialize(project)
+        @project = project
+        @proxies = project.buildfile.proxies
+      end
+
+      def call(env)
+        url = env['PATH_INFO']
+
+        @proxies.each do |proxy, value|
+          if url.match(/^#{Regexp.escape(proxy.to_s)}/)
+            return handle_proxy(value, proxy.to_s, env)
+          end
+        end
+
+        return [404, {}, "not found"]
+      end
+
+      def handle_proxy(proxy, proxy_url, env)
+        if proxy[:secure] && !SC::HTTPS_ENABLED
+          SC.logger << "~ WARNING: HTTPS is not supported on your system, using HTTP instead.\n"
+          SC.logger << "    If you are using Ubuntu, you can run `apt-get install libopenssl-ruby`\n"
+          proxy[:secure] = false
+        end
+
+        origin_host = env['SERVER_NAME'] # capture the origin host for cookies
+        http_method = env['REQUEST_METHOD'].to_s.downcase
+        url = env['PATH_INFO']
+        params = env['QUERY_STRING']
+
+        # collect headers...
+        headers = {}
+        env.each do |key, value|
+          next unless key =~ /^HTTP_/
+          key = key.gsub(/^HTTP_/,'').downcase.sub(/^\w/){|l| l.upcase}.gsub(/_(\w)/){|l| "-#{$1.upcase}"} # remove HTTP_, dasherize and titleize
+          if !key.eql? "Version"
+            headers[key] = value
+          end
+        end
+
+        # Rack documentation says CONTENT_TYPE and CONTENT_LENGTH aren't prefixed by HTTP_
+        headers['Content-Type'] = env['CONTENT_TYPE'] if env['CONTENT_TYPE']
+
+        length = env['CONTENT_LENGTH']
+        headers['Content-Length'] = length if length
+
+        http_host, http_port = proxy[:to].split(':')
+        http_port = proxy[:secure] ? '443' : '80' if http_port.nil?
+
+        # added 4/23/09 per Charles Jolley, corrects problem
+        # when making requests to virtual hosts
+        headers['Host'] = "#{http_host}:#{http_port}"
+
+        if proxy[:url]
+          url = url.sub(/^#{Regexp.escape proxy_url}/, proxy[:url])
+        end
+
+        http_path = [url]
+        http_path << params if params && params.size>0
+        http_path = http_path.join('?')
+
+        response = nil
+        no_body_method = %w(get copy head move options trace)
+
+        done = false
+        tries = 0
+        until done
+          http = ::Net::HTTP.new(http_host, http_port)
+
+          if proxy[:secure]
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+
+          http.start do |web|
+            if no_body_method.include?(http_method)
+              response = web.send(http_method, http_path, headers)
+            else
+              http_body = env['rack.input']
+              http_body.rewind # May not be necessary but can't hurt
+
+              req = Net::HTTPGenericRequest.new(http_method.upcase,
+                                                  true, true, http_path, headers)
+              req.body_stream = http_body if length.to_i > 0
+              response = web.request(req)
+            end
+          end
+
+          status = response.code # http status code
+          protocol = proxy[:secure] ? 'https' : 'http'
+
+          SC.logger << "~ PROXY: #{http_method.upcase} #{status} #{url} -> #{protocol}://#{http_host}:#{http_port}#{http_path}\n"
+
+          # display and construct specific response headers
+          response_headers = {}
+          ignore_headers = ['transfer-encoding', 'keep-alive', 'connection']
+          response.each do |key, value|
+            next if ignore_headers.include?(key.downcase)
+            # If this is a cookie, strip out the domain.  This technically may
+            # break certain scenarios where services try to set cross-domain
+            # cookies, but those services should not be doing that anyway...
+            value.gsub!(/domain=[^\;]+\;? ?/,'') if key.downcase == 'set-cookie'
+            # Location headers should rewrite the hostname if it is included.
+            value.gsub!(/^http:\/\/#{http_host}(:[0-9]+)?\//, "http://#{http_host}/") if key.downcase == 'location'
+            # content-length is returning char count not bytesize
+            if key.downcase == 'content-length'
+              if response.body.respond_to?(:bytesize)
+                value = response.body.bytesize.to_s
+              elsif response.body.respond_to?(:size)
+                value = response.body.size.to_s
+              else
+                value = '0'
+              end
+            end
+
+            SC.logger << "   #{key}: #{value}\n"
+            response_headers[key] = value
+          end
+
+          if [301, 302, 303, 307].include?(status.to_i) && proxy[:redirect] != false
+            SC.logger << '~ REDIRECTING: '+response_headers['location']+"\n"
+
+            uri = URI.parse(response_headers['location']);
+            http_host = uri.host
+            http_port = uri.port
+            http_path = uri.path
+            http_path += '?'+uri.query if uri.query
+
+            tries += 1
+            if tries > 10
+              raise "Too many redirects!"
+            end
+          else
+            done = true
+          end
+        end
+
+        # Thin doesn't like null bodies
+        response_body = response.body || ''
+
+        return [status, ::Rack::Utils::HeaderHash.new(response_headers), [response_body]]
+      end
+    end
+  end
+end

data/lib/sproutcore/rack/service.rb

@@ -0,0 +1,153 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+  module Rack
+
+    # Configures a standard set of Rack adaptors for serving SproutCore apps.
+    # Based on your config settings, this will configure appropriate
+    # middlewear apps for each incoming project.  Requests are then cascaded
+    # through the projects to find one that can service the request.
+    #
+    class Service
+
+      cattr_accessor :filesystem
+
+      # Convenience method to start the rack service as a server.  You must
+      # pass at least a :project => foo, or :projects => [foo, bar] option
+      # to this method, but you may also pass a number of other config optios
+      # including:
+      #
+      # === Options
+      #  :host:: the hostname to listen on (default 0.0.0.0)
+      #  :port:: the portname to listen on (default 4020)
+      #  :daemonize:: if true, service will be run as daemon
+      #  :pid:: if daemonizing, this is the path of the file to write pid to
+      #
+      def self.start(opts = {})
+
+        # load rack
+        begin
+          require 'rack'
+        rescue LoadError => e
+          gem 'rack'
+          require 'rack'
+        end
+
+        # Guess.
+        if ENV.include?("PHP_FCGI_CHILDREN")
+          server = ::Rack::Handler::FastCGI
+
+          # We already speak FastCGI
+          options.delete :File
+          options.delete :Port
+        elsif ENV.include?("REQUEST_METHOD")
+          server = ::Rack::Handler::CGI
+        else
+          begin
+            server = ::Rack::Handler::Thin
+          rescue LoadError => e
+            server = ::Rack::Handler::Mongrel
+          end
+        end
+        
+        opts[:Filesystem] ||= opts[:filesystem] || true # enabled by default
+        self.filesystem = opts[:Filesystem]
+
+        projects = opts.delete(:projects) || [opts.delete(:project)].compact
+        app = self.new(*projects)
+
+        opts[:Host] ||= opts[:host] # allow either case.
+        opts[:Port] ||= opts[:port] || '4020'
+
+        # If daemonize is set, do it...
+        if opts[:daemonize]
+          SC.logger.info "Daemonizing..."
+          pid = opts[:pid]
+
+          if RUBY_VERSION < "1.9"
+            return if fork
+            Process.setsid
+            return if fork
+            Dir.chdir "/"
+            File.umask 0000
+            STDIN.reopen "/dev/null"
+            STDOUT.reopen "/dev/null", "a"
+            STDERR.reopen "/dev/null", "a"
+          else
+            Process.daemon
+          end
+
+          if pid
+            File.open(pid, 'w'){ |f| f.write("#{Process.pid}") }
+            at_exit { File.delete(pid) if File.exist?(pid) }
+          end
+        end
+
+        SC.logger << "Starting server at http://#{opts[:Host] || '0.0.0.0'}:#{opts[:Port]} in #{SC.build_mode} mode\n"
+        SC.logger << "To quit sc-server, press Control-C\n"
+        server.run app, opts
+      end
+
+      def initialize(*projects)
+        @projects = projects.flatten
+
+        # Get apps for each project & cascade if needed
+        @apps = @projects.map { |project| middleware_for(project) }
+        @app = @apps.size == 1 ? @apps.first : ::Rack::Cascade.new(@apps)
+
+        # Now put it behind some useful general optimizers...
+        @app = ::Rack::Recursive.new(@app)
+        @app = ::Rack::ConditionalGet.new(@app)
+        #@app = ::Rack::Deflater.new(@app)
+
+      end
+
+      def call(env); @app.call(env); end
+
+      # Construct new middleware for the named project
+      def middleware_for(project)
+        apps = []
+
+        # setup some conditional items...
+        config = project.config
+
+        # serve files out of the public directory if serve_public is
+        # configures && the public directory exists
+        if config[:serve_public]
+          pubdir = File.join(project.project_root, 'public')
+          apps  << ::Rack::File.new(pubdir) if File.directory?(pubdir)
+        end
+
+        if self.filesystem
+          apps << SC::Rack::Filesystem.new(project)
+        end
+
+        #if config.serve_test_runner || config.serve_docs
+          apps << SC::Rack::Dev.new(project)
+        #end
+
+        # Add builder for the project itself
+        apps  << SC::Rack::Builder.new(project)
+
+        if project.buildfile.proxies.size > 0
+          apps << SC::Rack::Proxy.new(project)
+        end
+
+        # Wrap'em in a cascade if needed.  This will return the first
+        # app that does not return nil
+        app = apps.size == 1 ? apps.first : ::Rack::Cascade.new(apps)
+
+        # Add show exceptions handler if enabled
+        app = ::Rack::ShowExceptions.new(app) if config[:serve_exceptions]
+
+        return app # done!
+      end
+
+    end
+  end
+end

data/lib/sproutcore/rack/test_runner.rb

@@ -0,0 +1,24 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe Inc.
+#            and contributors
+# ===========================================================================
+
+module SC
+  module Rack
+
+    # Rewrites relevant requests to load the SproutCore test runner for a
+    # given project.
+    class TestRunner
+
+      def initialize(project)
+        @project = project
+      end
+
+      def call(env)
+        return [404, {}, "not found"]
+      end
+    end
+  end
+end

data/lib/sproutcore/rack.rb

@@ -0,0 +1,7 @@
+require "sproutcore/rack/builder"
+require "sproutcore/rack/dev"
+require "sproutcore/rack/docs"
+require "sproutcore/rack/filesystem"
+require "sproutcore/rack/proxy"
+require "sproutcore/rack/service"
+require "sproutcore/rack/test_runner"