zero 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+.rbx
+config.ru

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--order random

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :guard do
+  gem 'guard'
+  gem 'guard-bundler'
+  gem 'guard-rspec'
+end
+
+group :test do
+  gem 'thor'
+  gem 'simplecov'
+end

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    zero (0.0.1)
+      tilt
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.0.8)
+    diff-lcs (1.1.3)
+    guard (1.5.4)
+      listen (>= 0.4.2)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-bundler (1.0.0)
+      bundler (~> 1.0)
+      guard (~> 1.1)
+    guard-rspec (2.3.0)
+      guard (>= 1.1)
+      rspec (~> 2.11)
+    listen (0.6.0)
+    lumberjack (1.0.2)
+    method_source (0.8.1)
+    multi_json (1.3.7)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    rack (1.4.1)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.0)
+    rspec-expectations (2.12.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.3.3)
+    thor (0.16.0)
+    tilt (1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard
+  guard-bundler
+  guard-rspec
+  rack
+  rspec
+  simplecov
+  thor
+  zero!

data/Guardfile

@@ -0,0 +1,15 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  # Uncomment next line if Gemfile contain `gemspec' command
+  watch(/^.+\.gemspec/)
+end
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -0,0 +1,60 @@
+zero - a toolkit for web services
+=================================
+
+The focus of this project is to provide small helpers for building web services
+without the need of learning a complete new web stack from the bottom to the
+top.
+
+As this project is still at the beginning, some things may change or may not be
+as good as other parts. But we are working on these parts to make them easier
+to use and stable enough.
+
+The following is a small list of things, the project already provides and at the
+end you can find a small sample on what is already possible.
+
+parts of the toolkit
+--------------------
+
+### Request
+
+A new request implementation is provided to make it easier for accessing all the
+various elements of a request. It provides an interface for all access headers
+through the method `#access`. It also provides a method `#params`, which returns
+an object with parameters seperated between *query* and *payload* parameters.
+
+### Response
+
+A new response is also provided. which is just some lines of code at the moment,
+but will grow in functionality. We aim at a response which will take care of all
+the http specific stuff itself, to make it easier for you.
+
+### Router
+
+A small router with variables is also provided. It can take static urls, but
+also dynamic routes and push them to the appropiate controller. It is very
+lightweight and can therefore be used in other projects, where a Rack::Router
+is needed but can't do as much and other implementations are just to big.
+
+### Renderer
+
+This part should do the work for you to decide, which template to use. You can
+define a template directory and a mapping of simple shortcuts of types to all
+types the template should be rendered with. With these two information the
+renderer will take care of selecting the correct template, so that you can
+concentrate on the hard parts.
+
+### Controller
+
+This is in a very rough state at the moment, but already shows the potential in
+which direction this hole project should go. It defines a very simple interface
+for your own controllers, in that it only wants `#render` to be implemented, but
+also calls `#process` to seperate the processing and rendering. It uses the
+Zero tools at the moment, but later should be able to use other libs too.
+
+example
+-------
+
+To give you an impression on what these parts can already do for you, you can
+take a look at the sample application 
+[here](https://github.com/Gibheer/zero-examples) and try it out. It does not
+take much.

data/Thorfile

@@ -0,0 +1,6 @@
+class Default < Thor
+  desc 'spec', 'run all specs'
+  def spec
+    exec 'rspec'
+  end
+end

data/lib/zero.rb

@@ -0,0 +1,7 @@
+module Zero
+  require_relative 'zero/controller'
+  require_relative 'zero/router'
+  require_relative 'zero/renderer'
+  require_relative 'zero/request'
+  require_relative 'zero/response'
+end

data/lib/zero/controller.rb

@@ -0,0 +1,46 @@
+module Zero
+  # abstract class to make creation of controllers easier
+  #
+  # This abstract class creates an interface to make it easier to write
+  # rack compatible controllers. It catches #call and creates a new instance
+  # with the environment and calls #render on it.
+  class Controller
+    # initialize a new instance of the controller and call response on it
+    def self.call(env)
+      new(Zero::Request.create(env)).response
+    end
+
+    # set the renderer to use in the controller
+    def self.renderer=(renderer)
+      @@renderer = renderer
+    end
+
+    # get the renderer set in the controller
+    def self.renderer
+      @@renderer
+    end
+
+    # a small helper to get the actual renderer
+    def renderer
+      self.class.renderer
+    end
+
+    # initialize the controller
+    # @param request [Request] a request object
+    def initialize(request)
+      @request  = request
+      @response = Zero::Response.new
+    end
+
+    # build the response and return it
+    #
+    # This method calls #process if it was defined so make it easier to process
+    # the request before rendering stuff.
+    # @return Response a rack conform response
+    def response
+      process if respond_to?(:process)
+      render
+      @response.to_a
+    end
+  end
+end

data/lib/zero/rack_request.rb

@@ -0,0 +1,44 @@
+# as we need #update_param we patch it it into the request
+# this is directly from thr request.rb of the rack repository, so this
+# can be deleted, when rack was released
+r = Rack::Request.new(Rack::MockRequest.env_for('foo'))
+if not r.respond_to?('update_param') then
+  class Rack::Request
+    # Destructively update a parameter, whether it's in GET and/or POST.
+    # Returns nil.
+    #
+    # The parameter is updated wherever it was previous defined, so
+    # GET, POST, or both. If it wasn't previously defined, it's inserted into GET.
+    #
+    # env['rack.input'] is not touched.
+    def update_param(k, v)
+      found = false
+      if self.GET.has_key?(k)
+        found = true
+        self.GET[k] = v
+      end
+      if self.POST.has_key?(k)
+        found = true
+        self.POST[k] = v
+      end
+      unless found
+        self.GET[k] = v
+      end
+      @params = nil
+      nil
+    end
+
+    # Destructively delete a parameter, whether it's in GET or POST.
+    # Returns the value of the deleted parameter.
+    #
+    # If the parameter is in both GET and POST, the POST value takes
+    # precedence since that's how #params works.
+    #
+    # env['rack.input'] is not touched.
+    def delete_param(k)
+      v = [ self.POST.delete(k), self.GET.delete(k) ].compact.first
+      @params = nil
+      v
+    end
+  end
+end

data/lib/zero/renderer.rb

@@ -0,0 +1,139 @@
+module Zero
+  # the base renderer for getting render containers
+  #
+  # This class handles templates and render coontainers, which can be used for
+  # the actual rendering.
+  #
+  # To use this renderer you have to give it a template path and optionally
+  # a map of shorthand type descriptions to fully types. This will then be used
+  # to extend the internal map of templates to possible formats in a way, that
+  # you will be able to answer xhtml and html requests with the same template.
+  #
+  # When the object is initialized and you are sure, everything is loaded, call
+  # #read_template_path! and the template tree will be built. Without this step,
+  # you will probably don't get any output.
+  #
+  # After the setup, the renderer can be used to build render containers, which
+  # then can be used to actually render something.
+  class Renderer
+    # initializes a new Renderer
+    #
+    # This method takes a path to the base template directory and a type map.
+    # This type map is used to extend the possible renderings for different
+    # types, which the clients sends.
+    #
+    # @example create a simple renderer
+    #   Renderer.new('app/templates')
+    #
+    # @example create a renderer with a small map
+    #   Renderer.new('app', {
+    #     'html' => ['text/html', 'application/html+xml'],
+    #     'json' => ['application/json', 'application/aweomse+json']
+    #   })
+    #
+    # @param template_path [String] a string to templates
+    # @param type_map [Hash] a map of simple types to complex ones
+    def initialize(template_path, type_map = {})
+      @template_path = template_path + '/'
+      @type_map = type_map
+    end
+
+    # returns the hash of type conversions
+    # @return [Hash] type conversion
+    attr_reader :type_map
+    # get the path to the templates
+    # @return [String] the base template path
+    attr_reader :template_path
+    # get the tree of templates
+    # @api private
+    # @return [Hash] the template tree
+    attr_reader :templates
+
+    # load the template tree
+    #
+    # This method gets all templates in the `template_path` and builds an
+    # internal tree structure, where templates and types direct the request to
+    # the wanted template.
+    # @return [Self] returns the object
+    def read_template_path!
+      # TODO clean up later
+      @templates = {}
+      search_files.each do |file|
+        parts = file.gsub(/#{template_path}/, '').split('.')
+        @templates[parts[0]] ||= {}
+
+        # Set default value
+        types = 'default'
+        # Overwrite default value, if it's set in template path
+        if parts.count > 2 then
+          types = parts[1]
+        end
+
+        read_type(types).each do |type|
+          @templates[parts[0]][type] = file
+        end
+      end
+    end
+
+    # render a template
+    #
+    # This method will render the given template, based on the type in the given
+    # context.
+    # @param name [String] the name of the template
+    # @param type [Array] a list of accept types used to find the template
+    # @param context [Object] the context in which to evaluate the template
+    # @return [String] the rendered content
+    def render(name, type, context)
+      template(name, type).render(context)
+    end
+
+    private
+
+    # search in `template_path` for templates beginning with `template_name`
+    # @api private
+    # @param template_name [String] the name of the template
+    # @return [#each] a list of all templates found
+    def search_files
+      Dir[template_path + '**/*.*']
+    end
+
+    # gets the type information from a file and converts it to an array of
+    # possible matching types
+    # @api private
+    # @param short_notation [String] a short notation of a type, like `html`
+    # @return [Array] a list of matching types, like `text/html`
+    def read_type(short_notation)
+      to_type_list(type_map[short_notation] || short_notation)
+    end
+
+    # convert a map to an array if it is not one
+    # @api private
+    # @param original_map [Object] the type(s) to convert
+    # @return [Array] a list of objects
+    def to_type_list(original_map)
+      return original_map if original_map.respond_to?(:each)
+      [original_map]
+    end
+
+    # get the prepared template for the name and type
+    # @api private
+    # @param name [String] the name of the template
+    # @param types [Array] the types for the template
+    # @return [Tilt::Template] a prepared tilt template
+    def template(name, types)
+      if templates.has_key? name
+        types.each do |type|
+          template = templates[name][type]
+          unless template.nil?
+            return template if template.kind_of?(Tilt::Template)
+            return Tilt.new(template)
+          end
+        end
+        raise ArgumentError.new(
+          "No template found for any of this types #{types.join ', '}!"
+        )
+      end
+      raise ArgumentError.new "No template found for '#{name}'!"
+    end
+  end
+end

data/lib/zero/request.rb

@@ -0,0 +1,100 @@
+require_relative 'request/accept'
+require_relative 'request/client'
+require_relative 'request/parameter'
+require_relative 'request/server'
+
+module Zero
+  # This class wraps around a rack environment for easier access to all data.
+  class Request
+    def self.create(environment)
+      return environment['zero.request'] if environment.has_key?('zero.request')
+      new(environment)
+    end
+
+    # create a new request object
+    def initialize(env)
+      @env = env
+      @env['zero.request'] = self
+    end
+
+    # get the environment
+    # @return [Hash] the environment hash
+    attr_reader :env
+
+    # get the requested path
+    # @return [String] returns the requested path
+    def path
+      @path ||= @env[CONST_PATH_INFO]
+    end
+
+    # return all information about the client
+    # @return [Client] an information object about the client
+    def client
+      @client ||= Request::Client.new(@env)
+    end
+
+    # get the information on the server
+    # @return [Server] information on the running server
+    def server
+      @server ||= Request::Server.new(@env)
+    end
+
+    # get an object representing the parameters of the request
+    # @return [Parameter] object having all parameters
+    def params
+      @params ||= Request::Parameter.new(@env)
+    end
+
+    # return the content type of the request
+    # TODO change into its own object?
+    # @return [String] returns the content type of the request
+    def content_type
+      @env[CONST_CONTENT_TYPE] if @env.has_key?(CONST_CONTENT_TYPE)
+    end
+
+    # get the media types
+    # @return [Accept] on Accept object managing all types and their order
+    def accept
+      @accept ||= Request::Accept.new(@env)
+    end
+
+    # get the method of the request
+    # @return [Symbol] the symbol representation of the method
+    def method
+      @method ||= @env[CONST_REQUEST_METHOD].downcase.to_sym
+    end
+    # is the method 'GET'?
+    # @return [Boolean] true if this is a get request
+    def get?;  method == :get;  end
+    # is the method 'POST'?
+    # @return [Boolean] true if this is a post request
+    def post?; method == :post; end
+    # is the method 'PUT'?
+    # @return [Boolean] true if this is a put request
+    def put?;  method == :put;  end
+    # is the method 'DELETE'?
+    # @return [Boolean] true if this is a delete request
+    def delete?; method == :delete; end
+    # is the method 'HEAD'?
+    # @return [Boolean] true if this is a head request
+    def head?; method == :head; end
+    # is the method 'PATCH'?
+    # @return [Boolean] true if this is a patch request
+    def patch?; method == :patch; end
+
+    private
+
+    # constant for the content type key
+    # @api private
+    CONST_CONTENT_TYPE   = 'CONTENT_TYPE'
+    # constant for the http accept key
+    # @api private
+    CONST_HTTP_ACCEPT    = 'HTTP_ACCEPT'
+    # constant for the path info key
+    # @api private
+    CONST_PATH_INFO      = 'PATH_INFO'
+    # constant for the request method key
+    # @api private
+    CONST_REQUEST_METHOD = 'REQUEST_METHOD'
+  end
+end