zero 0.1.0

data/lib/zero/request/accept.rb

@@ -0,0 +1,28 @@
+require_relative 'accept_type'
+
+module Zero
+  class Request
+    # encapsulates the accept header to easier work with
+    # this is partly copied from sinatra
+    class Accept
+      MEDIA_TYPE_SEPERATOR  = ','
+      MEDIA_PARAM_SEPERATOR = ';'
+      MEDIA_QUALITY_REGEX   = /q=[01]\./
+
+      KEY_HTTP_ACCEPT = 'HTTP_ACCEPT'
+      KEY_HTTP_ACCEPT_LANGUAGE = 'HTTP_ACCEPT_LANGUAGE'
+      KEY_HTTP_ACCEPT_ENCODING = 'HTTP_ACCEPT_ENCODING'
+
+      # create a new accept object
+      def initialize(environment)
+        @types = AcceptType.new(environment[KEY_HTTP_ACCEPT])
+        @language = AcceptType.new(environment[KEY_HTTP_ACCEPT_LANGUAGE])
+        @encoding = AcceptType.new(environment[KEY_HTTP_ACCEPT_ENCODING])
+      end
+
+      attr_reader :types
+      attr_reader :language
+      attr_reader :encoding
+    end
+  end
+end

data/lib/zero/request/accept_type.rb

@@ -0,0 +1,58 @@
+module Zero
+  class Request
+    # This class provides an interface to access information of accept schemas.
+    class AcceptType
+      MEDIA_TYPE_SEPERATOR  = ','
+      MEDIA_PARAM_SEPERATOR = ';'
+      MEDIA_QUALITY_REGEX   = /q=[01]\./
+
+      # create a new instance of AcceptType
+      def initialize(string)
+        if string.nil?
+          @elements = []
+        else
+          @elements = parse_elements(string)
+        end
+      end
+
+      # return the preferred type
+      # @return String the preferred media type
+      def preferred
+        @elements.first
+      end
+
+      # iterate over all media types
+      def each
+        @elements.each {|element| yield element}
+      end
+
+      private
+
+      # converts the accept string to a useable array
+      # @param string the string containing media ranges and options
+      def parse_elements(string = '*/*')
+        string.
+          gsub(/\s/, '').
+          split(MEDIA_TYPE_SEPERATOR).
+          map do |accept_range|
+            extract_order(*accept_range.split(MEDIA_PARAM_SEPERATOR))
+          end.
+          sort_by(&:last).
+          map(&:first)
+      end
+
+      # extract the order of the type
+      # @param media_type the type itself
+      # @param params further options to the type
+      # @return Array the media type and quality in that order
+      def extract_order(media_type, *params)
+        params.each do |param|
+          if param.match(MEDIA_QUALITY_REGEX)
+            return [media_type, 10 - param[4..-1].to_i] 
+          end
+        end
+        [media_type, 0]
+      end
+    end
+  end
+end

data/lib/zero/request/client.rb

@@ -0,0 +1,31 @@
+module Zero
+  class Request
+    # This class represents all information about the client of a request.
+    class Client
+      # the key for the ip of the client
+      KEY_REMOTE_ADDR = 'REMOTE_ADDR'
+      # the key for the hostname
+      KEY_REMOTE_HOST = 'REMOTE_HOST'
+      # the key for the user agent
+      KEY_USER_AGENT  = 'HTTP_USER_AGENT'
+
+      # creates a new client with the data of the request environment
+      # @param environment a hash representation of the request
+      def initialize(environment)
+        @address    = environment[KEY_REMOTE_ADDR]
+        @hostname   = environment[KEY_REMOTE_HOST]
+        @user_agent = environment[KEY_USER_AGENT]
+      end
+
+      # the ip address of the client
+      # @return [String] the address of the client
+      attr_reader :address
+      # the hostname of the client
+      # @return [String] the hostname of the client
+      attr_reader :hostname
+      # the user agent of the client
+      # @return [String] the user agent of the client
+      attr_reader :user_agent
+    end
+  end
+end

data/lib/zero/request/parameter.rb

