tilia-http 4.1.0

data/lib/tilia/http/response_decorator.rb

@@ -0,0 +1,58 @@
+module Tilia
+  module Http
+    # Response Decorator
+    #
+    # This helper class allows you to easily create decorators for the Response
+    # object.
+    class ResponseDecorator
+      include Tilia::Http::ResponseInterface
+      include Tilia::Http::MessageDecoratorTrait
+
+      # Constructor.
+      #
+      # @param ResponseInterface inner
+      def initialize(inner)
+        @inner = inner
+      end
+
+      # Returns the current HTTP status code.
+      #
+      # @return int
+      def status
+        @inner.status
+      end
+
+      # Returns the human-readable status string.
+      #
+      # In the case of a 200, this may for example be 'OK'.
+      #
+      # @return [String]
+      def status_text
+        @inner.status_text
+      end
+
+      # Sets the HTTP status code.
+      #
+      # This can be either the full HTTP status code with human readable string,
+      # for example: "403 I can't let you do that, Dave".
+      #
+      # Or just the code, in which case the appropriate default message will be
+      # added.
+      #
+      # @param [String, Fixnum] status
+      # @return [void]
+      def status=(status)
+        @inner.status = status
+      end
+
+      # Serializes the request object as a string.
+      #
+      # This is useful for debugging purposes.
+      #
+      # @return [String]
+      def to_s
+        @inner.to_s
+      end
+    end
+  end
+end

data/lib/tilia/http/response_interface.rb

@@ -0,0 +1,36 @@
+module Tilia
+  module Http
+    # This interface represents a HTTP response.
+    module ResponseInterface
+      include Tilia::Http::MessageInterface
+
+      # Returns the current HTTP status code.
+      #
+      # @return int
+      def status
+      end
+
+      # Returns the human-readable status string.
+      #
+      # In the case of a 200, this may for example be 'OK'.
+      #
+      # @return [String]
+      def status_text
+      end
+
+      # Sets the HTTP status code.
+      #
+      # This can be either the full HTTP status code with human readable string,
+      # for example: "403 I can't let you do that, Dave".
+      #
+      # Or just the code, in which case the appropriate default message will be
+      # added.
+      #
+      # @param [String, Fixnum] status
+      # @throws \InvalidArgumentExeption
+      # @return [void]
+      def status=(_status)
+      end
+    end
+  end
+end

data/lib/tilia/http/sapi.rb

@@ -0,0 +1,165 @@
+require 'stringio'
+require 'base64'
+module Tilia
+  module Http
+    # PHP SAPI
+    #
+    # This object is responsible for:
+    # 1. Constructing a Request object based on the current HTTP request sent to
+    #    the PHP process.
+    # 2. Sending the Response object back to the client.
+    #
+    # It could be said that this class provides a mapping between the Request and
+    # Response objects, and php's:
+    #
+    # * $_SERVER
+    # * $_POST
+    # * $_FILES
+    # * php://input
+    # * echo
+    # * header
+    # * php://output
+    #
+    # You can choose to either call all these methods statically, but you can also
+    # instantiate this as an object to allow for polymorhpism.
+    class Sapi
+      # This static method will create a new Request object, based on the
+      # current PHP request.
+      #
+      # @return Request
+      def self.request
+        fail NotImplementedError, 'This object method now is an instance method'
+      end
+
+      # Sends the HTTP response back to a HTTP client.
+      #
+      # This calls php's header function and streams the body to php://output.
+      #
+      # @param ResponseInterface response
+      # @return [void]
+      def self.send_response(response)
+        # RUBY: Rack does not support HTTP Version (?)
+        # header("HTTP/#{response.http_version} #{response.status} #{response.status_text}")
+
+        status = response.status
+        headers = {}
+        response.headers.each do |key, value|
+          headers[key] = value.join("\n")
+        end
+
+        body = response.body_as_stream
+        content_length = response.header('Content-Length')
+        if content_length
+          output = StringIO.new
+          output.write body.read(content_length.to_i)
+          output.rewind
+          body = output
+        end
+
+        [status, headers, body]
+      end
+
+      # This static method will create a new Request object, based on a PHP
+      # $_SERVER array.
+      #
+      # @param array server_array
+      # @return Request
+      def self.create_from_server_array(server_array)
+        headers = {}
+        method = nil
+        url = nil
+        http_version = '1.1'
+
+        protocol = 'http'
+        host_name = 'localhost'
+
+        server_array.each do |key, value|
+          case key
+          when 'SERVER_PROTOCOL'
+            http_version = '1.0' if value == 'HTTP/1.0'
+          when 'REQUEST_METHOD'
+            method = value
+          when 'REQUEST_URI'
+            url = value
+
+          # These sometimes should up without a HTTP_ prefix
+          when 'CONTENT_TYPE'
+            headers['Content-Type'] = value
+          when 'CONTENT_LENGTH'
+            headers['Content-Length'] = value
+
+          # mod_php on apache will put credentials in these variables.
+          # (fast)cgi does not usually do this, however.
+          when 'PHP_AUTH_USER'
+            if server_array.key? 'PHP_AUTH_PW'
+              headers['Authorization'] = "Basic #{Base64.strict_encode64 "#{value}:#{server_array['PHP_AUTH_PW']}"}"
+            end
+          when 'PHP_AUTH_DIGEST'
+            headers['Authorization'] = "Digest #{value}"
+
+          # Apache may prefix the HTTP_AUTHORIZATION header with
+          # REDIRECT_, if mod_rewrite was used.
+          when 'REDIRECT_HTTP_AUTHORIZATION'
+            headers['Authorization'] = value
+
+          when 'HTTP_HOST'
+            host_name = value
+            headers['Host'] = value
+
+          when 'HTTPS'
+            protocol = 'https' if value && value != 'off'
+
+          # RUBY
+          when 'rack.url_scheme'
+            protocol = value
+
+          else
+            if key.index('HTTP_') == 0
+              # It's a HTTP header
+
+              # Normalizing it to be prettier
+              header = key[5..-1].downcase
+
+              # Transforming dashes into spaces, and uppercasing
+              # every first letter.
+              # Turning spaces into dashes.
+              header = header.split(/_/).map(&:capitalize).join('-')
+
+              headers[header] = value
+            end
+          end
+        end
+
+        r = Tilia::Http::Request.new(method, url, headers)
+        r.http_version = http_version
+        r.raw_server_data = server_array
+        r.absolute_url = "#{protocol}://#{host_name}#{url}"
+        r
+      end
+
+      # TODO: document
+      def initialize(env)
+        @env = env
+        @rack_request = Rack::Request.new(env)
+      end
+
+      # TODO: document
+      def request
+        r = create_from_server_array(@env)
+        r.body = StringIO.new
+        r.post_data = @rack_request.POST
+        r
+      end
+
+      # TODO: document
+      def send_response(response)
+        self.class.send_response(response)
+      end
+
+      # TODO: document
+      def create_from_server_array(server_array)
+        self.class.create_from_server_array(server_array)
+      end
+    end
+  end
+end

