kawaii-core 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34266b059482427cf4b508d369a3a82eee1c13b9
-  data.tar.gz: a44b19872324040f54441b625dd107452e7e88af
+  metadata.gz: 4ac5408912341100edad70023e719dc15b735d92
+  data.tar.gz: 2a765e3f6108277eec769b70498b6a9fb71e7194
 SHA512:
-  metadata.gz: f608c27a33e224eee46f7a3f6d9adb3b9e5cda66c1d98847077ec80b6667b5aba4fbdcf953f685a879f1fdf33db9cdc195485fe541dfa24c4d1a18fc232ae3f8
-  data.tar.gz: 62f772e16fd0b43d6d7adfc3a038eb247a3c3100dc1999d1f6fc8abafc15be4bb714e2c8f6286c2d4c3b613493901291b76960a3bfe16fd4e1166e9ecfbbe64d
+  metadata.gz: f53adf2a8620017251471e3ef461b9af0ba93aaf0f35529be3661ceae9dacb8597f1128b0877a67d264fd615df908292a000e569705bf74e38ed274063bb5d65
+  data.tar.gz: 910405f211b29dfd8bbf6857e6bbfd982e750fbaed1f2ea797a1a8ddea257aadca61d34144cbf4454f83408d0868ce992f77ff522148a79333956055e287dc67

data/README.md

@@ -166,6 +166,27 @@ get '/' do
 end
 ```
 
+### MIME types
+
+You can use `respond_to` in a way similar to Rails in your handlers to match MIME types.
+
+Example:
+
+```ruby
+post '/users' do
+  respond_to do |format|
+    format.json do
+      { foo: 'bar' }
+    end
+    format.html do
+      'Hello, world'
+    end
+  end
+end
+```
+
+**Important:** Content negotiation is currently only based on the `Content-Type` header field of the HTTP request.
+
 ### View templates
 
 View templates must currently be stored in `views/` directory of the project using Kawaii. They can be rendered using the `render` method:

data/examples/json.ru

@@ -0,0 +1,21 @@
+require 'kawaii'
+require 'rack'
+
+class App < Kawaii::Base
+  get '/' do
+    respond_to do |format|
+      format.json { {foo: :bar} }
+      format.html { "Hello, world" }
+    end
+  end
+
+  post '/' do
+    respond_to do |format|
+      format.json { params }
+    end
+  end
+end
+
+run App
+
+

data/lib/kawaii.rb

@@ -7,6 +7,7 @@ require 'kawaii/method_chain'
 require 'kawaii/render_methods'
 require 'kawaii/matchers'
 require 'kawaii/route_mapping'
+require 'kawaii/formats'
 require 'kawaii/route_handler'
 require 'kawaii/route'
 require 'kawaii/routing_methods'

data/lib/kawaii/formats.rb

@@ -0,0 +1,185 @@
+# MIME formats.
+module Kawaii
+  # Registered formats.
+  class FormatRegistry
+    @formats = {}
+    class << self
+      attr_accessor :formats
+    end
+
+    # Registers a new format. Formats are preferred in the order they are
+    # registered; the first format has the highest priority.
+    def self.register!(format)
+      @formats[format.key] = format
+    end
+  end
+
+  # Core format-handling class.
+  class FormatHandler
+    # Creates a format handler for a route handler
+    # @param [Kawaii::RouteHandler] current route handler
+    # @return {FormatHandler}
+    def initialize(route_handler)
+      @route_handler = route_handler
+      @matches = []
+      @blocks = {}
+    end
+
+    # Matches method invoked in end-user code with {FormatBase#key}.
+    # If format matches the current request, it saves it for negotiation
+    # in {FormatHandler#response}.
+    def method_missing(meth, *_args, &block)
+      format = FormatRegistry.formats[meth]
+      return unless format && format.match?(@route_handler.request)
+      @candidates << format
+      @blocks[meth] = block
+    end
+
+    # Encoded response based on matched format (see
+    # {FormatHandler#method_missing}).
+    # @return {Array} Rack response array or nil if no format was matched
+    def response
+      format, block = find_best_match
+      return if format.nil?
+      # @note Request is mutated here!
+      new_params = format.parse_params(@route_handler.request)
+      @route_handler.params.merge!(new_params) if new_params
+      response = @route_handler.instance_exec(&block)
+      format.encode(response)
+    end
+
+    protected
+
+    def find_best_match
+      # Find matching format trying to match the first registered format
+      # then the second one and so on.
+      registered_fmts = FormatRegistry.formats
+      _, format = registered_fmts.find { |_, fmt| @candidates.include?(fmt) }
+      [format, @blocks[format.key]] if format
+    end
+  end
+
+  # @abstract Base class for MIME format handlers.
+  class FormatBase
+    # Unique key for the format and at the same time the name of the method used
+    # in end-user-code to define format handler.
+    #
+    # @example Format handler for :json key
+    #   respond_to do |format|
+    #     format.json { ... }
+    #   end
+    def key
+      fail NotImplementedError
+    end
+
+    # Returns true if the format is compatible with the request.
+    # @param _request [Rack::Request] current HTTP request
+    # @return true if there's a match.
+    def match?(_request)
+      fail NotImplementedError
+    end
+
+    # Parses params in request body in a way specific to the given format.
+    # @param _request [Rack::Request] contains information about the current
+    # HTTP request
+    # @return {Hash} including parsed params or nil
+    def parse_params(_request)
+      # Optional.
+    end
+
+    # Encodes response appropriately for the given format.
+    # @param _response [String, Hash, Array] response from format handler block.
+    # @return Rack response {Array}
+    def encode(_response)
+      fail NotImplementedError
+    end
+  end
+
+  require 'json'
+
+  # JSON MIME format (application/json).
+  class JsonFormat < FormatBase
+    # Unique key for the format and at the same time the name of the method used
+    # in end-user-code to define format handler.
+    #
+    # @example Format handler for :json key
+    #   respond_to do |format|
+    #     format.json do
+    #       { foo: 'bar' }
+    #     end
+    #   end
+    def key
+      :json
+    end
+
+    # Returns true if the format is compatible with the request.
+    # @param request [Rack::Request] current HTTP request
+    # @return true if there's a match.
+    def match?(request)
+      request.content_type =~ %r{^application/json.*}
+    end
+
+    # Parses JSON string in request body if present and converts it to a hash.
+    # @param request [Rack::Request] contains information about the current HTTP
+    #        request
+    # @return {Hash} including parsed params or nil
+    def parse_params(request)
+      json = request.body.read
+      JSON.parse(json).symbolize_keys if json.is_a?(String) && !json.empty?
+    end
+
+    # Encodes response appropriately by converting it to a JSON string.
+    # @param response [String, Hash, Array] response from format handler block.
+    # @return Rack response {Array}
+    def encode(response)
+      json = response.to_json
+      [200,
+       { Rack::CONTENT_TYPE => 'application/json',
+         Rack::CONTENT_LENGTH => json.length.to_s },
+       [json]]
+    end
+  end
+
+  # HTML MIME format.
+  class HtmlFormat < FormatBase
+    # Unique key for the format and at the same time the name of the method used
+    # in end-user-code to define format handler.
+    #
+    # @example Format handler for :html key
+    #   respond_to do |format|
+    #     format.html { 'Hello, world' }
+    #   end
+    def key
+      :html
+    end
+
+    # Always matches. This is why this format needs to be the last to
+    # be registered so more specific formats are before it.
+    def match?(_request)
+      true
+    end
+
+    # Response with text/html response.
+    # @param response [String] response from format handler block.
+    # @return Rack response {Array}
+    def encode(response)
+      [200,
+       { Rack::CONTENT_TYPE => 'text/html',
+         Rack::CONTENT_LENGTH => response.size.to_s },
+       [response]]
+    end
+  end
+
+  # Include this module to support 'respond_to'.
+  module FormatMethods
+    def respond_to(&block)
+      format_handler = FormatHandler.new(self)
+      instance_exec(format_handler, &block)
+      format_handler.response
+    end
+  end
+
+  # Register supported MIME formats.
+  FormatRegistry.register!(JsonFormat.new)
+  FormatRegistry.register!(HtmlFormat.new)
+end

data/lib/kawaii/route_handler.rb

@@ -9,6 +9,7 @@ module Kawaii
   class RouteHandler
     include MethodChain
     include RenderMethods
+    include FormatMethods
 
     # Params based on request visible in the route handler scope.
     attr_reader :params
@@ -39,7 +40,7 @@ module Kawaii
     class ResponseError < RuntimeError; end
 
     def process_response(response)
-      if response.is_a?(String)
+      if response.is_a?(String) # @todo Use HtmlFormat
         [200,
          { Rack::CONTENT_TYPE => 'text/html',
            Rack::CONTENT_LENGTH => response.size.to_s },
@@ -47,7 +48,7 @@ module Kawaii
       elsif response.is_a?(Array)
         response
       else
-        fail ResponseError, "Unsupported handler aresponse: #{response.inspect}"
+        fail ResponseError, "Unsupported handler response: #{response.inspect}"
       end
     end
   end

data/lib/kawaii/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kawaii-core
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Marcin Bilski
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-27 00:00:00.000000000 Z
+date: 2015-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -156,6 +156,7 @@ files:
 - examples/controller.ru
 - examples/hello_world.rb
 - examples/hello_world.ru
+- examples/json.ru
 - examples/modular.ru
 - examples/modular/first_app.rb
 - examples/modular/second_app.rb
@@ -168,6 +169,7 @@ files:
 - lib/kawaii/controller.rb
 - lib/kawaii/core_ext/hash.rb
 - lib/kawaii/core_ext/string.rb
+- lib/kawaii/formats.rb
 - lib/kawaii/matchers.rb
 - lib/kawaii/method_chain.rb
 - lib/kawaii/render_methods.rb
@@ -199,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: A simple web framework based on Rack