sproutcore 1.6.0.1-java → 1.7.1.beta-java

data/lib/sproutcore/helpers/entry_sorter.rb

@@ -72,6 +72,8 @@ module SC
             [1, name]
           when /lproj\/strings.js$/
             [-2, name]
+          when /lproj\/layout.js$/
+            [-2, name]
           else
             [-1, name]
           end

data/lib/sproutcore/helpers/minifier.rb

@@ -80,26 +80,50 @@ module SC::Helpers
     end
 
     def minify(paths)
-      paths = paths.first if paths.is_a?(Array) && paths.length == 1
-
-      if paths.is_a?(Array)
-        paths = paths.map{|p| '"'+p+'"'}.join(' ')
-        outfile = '".js$:.js"'
-      else
-        paths = outfile = '"'+paths+'"'
+      if not paths.kind_of?(Array)
+        paths = [paths]
+      end
+      
+      # Split paths into HTML and JS
+      html_paths = paths.select {|p| p =~ /\.html$/}
+      js_paths = paths.select {|p| p =~ /\.js$/}
+      
+      if html_paths.length > 0
+        command = %{java -jar "#{SC.html_jar}" "#{html_paths.join '" "'}" 2>&1}
+        puts "Executing #{command}"
+        output = `#{command}`
+        
+        SC.logger.info output
+        if $?.exitstatus != 0
+          SC.logger.fatal(output)
+          SC.logger.fatal("!!!! Minifying failed. Please check that your JS code is valid.")
+          SC.logger.fatal("!!!! Failed compiling #{paths}")
+
+          exit(1)
+        end
+      end
+      
+      if js_paths.length > 0
+        js_paths.each {|p|
+          command = %{java -jar "#{SC.js_jar}" -o "#{p}" "#{p}" 2>&1}
+          puts "Executing #{command}"
+          output = `#{command}`
+
+          SC.logger.info output
+          if $?.exitstatus != 0
+            SC.logger.fatal(output)
+            SC.logger.fatal("!!!! Minifying failed. Please check that your JS code is valid.")
+            SC.logger.fatal("!!!! Failed compiling #{paths}")
+
+            exit(1)
+          end
+        }
       end
 