data/lib/tilia/http/url_util.rb

@@ -0,0 +1,70 @@
+module Tilia
+  module Http
+    # URL utility class
+    #
+    # Note: this class is deprecated. All its functionality moved to functions.php
+    # or sabre\uri.
+    #
+    # @deprectated
+    module UrlUtil
+      # Encodes the path of a url.
+      #
+      # slashes (/) are treated as path-separators.
+      #
+      # @deprecated use \Sabre\HTTP\encode_path
+      # @param [String] path
+      # @return [String]
+      def self.encode_path(path)
+        Tilia::Http.encode_path(path)
+      end
+
+      # Encodes a 1 segment of a path
+      #
+      # Slashes are considered part of the name, and are encoded as %2f
+      #
+      # @deprecated use \Sabre\HTTP\encode_path_segment
+      # @param [String] path_segment
+      # @return [String]
+      def self.encode_path_segment(path_segment)
+        Tilia::Http.encode_path_segment(path_segment)
+      end
+
+      # Decodes a url-encoded path
+      #
+      # @deprecated use \Sabre\HTTP\decodePath
+      # @param [String] path
+      # @return [String]
+      def self.decode_path(path)
+        Tilia::Http.decode_path(path)
+      end
+
+      # Decodes a url-encoded path segment
+      #
+      # @deprecated use \Sabre\HTTP\decode_path_segment
+      # @param [String] path
+      # @return [String]
+      def self.decode_path_segment(path)
+        Tilia::Http.decode_path_segment(path)
+      end
+
+      # Returns the 'dirname' and 'basename' for a path.
+      #
+      # @deprecated Use Sabre\Uri\split.
+      # @param [String] path
+      # @return array
+      def self.split_path(path)
+        Tilia::Uri.split(path)
+      end
+
+      # Resolves relative urls, like a browser would.
+      #
+      # @deprecated Use Sabre\Uri\resolve.
+      # @param [String] base_path
+      # @param [String] new_path
+      # @return [String]
+      def self.resolve(base_path, new_path)
+        Tilia::Uri.resolve(base_path, new_path)
+      end
+    end
+  end
+end

data/lib/tilia/http/util.rb

@@ -0,0 +1,51 @@
+module Tilia
+  module Http
+    # HTTP utility methods
+    #
+    # @deprecated All these functions moved to the Tilia::Http namespace
+    module Util
+      # Content negotiation
+      #
+      # @deprecated Use Tilia::Http::negotiate_content_type
+      # @param [String, nil] accept_header_value
+      # @param array available_options
+      # @return [String, nil]
+      def self.negotiate_content_type(accept_header_value, available_options)
+        Http.negotiate_content_type(accept_header_value, available_options)
+      end
+
+      # Deprecated! Use negotiateContentType.
+      #
+      # @deprecated Use Tilia::Http::negotiate_content_type
+      # @param [String, nil] accept_header
+      # @param array available_options
+      # @return [String, nil]
+      def self.negotiate(accept_header_value, available_options)
+        Http.negotiate_content_type(accept_header_value, available_options)
+      end
+
+      # Parses a RFC2616-compatible date string
+      #
+      # This method returns false if the date is invalid
+      #
+      # @deprecated Use Tilia::Http::parse_date
+      # @param [String] date_header
+      # @return bool|DateTime
+      def self.parse_http_date(date_header)
+        Http.parse_date(date_header)
+      end
+
+      # Transforms a DateTime object to HTTP's most common date format.
+      #
+      # We're serializing it as the RFC 1123 date, which, for HTTP must be
+      # specified as GMT.
+      #
+      # @deprecated Use Tilia::Http::to_date
+      # @param \DateTime date_time
+      # @return [String]
+      def self.to_http_date(date_time)
+        Http.to_date(date_time)
+      end
+    end
+  end
+end

data/lib/tilia/http/version.rb

@@ -0,0 +1,9 @@
+module Tilia
+  module Http
+    # This class contains the version number for the HTTP package
+    class Version
+      # Full version number
+      VERSION = '4.1.0'
+    end
+  end
+end