@@ -0,0 +1,101 @@
+# TODO should that go into the main zero file?
+require 'set'
+
+module Zero
+  class Request
+    # represents all parameter set in a session
+    #
+    # This class holds all parameters available in the rack environment, split
+    # on query and payload parameters.
+    class Parameter
+      # they key for the query string
+      ENV_KEY_QUERY   = 'QUERY_STRING'
+      # the key for the payload
+      ENV_KEY_PAYLOAD = 'rack.input'     
+      # the key for custom parameters
+      ENV_KEY_CUSTOM = 'zero.params.custom'
+      # the key for the content type
+      ENV_KEY_CONTENT_TYPE = 'CONTENT_TYPE'
+      # all content types which used for using the body as a parameter input
+      PAYLOAD_CONTENT_TYPES = [
+        'application/x-www-form-urlencoded',
+        'multipart/form-data'
+      ].to_set
+
+      # get the query parameters
+      attr_reader :query
+      alias_method(:get, :query)
+
+      # get the payload or form data parameters
+      attr_reader :payload
+      alias_method(:post, :payload)
+
+      # get all custom parameters
+      attr_reader :custom
+
+      # creates a new parameter instance
+      #
+      # This should never be called directly, as it will be generated for you.
+      # This instance gives you the options to get query parameters (mostly
+      # called GET parameters) and payload parameters (or POST parameters).
+      # @param environment [Hash] the rack environment
+      def initialize(environment)
+        @query   = extract_query_params(environment)
+        @payload = extract_payload_params(environment)
+        if environment.has_key?(ENV_KEY_CUSTOM)
+          @custom = environment[ENV_KEY_CUSTOM]
+        else
+          @custom  = {}
+          environment[ENV_KEY_CUSTOM] = @custom
+        end
+      end
+
+      # get a parameter
+      #
+      # With this method you can get the value of a parameter. First the
+      # custom parameters are checked, then payload and after that the query
+      # ones.
+      #
+      # *Beware, that this may lead to security holes!*
+      #
+      # @param key [String] a key to look for
+      # @returns [String] the value of the key
+      def [](key)
+        @custom[key] || @payload[key] || @query[key]
+      end
+
+      # set a custom key/value pair
+      #
+      # Use this method if you want to set a custom parameter for later use. If
+      # the key was already set it will be overwritten.
+      # @param key [String] the key to use for saving the parameter
+      # @param value [Object] the value for the key
+      def []=(key, value)
+        @custom[key] = value
+      end
+
+      private
+
+      # extracts the key value pairs from the environment
+      # @return Hash all key value pairs from query string
+      def extract_query_params(environment)
+        return {} if environment[ENV_KEY_QUERY].length == 0
+        parse_string(environment[ENV_KEY_QUERY])
+      end
+
+      # extracts the key value pairs from the body
+      # @return Hash all key value pairs from the payload
+      def extract_payload_params(environment)
+        return {} unless PAYLOAD_CONTENT_TYPES.include?(environment[ENV_KEY_CONTENT_TYPE])
+        parse_string(environment[ENV_KEY_PAYLOAD].read)
+      end
+
+      # parse the query string like input to a hash
+      # @param query [String] the query string
+      # @return [Hash] the key/valuie pairs
+      def parse_string(query)
+        Hash[URI.decode_www_form(query)]
+      end
+    end
+  end
+end

data/lib/zero/request/server.rb

@@ -0,0 +1,41 @@
+module Zero
+  class Request
+    # This class represents all server related information of a request.
+    class Server
+      # the key for the server name
+      # @api private
+      KEY_SERVER_NAME     = 'SERVER_NAME'
+      # the key for the server port
+      # @api private
+      KEY_SERVER_PORT     = 'SERVER_PORT'
+      # the key for the server protocol
+      # @api private
+      KEY_SERVER_PROTOCOL = 'SERVER_PROTOCOL'
+      # the key for the server software
+      # @api private
+      KEY_SERVER_SOFTWARE = 'SERVER_SOFTWARE'
+
+      # This creates a new server instance extracting all server related
+      #  information from the environment.
+      def initialize(environment)
+        @hostname = environment[KEY_SERVER_NAME]
+        @port     = environment[KEY_SERVER_PORT].to_i
+        @protocol = environment[KEY_SERVER_PROTOCOL]
+        @software = environment[KEY_SERVER_SOFTWARE]
+      end
+
+      # get the port
+      # @return [Numeric] the port
+      attr_reader :port
+      # get the hostname of the server
+      # @return [String] the hostname
+      attr_reader :hostname
+      # get the protocol of the server (normally it should be HTTP/1.1)
+      # @return [String] the protocol
+      attr_reader :protocol
+      # get the server software
+      # @return [String] the server software name
+      attr_reader :software
+    end
+  end
+end

data/lib/zero/response.rb

@@ -0,0 +1,80 @@
+module Zero
+
+  # This is the representation of a response
+  #
+  class Response
+    attr_reader :status
+    attr_accessor :header, :body
+
+    # Constructor
+    # Sets default status code to 200.
+    #
+    def initialize
+      @status = 200
+      @header = {}
+      @body   = []
+    end
+
+    # Sets the status.
+    # Also converts every input directly to an integer.
+    #
+    # @param [Integer] status The status code
+    #
+    def status=(status)
+      @status = status.to_i
+    end
+
+    # Returns the data of the response as an array:
+    # [status, header, body]
+    # to be usable by any webserver.
+    #
+    # Sets the Content-Type to 'text/html', if it's not already set.
+    # Sets the Content-Length, if it's not already set. (Won't fix wrong
+    # lengths!)
+    # Removes Content-Type, Content-Length and body on status code 204 and 304.
+    #
+    # @return [Array] Usable by webservers
+    #
+    def to_a
+      # Remove content length and body, on status 204 and 304
+      if status == 204 or status == 304
+        header.delete('Content-Length')
+        header.delete('Content-Type')
+        self.body = []
+      else
+        # Set content length, if not already set
+        content_length unless header.has_key? 'Content-Length'
+        # Set content type, if not already set
+        self.content_type = 'text/html' unless header.has_key? 'Content-Type'
+      end
+
+      [status, header, body]
+    end
+
+    # Sets the content length header to the current length of the body
+    # Also creates one, if it does not exists
+    #
+    def content_length
+      self.header['Content-Length'] = body.join.bytesize.to_s
+    end
+
+    # Sets the content type header to the given value
+    # Also creates it, if it does not exists
+    #
+    # @param [String] value Content-Type tp set
+    #
+    def content_type=(value)
+      self.header['Content-Type'] = value
+    end
+
+    # Sets the Location header to the given URL and the status code to 302.
+    # 
+    # @param [String] location Redirect URL
+    #
+    def redirect(location, status = 302)
+      self.status = status
+      self.header['Location'] = location
+    end
+
+  end
+end

