kawaii-core 0.1.0

data/lib/kawaii/render_methods.rb

@@ -0,0 +1,14 @@
+module Kawaii
+  # Template rendering based on Tilt.
+  module RenderMethods
+    # Renders a template.
+    # @param tmpl [String] file name or path to template, relative to /views in project dir
+    # @example Rendering html erb file
+    #   render('index.html.erb')
+    # @todo Layouts.
+    def render(tmpl)
+      t = Tilt.new(File.join('views', tmpl)) # @todo Caching!
+      t.render(self)
+    end
+  end
+end

data/lib/kawaii/route.rb

@@ -0,0 +1,27 @@
+module Kawaii
+  # Matching and resolution for a single route.
+  class Route
+    include MethodChain
+
+    # Create a {Route} object.
+    # @param path [String, Regexp, Matcher] any path specification which can be
+    # consumed by {Matcher.compile}
+    # @param block [Proc] route handler
+    def initialize(scope, path, &block)
+      self.parent_scope = scope
+      @matcher = Matcher.compile(path, full_match: true)
+      @block = block
+    end
+
+    # Tries to match the route against a Rack environment.
+    # @param env [Hash] Rack environment
+    # @return [RouteHandler] a Rack application creating environment to run
+    # the route's handler block in on {RouteHandler#call}. Can be nil if
+    # no match found.
+    def match(env)
+      match = @matcher.match(env[Rack::PATH_INFO])
+      # puts "Route#match #{@matcher} #{env[Rack::PATH_INFO]} #{match.inspect}"
+      RouteHandler.new(self, match.params, &@block) if match
+    end
+  end
+end

data/lib/kawaii/route_context.rb

@@ -0,0 +1,49 @@
+module Kawaii
+  # Implementation of nested routes generated via Router#context.
+  #
+  # @example A simple context
+  #   context '/foo' do
+  #     get '/bar' do
+  #     end
+  #   end
+  #
+  #   # It is a rough equivalent of:
+  #
+  #   ctx = RouteContext.new('/foo')
+  #   ctx.get '/bar' do
+  #   end
+  #
+  # @private
+  class RouteContext
+    include RoutingMethods
+    include MethodChain
+
+    # Create a {RouteContext} object.
+    # @param path [String, Regexp, Matcher] any path specification which can
+    # be consumed by {Matcher.compile}
+    def initialize(scope, path)
+      self.parent_scope = scope
+      super()
+      @matcher = Matcher.compile(path, starts_with: true)
+    end
+
+    # Tries to match the context against a Rack environment.
+    # @param env [Hash] Rack environment
+    # @return [Route] matching route defined inside the context. Can be nil if
+    # no match found.
+    def match(env)
+      m = @matcher.match(env[Rack::PATH_INFO])
+      super(env.merge(Rack::PATH_INFO => ensure_slash(m.remaining_path))) if m
+    end
+
+    protected
+
+    def ensure_slash(path)
+      if path.start_with?('/')
+        path
+      else
+        '/' + path
+      end
+    end
+  end
+end

data/lib/kawaii/route_handler.rb

@@ -0,0 +1,54 @@
+module Kawaii
+  # Creates context for execution of route handler block provided by the user
+  # with {#params} and other objects.
+  #
+  # @example Route handler block
+  #   get '/users/:id' do
+  #     if params[:id] ...
+  #   end
+  class RouteHandler
+    include MethodChain
+    include RenderMethods
+
+    # Params based on request visible in the route handler scope.
+    attr_reader :params
+    # Rack::Request object visible in the route handler scope
+    attr_reader :request
+
+    # Creates a new RouteHandler wrapping a handler block.
+    # @param path_params [Hash] named parameters from paths similar to
+    #        /users/:id
+    # @param block [Proc] the actual route handler
+    def initialize(scope, path_params, &block)
+      self.parent_scope = scope
+      @path_params = path_params
+      @block = block
+    end
+
+    # Invokes the handler as a normal Rack application.
+    # @param env [Hash] Rack environment
+    # @return [Array] Rack response array
+    def call(env)
+      @request = Rack::Request.new(env)
+      @params = @path_params.merge(@request.params.symbolize_keys)
+      process_response(instance_exec(self, params, request, &@block))
+    end
+
+    protected
+
+    class ResponseError < RuntimeError; end
+
+    def process_response(response)
+      if response.is_a?(String)
+        [200,
+         { Rack::CONTENT_TYPE => 'text/html',
+           Rack::CONTENT_LENGTH => response.size.to_s },
+         [response]]
+      elsif response.is_a?(Array)
+        response
+      else
+        fail ResponseError, "Unsupported handler aresponse: #{response.inspect}"
+      end
+    end
+  end
+end

data/lib/kawaii/route_mapping.rb