-      command = %{java -Xmx256m -jar "#{SC.yui_jar}" -o #{outfile} #{paths} 2>&1}
-      output = `#{command}`
+      # SCyui doesn't need a -o. It writes to the original path.
+
 
-      SC.logger.info output
-      if $?.exitstatus != 0
-        SC.logger.fatal(output)
-        SC.logger.fatal("!!!! Minifying failed. Please check that your JS code is valid.")
-        SC.logger.fatal("!!!! Failed compiling #{paths}")
 
-        exit(1)
-      end
     end
 
   end

data/lib/sproutcore/helpers/static_helper.rb

@@ -75,22 +75,15 @@ module SC
         combine_stylesheets = t.config[:combine_stylesheets]
 
         combined_entries(t, opts, 'stylesheet.css', 'stylesheet-packed.css') do |cur_target, cur_entry|
-
           # We have to figure out if we should use the 2x version.
           # For this, we have to figure out the original name again...
           if opts[:x2]
-            name = cur_entry.extensionless_filename
+            name = cur_entry.filename
 
-            if name == "stylesheet"
-              name = "stylesheet@2x.css"
-            elsif name == "stylesheet-packed"
-              name = "stylesheet@2x-packed.css"
-            else
-              raise "Unexpected entry name when collecting CSS: " + name
-            end
+            name = name.gsub /stylesheet/, "stylesheet@2x"
 
             v = opts[:language] ? { :language => opts[:language] } : manifest.variation
-            x2_entry = t.manifest_for(v).entry_for name
+            x2_entry = cur_target.manifest_for(v).entry_for name
 
             cur_entry = x2_entry if x2_entry
           end
@@ -190,11 +183,7 @@ module SC
             ret << inline_javascript(resource_name)
           end
         end
-
-        url_prefix = $script_name ? %("#{$script_name}") : "null";
-
-        ret << %(<script type="text/javascript">SC.buildMode = "#{SC.build_mode}"; \n SC.urlPrefix = #{url_prefix}; </script>)
-
+        
         return ret * "\n"
       end
 
@@ -413,6 +402,13 @@ module SC
 
           # get the stylesheet or js entry for it...
           entry = cur_manifest.entry_for packed_entry_name
+          
+          if entry.nil?
+            # If it didn't find it, it may have been hidden by the IE hack for splitting CSS.
+            # In this case, we have to find it, but searching for any hidden file won't work
+            # because there could be more than one. So, we search based on 
+            entry = cur_manifest.entry_for packed_entry_name, { :hidden => true, :is_split => true  }
+          end
 
           # It used to be like this:
           # next if entry.nil? || !entry.composite? # no stylesheet or js
@@ -420,8 +416,30 @@ module SC
           # a reason to check for composite entries, either. So, the composite
           # check has been removed.
           next if entry.nil? # no stylesheet or js
-
-          yield(t, entry)
+          
+          # HACK FOR IE. Yes, IE hacks are now in Ruby as well! Isn't that grand!
+          # Basically, IE does not allow more than 4096 selectors. The problem: it has
+          # a max of 4096 selectors per file!!!
+          #
+          # and the problem is, we don't know the number of selectors until AFTER CSS
+          # is built. So, we have to, at the last minute, find these other files.
+          # They are given entries, but these entries are supplied AFTER the manifest
+          # is technically finished. So, it is only now that we can go find them.
+          #
+          # In fact: it may not even be around yet. It won't until this CSS entry is built.
+          # We didn't always have to build the CSS entries before serving HTML but... now we do.
+          # Because IE sucks.
+          entry.build!
+          
+          # The builder adds a :split_entries. :split_entries were added, we need to split
+          # CSS files.
+          if entry[:split_entries]
+            entry[:split_entries].each {|e|
+              yield(t, e)
+            }
+          else
+            yield(t, entry)
+          end
         end
 
         unpacked.each do |t|

data/lib/sproutcore/models/manifest.rb

@@ -93,6 +93,31 @@ module SC
     end
 
     def built?; @is_built; end
+    
+    #
+    # Resets this manifest, and all same-variation manifests the target depends on.
+    # This is useful when building: it clears the entries and frees up memory so
+    # building doesn't take multiple gigabytes.
+    #
+    def reset!
+      return if @is_resetting
+      @is_resetting = true
+      
+      targets = target.expand_required_targets({ :theme => true }) + [target]
+      entries = targets.map do |t|
+        t.manifest_for(variation).reset!
+      end
+      
+      targets = target.modules({ :debug => false, :test => false, :theme => true }).each do |t|
+        t.manifest_for(variation).reset!
+      end
+      
+      reset_entries!
+      
+      @is_resetting = false
+      
+      return self
+    end
 
     # Resets the manifest entries.  this is called before a build is
     # performed. This will reset only the entries, none of the other props.
@@ -102,6 +127,7 @@ module SC
     #
     def reset_entries!
       @is_built = false
+      self.delete(:entries)
       @entries = EntryList.new
       return self
     end

data/lib/sproutcore/models/target.rb

@@ -157,6 +157,11 @@ module SC
       # make sure we update for changes in theme and required (commonly changed):
       key << config[:theme].to_s if config[:theme] and opts[:theme]
       key << config[:required].to_s if config[:required]
+      if opts[:modules]
+        key << config[:inlined_modules] if config[:inlined_modules]
+        key << config[:prefetched_modules] if config[:prefetched_modules]
+        key << config[:deferred_modules] if config[:deferred_modules]
+      end
 
       key = key.compact.join('.')
 
@@ -166,7 +171,7 @@ module SC
       return ret unless ret.nil?
 
       # else compute return value, respecting options
-      ret = [config[:required], config[:inlined_modules]]
+      ret = [config[:required]]
       if opts[:debug] && config[:debug_required]
         ret << config[:debug_required]
       end
@@ -190,6 +195,12 @@ module SC
         end
       end
 
+      if opts[:modules]
+        ret << config[:inlined_modules]
+        ret << config[:prefetched_modules]
+        ret << config[:deferred_modules]
+      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 #{self[:target_name]}"

data/lib/sproutcore/rack.rb

@@ -2,5 +2,6 @@ require "sproutcore/rack/builder"
 require "sproutcore/rack/dev"
 require "sproutcore/rack/filesystem"
 require "sproutcore/rack/proxy"
+require 'sproutcore/rack/restrict_ip'
 require "sproutcore/rack/service"
 require "sproutcore/rack/test_runner"

data/lib/sproutcore/rack/proxy.rb

@@ -14,299 +14,318 @@ rescue LoadError => e
   SC::HTTPS_ENABLED = false
 end
 
-require 'eventmachine'
-require 'em-http'
-require 'thin'
-
+begin
+  require 'eventmachine'
+  require 'em-http'
+  require 'thin'
+  
+  SC::PROXY_ENABLED = true
+rescue LoadError => e
+  SC::PROXY_ENABLED = false
+end
 
-module SC
+if SC::PROXY_ENABLED
+  # There are cases where we cannot load the proxy and don't need to (build environment)
+  
+  module SC
 
-  module Rack
+    module Rack
 
-    class DeferrableBody
-      include EM::Deferrable
+      class DeferrableBody
+        include EM::Deferrable
 
-      def initialize(options = {})
-        @options = options
-      end
+        def initialize(options = {})
+          @options = options
+        end
 
-      def call(body)
-        body.each do |chunk|
-          @body_callback.call(prepare_chunk(chunk))
+        def call(body)
+          body.each do |chunk|
+            @body_callback.call(prepare_chunk(chunk))
+          end
         end
-      end
 
-      def prepare_chunk(chunk)
-        if chunked?
-          size = chunk.respond_to?(:bytesize) ? chunk.bytesize : chunk.length
-          "#{size.to_s(16)}\r\n#{chunk}\r\n"
-        else
-          # Thin doesn't like null bodies
-          chunk || ''
+        def prepare_chunk(chunk)
+          if chunked?
+            size = chunk.respond_to?(:bytesize) ? chunk.bytesize : chunk.length
+            "#{size.to_s(16)}\r\n#{chunk}\r\n"
+          else
+            # Thin doesn't like null bodies
+            chunk || ''
+          end
         end
-      end
 
-      def each(&blk)
-        @body_callback = blk
-      end
+        def each(&blk)
+          @body_callback = blk
+        end
 
-    private
+      private
 
-      def chunked?
-        @options[:chunked]
+        def chunked?
+          @options[:chunked]
+        end
       end
-    end
 
 
 
-    # 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)
-        path = env['PATH_INFO']
-
-        @proxies.each do |proxy, value|
-          # If the url matches a proxied url, handle it
-          if path.match(/^#{Regexp.escape(proxy.to_s)}/)
-            handle_proxy(value, proxy.to_s, env)
+      # Rack application proxies requests as needed for the given project.
+      class Proxy
 
-            # Don't block waiting for a response
-            throw :async
-          end
+        def initialize(project)
+          @project = project
+          @proxies = project.buildfile.proxies
         end
 
-        return [404, {}, "not found"]
-      end
+        def call(env)
+          path = env['PATH_INFO']
 
-      def chunked?(headers)
-        headers['Transfer-Encoding'] == "chunked"
-      end
+          @proxies.each do |proxy, value|
+            # If the url matches a proxied url, handle it
+            if path.match(/^#{Regexp.escape(proxy.to_s)}/)
+              handle_proxy(value, proxy.to_s, env)
 
-      def handle_proxy(proxy, proxy_url, env)
+              # Don't block waiting for a response
+              throw :async
+            end
+          end
 
-        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
+          return [404, {}, "not found"]
         end
 
-        headers = request_headers(env, proxy)         # ex. {"Host"=>"localhost:4020", "Connection"=>"...
-        path = env['PATH_INFO']                       # ex. /contacts
-        params = env['QUERY_STRING']                  # ex. since=yesterday&unread=true
+        def chunked?(headers)
+          headers['Transfer-Encoding'] == "chunked"
+        end
 
-        # Switch to https if proxy[:secure] configured
-        protocol = proxy[:secure] ? 'https' : 'http'
+        def handle_proxy(proxy, proxy_url, env)
 
-        # Adjust the path if proxy[:url] configured
-        if proxy[:url]
-          path = path.sub(/^#{Regexp.escape proxy_url}/, proxy[:url])
-        end
+          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
 
-        # The endpoint URL
-        url = protocol + '://' + proxy[:to]
-        url += path unless path.empty?
-        url += '?' + params unless params.empty?
+          headers = request_headers(env, proxy)         # ex. {"Host"=>"localhost:4020", "Connection"=>"...
+          path = env['PATH_INFO']                       # ex. /contacts
+          params = env['QUERY_STRING']                  # ex. since=yesterday&unread=true
 
-        if env['CONTENT_LENGTH'] || env['HTTP_TRANSFER_ENCODING']
-          req_body = env['rack.input']
-          req_body.rewind # May not be necessary but can't hurt
+          # Switch to https if proxy[:secure] configured
+          protocol = proxy[:secure] ? 'https' : 'http'
 
-          req_body = req_body.read
-        end
+          # Adjust the path if proxy[:url] configured
+          if proxy[:url]
+            path = path.sub(/^#{Regexp.escape proxy_url}/, proxy[:url])
+          end
 
-        # Options for the request
-        request_options = {}
-        request_options[:head] = headers
-        request_options[:body] = req_body if !!req_body
-        request_options[:timeout] = proxy[:timeout] if proxy[:timeout]
-        request_options[:redirects] = 10 if proxy[:redirect] != false
-
-        EventMachine.run {
-          body = nil
-          conn = EM::HttpRequest.new(url)
-          chunked = false
-          headers = {}
-          method = env['REQUEST_METHOD'].upcase
-          status = 0
-
-          case method
-            when 'GET'
-              http = conn.get request_options
-            when 'POST'
-              http = conn.post request_options
-            when 'PUT'
-              http = conn.put request_options
-            when 'DELETE'
-              http = conn.delete request_options
-            else
-              http = conn.head request_options
-            end
+          # The endpoint URL
+          url = protocol + '://' + proxy[:to]
+          url += path unless path.empty?
+          url += '?' + params unless params.empty?
 
-          # Received error
-          http.errback {
-            status = http.response_header.status
-            path = env['PATH_INFO']
-            url = http.last_effective_url
-            SC.logger << "~ PROXY FAILED:  #{method} #{path} -> #{status} #{url}\n"
-
-            # If a body has been sent use it, otherwise respond with generic message
-            if !body
-              body = "Unable to proxy to #{url}.  Received status: #{status}"
-              size = body.respond_to?(:bytesize) ? body.bytesize : body.length
-              headers = { 'Content-Length' => size.to_s }
-              body = [body]
-            end
+          if env['CONTENT_LENGTH'] || env['HTTP_TRANSFER_ENCODING']
+            req_body = env['rack.input']
+            req_body.rewind # May not be necessary but can't hurt
 
-            env['async.callback'].call [502, headers, body]
-          }
+            req_body = req_body.read
+          end
 
-          # Received response
-          http.callback {
-
-            # Too many redirects
-            if redirect? status
-              body = "Unable to proxy to #{url}.  Too many redirects."
-              size = body.respond_to?(:bytesize) ? body.bytesize : body.length
-              headers = { 'Content-Length' => size.to_s }
-
-              env['async.callback'].call [502, headers, [body]]
-            else
-              # Terminate the deferred body (which may have been chunked)
-              if body
-                body.call ['']
-                body.succeed
+          # Options for the request
+          request_options = {}
+          request_options[:head] = headers
+          request_options[:body] = req_body if !!req_body
+          request_options[:timeout] = proxy[:timeout] if proxy[:timeout]
+          request_options[:redirects] = 10 if proxy[:redirect] != false
+          request_options[:decoding] = false  # don't decode gzipped content
+
+          EventMachine.run {
+            body = nil
+            conn = EM::HttpRequest.new(url)
+            chunked = false
+            headers = {}
+            method = env['REQUEST_METHOD'].upcase
+            status = 0
+
+            case method
+              when 'GET'
+                http = conn.get request_options
+              when 'POST'
+                http = conn.post request_options
+              when 'PUT'
+                http = conn.put request_options
+              when 'DELETE'
+                http = conn.delete request_options
+              else
+                http = conn.head request_options
               end
 
-              # Log the initial path and the final url
+            # Received error
+            http.errback {
+              status = http.response_header.status
               path = env['PATH_INFO']
               url = http.last_effective_url
-              SC.logger << "~ PROXY: #{method} #{path} -> #{status} #{url}\n"
-           end
-          }
+              SC.logger << "~ PROXY FAILED:  #{method} #{path} -> #{status} #{url}\n"
 
-          # Received headers
-          http.headers { |hash|
-            status = http.response_header.status
+              # If a body has been sent use it, otherwise respond with generic message
+              if !body
+                body = "Unable to proxy to #{url}.  Received status: #{status}"
+                size = body.respond_to?(:bytesize) ? body.bytesize : body.length
+                headers = { 'Content-Length' => size.to_s }
+                body = [body]
+              end
 
-            headers = response_headers(hash)
+              env['async.callback'].call [502, headers, body]
+            }
 
-            # Don't respond on redirection, but fail out on bad redirects
-            if redirect? status
+            # Received response
+            http.callback {
 
-              if status == 304
-                env["async.callback"].call [status, headers, ['']]
-                SC.logger << "~ PROXY: #{method} #{path} -> #{status} #{url}\n"
-              elsif !headers['Location']
-                body = "Unable to proxy to #{url}. Received redirect with no Location."
+              # Too many redirects
+              if redirect? status
+                body = "Unable to proxy to #{url}.  Too many redirects."
                 size = body.respond_to?(:bytesize) ? body.bytesize : body.length
                 headers = { 'Content-Length' => size.to_s }
 
-                http.close
+                env['async.callback'].call [502, headers, [body]]
+              else
+                # Terminate the deferred body (which may have been chunked)
+                if body
+                  body.call ['']
+                  body.succeed
+                end
+
+                # Log the initial path and the final url
+                path = env['PATH_INFO']
+                url = http.last_effective_url
+                SC.logger << "~ PROXY: #{method} #{path} -> #{status} #{url}\n"
+             end
+            }
+
+            # Received headers
+            http.headers { |hash|
+              status = http.response_header.status
+
+              headers = response_headers(hash)
+
+              # Don't respond on redirection, but fail out on bad redirects
+              if redirect? status
+
+                if status == 304
+                  env["async.callback"].call [status, headers, ['']]
+                  SC.logger << "~ PROXY: #{method} #{path} -> #{status} #{url}\n"
+                elsif !headers['Location']
+                  body = "Unable to proxy to #{url}. Received redirect with no Location."
+                  size = body.respond_to?(:bytesize) ? body.bytesize : body.length
+                  headers = { 'Content-Length' => size.to_s }
+
+                  http.close
+                end
+
+              else
+                # Stream the body right across in the format it was sent
+                chunked = chunked?(headers)
+                body = DeferrableBody.new({ :chunked => chunked })
+
+                # Start responding to the client immediately
+                env["async.callback"].call [status, headers, body]
               end
+            }
 
-            else
-              # Stream the body right across in the format it was sent
-              chunked = chunked?(headers)
-              body = DeferrableBody.new({ :chunked => chunked })
+            # Received chunk of data
+            http.stream { |chunk|
+              # Ignore body of redirects
+              if !redirect? status
+                body.call [chunk]
+              end
+            }
 
-              # Start responding to the client immediately
-              env["async.callback"].call [status, headers, body]
-            end
-          }
+            # If the client disconnects early, make sure we close our other connection too
+            # TODO: this is waiting for changes not yet available in em-http
+            # Test with: curl http://0.0.0.0:4020/stream.twitter.com/1/statuses/sample.json -uTWITTER_USERNAME:TWITTER_PASSWORD
+            # env["async.close"].callback {
+            #   conn.close
+            # }
 
-          # Received chunk of data
-          http.stream { |chunk|
-            # Ignore body of redirects
-            if !redirect? status
-              body.call [chunk]
-            end
           }
-        }
-      end
+        end
 
-      def redirect?(status)
-        status >= 300 && status < 400
-      end
+        def redirect?(status)
+          status >= 300 && status < 400
+        end
 
-      # collect headers...
-      def request_headers(env, proxy)
-        result = {}
-        env.each do |key, value|
-          next unless key =~ /^HTTP_/
+        # collect headers...
+        def request_headers(env, proxy)
+          result = {}
+          env.each do |key, value|
+            next unless key =~ /^HTTP_/
 
-          key = headerize(key)
-          if !key.eql? "Version"
-            result[key] = value
+            key = headerize(key)
+            if !key.eql? "Version"
+              result[key] = value
+            end
           end
-        end
 
-        # Rack documentation says CONTENT_TYPE and CONTENT_LENGTH aren't prefixed by HTTP_
-        result['Content-Type'] = env['CONTENT_TYPE'] if env['CONTENT_TYPE']
+          # Rack documentation says CONTENT_TYPE and CONTENT_LENGTH aren't prefixed by HTTP_
+          result['Content-Type'] = env['CONTENT_TYPE'] if env['CONTENT_TYPE']
 
-        length = env['CONTENT_LENGTH']
-        result['Content-Length'] = length if length
+          length = env['CONTENT_LENGTH']
+          result['Content-Length'] = length if length
 
-        # added 4/23/09 per Charles Jolley, corrects problem
-        # when making requests to virtual hosts
-        result['Host'] = proxy[:to]
+          # added 4/23/09 per Charles Jolley, corrects problem
+          # when making requests to virtual hosts
+          result['Host'] = proxy[:to]
 
-        result
-      end
+          result
+        end
 
-      # construct and display specific response headers
-      def response_headers(hash)
-        result = {}
+        # construct and display specific response headers
+        def response_headers(hash)
+          result = {}
 
-        hash.each do |key, value|
-          key = headerize(key)
+          hash.each do |key, value|
+            key = headerize(key)
 
-          # Because Set-Cookie header can appear more the once in the response body,
-          # but Rack only accepts a hash of headers, we store it in a line break separated string
-          # for Ruby 1.9 and as an Array for Ruby 1.8
-          # See http://groups.google.com/group/rack-devel/browse_thread/thread/e8759b91a82c5a10/a8dbd4574fe97d69?#a8dbd4574fe97d69
-          if key.downcase == 'set-cookie'
-            cookies = []
+            # Because Set-Cookie header can appear more the once in the response body,
+            # but Rack only accepts a hash of headers, we store it in a line break separated string
+            # for Ruby 1.9 and as an Array for Ruby 1.8
+            # See http://groups.google.com/group/rack-devel/browse_thread/thread/e8759b91a82c5a10/a8dbd4574fe97d69?#a8dbd4574fe97d69
+            if key.downcase == 'set-cookie'
+              cookies = []
 
-            case value
-              when Array then value.each { |c| cookies << strip_domain(c) }
-              when Hash  then value.each { |_, c| cookies << strip_domain(c) }
-              else            cookies << strip_domain(value)
-            end
+              case value
+                when Array then value.each { |c| cookies << strip_domain(c) }
+                when Hash  then value.each { |_, c| cookies << strip_domain(c) }
+                else            cookies << strip_domain(value)
+              end
 
-            # Remove nil values
-            result['Set-Cookie'] = [result['Set-Cookie'], cookies].compact
+              # Remove nil values
+              result['Set-Cookie'] = [result['Set-Cookie'], cookies].compact
 
-            if Thin.ruby_18?
-              result['Set-Cookie'].flatten!
-            else
-              result['Set-Cookie'] = result['Set-Cookie'].join("\n")
+              if Thin.ruby_18?
+                result['Set-Cookie'].flatten!
+              else
+                result['Set-Cookie'] = result['Set-Cookie'].join("\n")
+              end
             end
+
+            SC.logger << "   #{key}: #{value}\n"
+            result[key] = value
           end
 
-          SC.logger << "   #{key}: #{value}\n"
-          result[key] = value
+          ::Rack::Utils::HeaderHash.new(result)
         end
 
-        ::Rack::Utils::HeaderHash.new(result)
-      end
-
-      # remove HTTP_, dasherize and titleize
-      def headerize(str)
-        parts = str.gsub(/^HTTP_/, '').split('_')
-        parts.map! { |p| p.capitalize }.join('-')
-      end
+        # remove HTTP_, dasherize and titleize
+        def headerize(str)
+          parts = str.gsub(/^HTTP_/, '').split('_')
+          parts.map! { |p| p.capitalize }.join('-')
+        end
 
-      # Strip out the domain of passed in cookie.  This technically may
-      # break certain scenarios where services try to set cross-domain
-      # cookies, but those services should not be doing that anyway...
-      def strip_domain(cookie)
-        cookie.to_s.gsub!(/domain=[^\;]+\;? ?/,'')
+        # Strip out the domain of passed in cookie.  This technically may
+        # break certain scenarios where services try to set cross-domain
+        # cookies, but those services should not be doing that anyway...
+        def strip_domain(cookie)
+          cookie.to_s.gsub!(/domain=[^\;]+\;? ?/,'')
+        end
       end
     end
   end
-end
+
+end