kawaii-core 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'kawaii'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/controller.ru

@@ -0,0 +1,30 @@
+require 'kawaii'
+
+class HelloWorld < Kawaii::Controller
+  def index
+    @title = 'Hello, world'
+    render('index.html.erb')
+  end
+
+  def show
+    "GET /users/#{params[:id]}"
+  end
+
+  def create
+    'POST /users'
+  end
+
+  def update
+    "PATCH /users/#{params[:id]}"
+  end
+
+  def destroy
+    "DELETE /users/#{params[:id]}"
+  end
+end
+
+class App < Kawaii::Base
+  route '/users/', :hello_world
+end
+
+run App

data/examples/hello_world.rb

@@ -0,0 +1,5 @@
+require 'kawaii'
+
+get '/' do
+  'Hello, world'
+end

data/examples/hello_world.ru

@@ -0,0 +1,4 @@
+require 'kawaii'
+require_relative 'hello_world'
+
+run Kawaii::SingletonApp

data/examples/modular.ru

@@ -0,0 +1,11 @@
+require 'kawaii'
+require_relative 'modular/first_app'
+require_relative 'modular/second_app'
+
+map '/first' do
+  run FirstApp
+end
+
+map '/second' do
+  run SecondApp
+end

data/examples/modular/first_app.rb

@@ -0,0 +1,6 @@
+# FirstApp -- see modular.ru
+class FirstApp < Kawaii::Base
+  get '/' do
+    'First app'
+  end
+end

data/examples/modular/second_app.rb

@@ -0,0 +1,6 @@
+# SecondApp -- see modular.ru
+class SecondApp < Kawaii::Base
+  get '/' do
+    'Second app'
+  end
+end

data/examples/nested_routes.rb

@@ -0,0 +1,11 @@
+require 'kawaii'
+
+context '/foo' do
+  get '/bar' do
+    'Nested routes'
+  end
+
+  get '/' do
+    'Hello'
+  end
+end

data/examples/views.ru

@@ -0,0 +1,10 @@
+require 'kawaii'
+
+class Views < Kawaii::Base
+  get '/' do
+    @title = 'Hello, world'
+    render('index.html.erb')
+  end
+end
+
+run Views

data/examples/views/index.html.erb

@@ -0,0 +1 @@
+<h1><%= @title %></h1>

data/kawaii-core.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kawaii/version'
+
+Gem::Specification.new do |spec|
+  spec.name      = 'kawaii-core'
+  spec.version   = Kawaii::VERSION
+  spec.authors   = ['Marcin Bilski']
+  spec.email     = ['gyamtso@gmail.com']
+
+  spec.summary       = 'Kawaii is a simple web framework based on Rack'
+  spec.description   = 'Kawaii is a basic but extensible web framework based on Rack'
+  
+  spec.homepage  = "https://github.com/bilus/kawaii"
+  spec.license   = 'MIT'
+
+  spec.files     = `git ls-files -z`.split("\x0").reject { |f|
+    f.match(%r{^(test|spec|features)/})
+  }
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'rack', '~> 1.6'
+  spec.add_dependency 'tilt', '~> 2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.4'
+  spec.add_development_dependency 'guard-rspec', '~>4.6'
+  spec.add_development_dependency 'rack-test', '~>0.6'
+  spec.add_development_dependency 'yard', '~> 0.8'
+end

data/lib/kawaii.rb

@@ -0,0 +1,17 @@
+require 'kawaii/version'
+require 'rack'
+require 'tilt'
+require 'kawaii/core_ext/hash'
+require 'kawaii/core_ext/string'
+require 'kawaii/method_chain'
+require 'kawaii/render_methods'
+require 'kawaii/matchers'
+require 'kawaii/route_mapping'
+require 'kawaii/route_handler'
+require 'kawaii/route'
+require 'kawaii/routing_methods'
+require 'kawaii/route_context'
+require 'kawaii/server_methods'
+require 'kawaii/base'
+require 'kawaii/singleton_app'
+require 'kawaii/controller'

data/lib/kawaii/base.rb

@@ -0,0 +1,48 @@
+module Kawaii
+  # Base class for all Kawaii applications. Inherit from this class to create
+  # a modular application.
+  #
+  # @example my_app.rb
+  #   require 'kawaii'
+  #   class MyApp < Kawaii::Base
+  #     get '/' do
+  #       'Hello, world'
+  #     end
+  #   end
+  #
+  # @example config.ru
+  #   require 'my_app.rb'
+  #   run MyApp
+  class Base
+    def initialize(downstream_app = nil)
+      @downstream_app = downstream_app
+    end
+
+    # Instances of classes derived from [Kawaii::Base] are Rack applications.
+    def call(env)
+      matching = self.class.match(env) || not_found
+      matching.call(env)
+    end
+
+    class << self
+      include ServerMethods
+      include RoutingMethods
+
+      # Make it runnable via `run MyApp`.
+      def call(env)
+        @app ||= new
+        @app.call(env)
+      end
+    end
+
+    protected
+
+    def not_found
+      @downstream_app || ->(_env) { text(404, 'Not found') }
+    end
+
+    def text(status, s)
+      [status, { Rack::CONTENT_TYPE => 'text/plain' }, [s]]
+    end
+  end
+end

data/lib/kawaii/controller.rb

@@ -0,0 +1,32 @@
+module Kawaii
+  # MVP controller. Define actions and map to them using regular routing
+  # functions.
+  #
+  # @example Routing to controllers
+  #  class HelloWorld < Kawaii::Controller
+  #    def index
+  #      'Hello, world'
+  #    end
+  #
+  #    def show
+  #      @id = params[:id]
+  #      render('show.html.erb')
+  #    end
+  #  end
+  #
+  #  get '/', 'hello_world#index'
+  class Controller
+    include RenderMethods
+    
+    # Parameter [Hash] accessible in actions
+    attr_reader :params
+    # Rack::Request accessible in actions
+    attr_reader :request
+
+    # Creates a controller.
+    def initialize(params, request)
+      @params = params
+      @request = request
+    end
+  end
+end

data/lib/kawaii/core_ext/hash.rb

@@ -0,0 +1,23 @@
+# Extend {Hash}.
+class Hash
+  # Transforms keys.
+  #
+  # @yield [key] gives each key to the block
+  # @yieldreturn [key] new key
+  #
+  # @return [Hash] new hash with transformed keys
+  def update_keys
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Turns string keys to symbols.
+  #
+  # @return [Hash] a new hash
+  def symbolize_keys
+    update_keys(&:to_sym)
+  end
+end

data/lib/kawaii/core_ext/string.rb

@@ -0,0 +1,6 @@
+# Extend String class.
+class String
+  def camelcase
+    gsub(/(?<=_|^)(\w)/) { Regexp.last_match[1].upcase }.gsub(/(?:_)(\w)/, '\1')
+  end
+end

data/lib/kawaii/matchers.rb

@@ -0,0 +1,135 @@
+# Route matchers.
+module Kawaii
+  # Result of matching a path.
+  class Match
+    # What is left of the actual path after {Matcher#match} consumed the
+    # matching portion.
+    attr_reader :remaining_path
+    # Hash containing params extracted from paths such as
+    # /users/:user_id/posts/:post_id
+    attr_reader :params
+
+    # Creates a new match result.
+    # @param remaining_path [String] what is left of the actual path after
+    #        {Matcher#match} consumed the matching portion
+    # @param params [Hash] params extracted from paths such as /users/:id
+    def initialize(remaining_path, params = {})
+      @remaining_path = remaining_path
+      @params = params
+    end
+  end
+
+  # @abstract Base class for a route matcher.
+  class Matcher
+    # Creates a matcher.
+    # @param path [String, Regexp, Matcher] path specification to compile
+    #        to a matcher
+    # @param options [Hash] :full_match to require the entire path to match
+    #        the resulting matcher
+    # Generated matchers by default match only the beginning of the string
+    # containing the actual path from Rack environment.
+    def self.compile(path, options = {})
+      # @todo Make it extendable?
+      matcher = if path.is_a?(String)
+                  StringMatcher.new(path)
+                elsif path.is_a?(Regexp)
+                  RegexpMatcher.new(path)
+                elsif path.is_a?(Matcher)
+                  path
+                else
+                  fail RuntimeException, "#{path} is not a supported matcher"
+                end
+      options[:full_match] ? FullMatcher.new(matcher) : matcher
+    end
+
+    # Tries to match the actual path.
+    # @param path [String] the actual path from Rack env
+    # @return {Match} if the beginning of path does match or nil if there is
+    # no match.
+    def match(_path)
+      fail NotImplementedError
+    end
+  end
+
+  # Matcher for string paths. Supports named params.
+  #
+  # @example Simple string matcher
+  #   get '/users' do ... end
+  #
+  # @example Named parameters
+  #   get '/users/:id' do ... end
+  #
+  # @example Wildcards
+  #   get '/users/?' do ... end # Optional trailing slash
+  class StringMatcher
+    # Creates a {StringMatcher}
+    # @param path [String] path specification
+    def initialize(path)
+      @rx = compile(path)
+    end
+
+    # Tries to match the actual path.
+    # @param path [String] the actual path from Rack env
+    # @return {Match} if the beginning of path does match or nil if there
+    # is no match.
+    def match(path)
+      m = path.match(@rx)
+      Match.new(remaining_path(path, m), match_to_params(m)) if m
+    end
+
+    protected
+
+    def compile(path)
+      prep_path = path.gsub('*', '.*').gsub(%r{/\:([^/]+)}, '/(?<\1>[^\/]+)')
+      Regexp.new("^#{prep_path}")
+    end
+
+    def remaining_path(path, m)
+      _, start = m.offset(0) # Whole match.
+      path[start..-1]
+    end
+
+    def match_to_params(m)
+      # In-place reduce:
+      m.names.each_with_object({}) { |n, params| params[n.to_sym] = m[n] }
+    end
+  end
+
+  # Regular expression matcher.
+  # @example Simple regular expression matcher
+  #   get /\/users.*/ do ... end
+  class RegexpMatcher
+    # Creates a {RegexpMatcher}
+    # @param path [Regexp] path specification regex
+    # @todo Support parameters based on named capture groups.
+    def initialize(rx)
+      @rx = rx
+    end
+
+    # Tries to match the actual path.
+    # @param path [String] the actual path from Rack env
+    # @return {Match} if the beginning of path does match or nil if there is
+    # no match.
+    def match(path)
+      new_path = path.gsub(@rx, '')
+      Match.new(new_path) if path != new_path
+    end
+  end
+
+  # Ensures the entire path is consumed by the wrapped {Matcher} instance.
+  class FullMatcher
+    # Creates a {FullMatcher}.
+    # @param matcher [Matcher] wrapped matcher
+    def initialize(matcher)
+      @matcher = matcher
+    end
+
+    # Tries to match the entire actual path.
+    # @param path [String] the actual path from Rack env
+    # @return {Match} if the entire path does match or nil otherwise.
+    def match(path)
+      m = @matcher.match(path)
+      m if m && m.remaining_path == ''
+    end
+  end
+end

data/lib/kawaii/method_chain.rb

@@ -0,0 +1,15 @@
+module Kawaii
+  # Allows handlers to use methods defined in outer contexts or at class scope.
+  # Set {#parent_scope} in constructor.
+  module MethodChain
+    attr_writer :parent_scope
+
+    def method_missing(meth, *args)
+      @parent_scope.send(meth, *args) if @parent_scope.respond_to?(meth)
+    end
+
+    def respond_to?(method_name, include_private = false)
+      super || @parent_scope.respond_to?(method_name, include_private)
+    end
+  end
+end