@@ -0,0 +1,35 @@
+module Kawaii
+  # @private
+  # Maps route to a handler based on parameters.
+  # Supports mapping to blocks and to controller actions.
+  class RouteMapping
+    def initialize(mapping, &block)
+      fail 'Do not provide a block if mapping given' if mapping && block
+      fail 'Provide a mapping or a block' unless mapping || block
+      @mapping = mapping
+      @block = block
+    end
+
+    def resolve
+      return @block if @block
+      controller_name, method = parse(@mapping)
+      controller_class = find_controller(controller_name)
+      fail "Cannot find controller: #{controller_name}" if controller_class.nil?
+      proc do |& _args|
+        controller = controller_class.new(params, request)
+        controller.send(method)
+      end
+    end
+
+    protected
+
+    def find_controller(controller_name)
+      Object.const_get(controller_name)
+    end
+
+    def parse(mapping)
+      controller, method = mapping.split('#')
+      [controller.camelcase, method.to_sym]
+    end
+  end
+end

data/lib/kawaii/routing_methods.rb

@@ -0,0 +1,120 @@
+module Kawaii
+  # Core route-building and matching.
+  #
+  # These functions can be used both in a class inheriting from {Base}
+  # and in file scope.
+  #
+  # @example Using a class deriving from {Base}
+  #   class MyApp < Kawaii::Base
+  #     get '/' do
+  #       'Hello, world'
+  #     end
+  #   end
+  #
+  # @example Using top-level (source file scope) route definitions
+  #   get '/' do
+  #     'Hello, world'
+  #   end
+  module RoutingMethods
+    # @!macro [attach] add_http_method
+    #   @method $1(path, &block)
+    #   Route handler for $1 HTTP method
+    #   @param path [String, Regexp, Matcher] any path specification which can
+    #          be consumed by {Matcher.compile}
+    #   @param block the route handler
+    #   @yield to the given block
+    # @note Supported HTTP verbs based on https://github.com/rack/rack/blob/master/lib/rack.rb#L48
+    def self.add_http_method(meth)
+      define_method(meth) do |path, mapping = nil, &block|
+        handler = RouteMapping.new(mapping, &block).resolve
+        add_route!(meth.to_s.upcase, Route.new(self, path, &handler))
+      end
+    end
+
+    add_http_method :get
+    add_http_method :post
+    add_http_method :put
+    add_http_method :patch
+    add_http_method :delete
+    add_http_method :head
+    add_http_method :options
+    add_http_method :link
+    add_http_method :unlink
+    add_http_method :trace
+    # Note: Have to generate them individually due to yard limitations.
+
+
+    # Insert routes corresponding to REST actions (similar to Rails `resource`).
+    # @param path [String] path prefix (e.g. "/users/")
+    # @param controller [String] snakecase controller name (e.g. "hello_world"
+    #        corresponds to HelloWorld).
+    # @example REST resource routes
+    #    route '/users/', 'hello_world'
+    # 
+    #    # Will insert routes corresponding to:
+    #    # GET /users/? -> Controller#index
+    #    # GET /users/:id/? -> Controller#show
+    #    # POST /users/? -> Controller#create
+    #    # PATCH /users/:id/? -> Controller#update
+    #    # DELETE /users/:id/? -> Controller#destroy
+    def route(path, controller)
+      get(File.join(path, '?'), "#{controller}#index")
+      get(File.join(path, '/:id/?'), "#{controller}#show")
+      post(File.join(path, '?'), "#{controller}#create")
+      patch(File.join(path, '/:id/?'), "#{controller}#update")
+      delete(File.join(path, '/:id/?'), "#{controller}#destroy")
+    end
+
+    # Create a context for route nesting.
+    #
+    #   @param path [String, Regexp, Matcher] any path specification which can
+    #          be consumed by {Matcher.compile}
+    #   @param block the route handler
+    #   @yield to the given block
+    #
+    # @example A simple context
+    #   context '/foo' do
+    #     get '/bar' do
+    #     end
+    #   end
+    def context(path, &block)
+      ctx = RouteContext.new(self, path)
+      # @todo Is there a better way to keep ordering of routes?
+      # An alternative would be to enter each route in a context only once
+      # (with 'prefix' based on containing contexts).
+      # On the other hand, we're only doing that when compiling routes, further
+      # processing is faster this way.
+      ctx.instance_eval(&block)
+      ctx.methods_used.each do |meth|
+        add_route!(meth, ctx)
+      end
+    end
+
+    # Tries to match against a Rack environment.
+    # @param env [Hash] Rack environment
+    # @return [Route] matching route. Can be nil if no match found.
+    def match(env)
+      routes[env[Rack::REQUEST_METHOD]]
+        .lazy # Lazy to avoid unnecessary calls to #match.
+        .map { |r| r.match(env) }
+        .find { |r| !r.nil? }
+    end
+
+    # Returns a list of HTTP methods used by the routes (incl. nested routes).
+    # @return [Array<String>] example ["GET", "POST"]
+    def methods_used
+      routes.keys
+    end
+
+    protected
+
+    def routes
+      @routes ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def add_route!(method, route)
+      # puts "add_route! #{method} #{route.inspect}"
+      routes[method] << route
+    end
+  end
+end