data/lib/zero/router.rb

@@ -0,0 +1,63 @@
+module Zero
+  # makes it possible to route urls to rack applications
+  #
+  # This class can be used to build a small rack application which routes
+  # requests to the given application.
+  # In the URLs it is also possible to use placeholders which then get assigned
+  # as variables to the parameters.
+  #
+  # @example of a simple router
+  #   router = Zero::Router.new(
+  #     '/' => WelcomeController,
+  #     '/posts' => PostController
+  #   )
+  #
+  # @example of a router with variables
+  #   router = Zero::Router.new(
+  #     '/foo/:id' => FooController
+  #   )
+  class Router
+    # match for variables in routes
+    VARIABLE_MATCH = %r{:(\w+)[^/]?}
+    # the replacement string to make it an regex
+    VARIABLE_REGEX = '(?<\1>.+?)'
+
+    # create a new router instance
+    #
+    # @example of a simple router
+    #   router = Zero::Router.new(
+    #     '/' => WelcomeController,
+    #     '/posts' => PostController
+    #   )
+    # 
+    # @param routes [Hash] a map of URLs to rack compatible applications
+    def initialize(routes)
+      @routes = {}
+      routes.each do |route, target|
+        @routes[
+          Regexp.new(
+            route.gsub(VARIABLE_MATCH, VARIABLE_REGEX) + '$')] = target
+      end
+    end
+
+    # call the router and call the matching application
+    #
+    # This method has to be called with a rack compatible environment, then the
+    # method will find a matching route and call the application.
+    # @param env [Hash] a rack environment
+    # @return [Array] a rack compatible response
+    def call(env)
+      request = Zero::Request.create(env)
+      @routes.each do |route, target|
+        match = route.match(request.path)
+        if match
+          match.names.each_index do |i|
+            request.params[match.names[i]] = match.captures[i]
+          end
+          return target.call(request.env)
+        end
+      end
+      [404, {'Content-Type' => 'text/html'}, ['Not found!']]
+    end
+  end
+end

data/lib/zero/version.rb

@@ -0,0 +1,3 @@
+module Zero
+  VERSION = '0.1.0'.freeze
+end

data/spec/fixtures/templates/index.html.erb

@@ -0,0 +1 @@
+success

data/spec/fixtures/templates/index.json.erb

@@ -0,0 +1 @@
+{text: 'success'}

data/spec/spec_helper.rb

@@ -0,0 +1,65 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '_spec.rb'
+  add_filter 'spec_helper.rb'
+end
+
+require 'rack'
+require 'erb'
+require 'tilt'
+require 'zero'
+
+class SpecTemplateContext
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+end
+
+class SpecController < Zero::Controller
+  def process; end
+  def render; @response = [200, {'Content-Type' => 'text/html'}, ['foo']]; end
+end
+
+class SpecApp
+  attr_reader :env
+
+  def self.call(env)
+    @env = env
+    return [200, {'Content-Type' => 'text/html'}, ['success']]
+  end
+end
+
+class EnvGenerator
+  KEY_REQUEST_METHOD = 'REQUEST_METHOD'
+  KEY_REQUEST_GET    = 'GET'
+  KEY_REQUEST_HEAD   = 'HEAD'
+  KEY_REQUEST_POST   = 'POST'
+  KEY_REQUEST_PUT    = 'PUT'
+  KEY_REQUEST_DELETE = 'DELETE'
+
+  def self.generate_env(uri, options)
+    Rack::MockRequest.env_for(uri, options)
+  end
+
+  def self.get(uri, options = {})
+    generate_env(uri, options.merge(KEY_REQUEST_METHOD => KEY_REQUEST_GET))
+  end
+
+  def self.head(uri, options = {})
+    generate_env(uri, options.merge(KEY_REQUEST_METHOD => KEY_REQUEST_HEAD))
+  end
+
+  def self.post(uri, options = {})
+    generate_env(uri, options.merge(KEY_REQUEST_METHOD => KEY_REQUEST_POST))
+  end
+
+  def self.put(uri, options = {})
+    generate_env(uri, options.merge(KEY_REQUEST_METHOD => KEY_REQUEST_PUT))
+  end
+
+  def self.delete(uri, options = {})
+    generate_env(uri, options.merge(KEY_REQUEST_METHOD => KEY_REQUEST_DELETE))
+  end
+end