data/lib/kawaii/server_methods.rb

@@ -0,0 +1,33 @@
+module Kawaii
+  # Mixins for starting a self-contained server. To be included in a class
+  # derived from {Base}.
+  # @note At the moment hard-coded to use WEBrick.
+  module ServerMethods
+    WEBRICK = 'WEBrick'
+
+    # Starts serving the app.
+    # @param port [Fixnum] port number to bind to
+    def start!(port) # @todo Support other handlers http://www.rubydoc.info/github/rack/rack/Rack/Handler
+      Rack::Handler.get(WEBRICK).run(self, Port: port) do |s|
+        @server = s
+        at_exit { stop! }
+        [:INT, :TERM].each do |signal|
+          old = trap(signal) do
+            stop!
+            old.call if old.respond_to?(:call)
+          end
+        end
+      end
+    end
+
+    # Stops serving the app.
+    def stop!
+      @server.stop if @server # NOTE: WEBrick-specific
+    end
+
+    # Returns true if the server is running.
+    def running?
+      !@server.nil?
+    end
+  end
+end

data/lib/kawaii/singleton_app.rb

@@ -0,0 +1,58 @@
+module Kawaii
+  # Class used to implement a standalone Kawaii app generated with top-level
+  # route helpers (e.g. monkey-patched onto the `main` object).
+  #
+  # This lets you create a .rb file containing just route definitions and run it
+  # with `ruby` command.
+  #
+  # @example test.rb
+  #   require 'kawaii'
+  #
+  #   get '/' do
+  #     'Hello, world'
+  #   end
+  #
+  # @example Running from command line
+  #   ruby -r kawaii test.rb
+  #   ...
+  #
+  class SingletonApp < Base
+    class << self
+      def maybe_start!(port)
+        # Give routes a chance to install and app to initialize.
+        at_exit { start!(port) unless $ERROR_INFO } if !running? && run_direct?
+      end
+
+      protected
+
+      def run_direct?
+        c = caller_locations.map(&:path).find { |path| !skip_caller?(path) }
+        File.identical?($PROGRAM_NAME, c)
+      end
+
+      def skip_caller?(path)
+        File.identical?(path, __FILE__) ||
+          path[%r{rubygems/core_ext/kernel_require\.rb$}] ||
+          path[%r{/kawaii.rb$}]
+      end
+    end
+  end
+end
+
+# Helpers you use directly in a .rb file without using a class
+# inheriting from {Base}.
+#
+# @example hello_world.rb
+#   get '/' do
+#      'Hello, world'
+#   end
+class << self
+  include Kawaii::RoutingMethods
+
+  def routes
+    Kawaii::SingletonApp.routes # Add route handlers to {SingletonApp}
+  end
+end
+
+# For self-contained execution without config.ru. See {SingletonApp} above.
+Kawaii::SingletonApp.maybe_start!(8088) # @todo Hard-coded port number.

data/lib/kawaii/version.rb

@@ -0,0 +1,4 @@
+# Gem version.
+module Kawaii
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: kawaii-core
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Marcin Bilski
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.6'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Kawaii is a basic but extensible web framework based on Rack
+email:
+- gyamtso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/controller.ru
+- examples/hello_world.rb
+- examples/hello_world.ru
+- examples/modular.ru
+- examples/modular/first_app.rb
+- examples/modular/second_app.rb
+- examples/nested_routes.rb
+- examples/views.ru
+- examples/views/index.html.erb
+- kawaii-core.gemspec
+- lib/kawaii.rb
+- lib/kawaii/base.rb
+- lib/kawaii/controller.rb
+- lib/kawaii/core_ext/hash.rb
+- lib/kawaii/core_ext/string.rb
+- lib/kawaii/matchers.rb
+- lib/kawaii/method_chain.rb
+- lib/kawaii/render_methods.rb
+- lib/kawaii/route.rb
+- lib/kawaii/route_context.rb
+- lib/kawaii/route_handler.rb
+- lib/kawaii/route_mapping.rb
+- lib/kawaii/routing_methods.rb
+- lib/kawaii/server_methods.rb
+- lib/kawaii/singleton_app.rb
+- lib/kawaii/version.rb
+homepage: https://github.com/bilus/kawaii
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Kawaii is a simple web framework based on Rack
+test_files: []
+has_rdoc: