tynn 2.0.0.alpha → 2.0.0.beta1

data/lib/tynn/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Tynn
+  # Generic Tynn exception class.
+  class Error < StandardError
+  end
+end

data/lib/tynn/json.rb

@@ -11,25 +11,38 @@ class Tynn
   #   Tynn.plugin(Tynn::JSON)
   #
   module JSON
+    def self.setup(app, options = {}) # :nodoc:
+      app.set(:json, {
+        content_type: "application/json"
+      }.merge(options))
+    end
+
     module InstanceMethods
-      # Generates a JSON document from <tt>data</tt> and writes it to the response body.
-      # It automatically sets the <tt>Content-Type</tt> header to <tt>application/json</tt>.
+      # Generates a JSON document from <tt>data</tt> and writes it to the
+      # response body. It automatically sets the <tt>Content-Type</tt> header
+      # to <tt>application/json</tt>.
       #
       #   Tynn.define do
-      #     on("hash") do
+      #     on "hash" do
       #       json(foo: "bar")
       #     end
       #
-      #     on("array") do
+      #     on "array" do
       #       json([1, 2, 3])
       #     end
       #   end
       #
       def json(data)
-        res.headers["Content-Type"] = "application/json"
+        res.content_type = json_opts[:content_type]
 
         res.write(::JSON.generate(data))
       end
+
+      private
+
+      def json_opts
+        self.class.settings[:json]
+      end
     end
   end
 end

data/lib/tynn/render.rb

@@ -1,52 +1,63 @@
 # frozen_string_literal: true
 
-require "tilt"
+require "hmote"
 
 class Tynn
   module Render
     def self.setup(app, options = {}) # :nodoc:
       app.set(:render, {
-        layout: options.fetch(:layout, "layout"),
-        views: options.fetch(:views, File.expand_path("views", Dir.pwd)),
-        engine: options.fetch(:engine, "erb"),
-        engine_opts: {
-          escape_html: true
-        }.merge(options.fetch(:options, {}))
-      })
+        content_type: "text/html",
+        layout: "layout",
+        root: Dir.pwd,
+        views: "views"
+      }.merge(options))
     end
 
     module InstanceMethods
-      def render(template, locals = {}, layout = self.class.settings.dig(:render, :layout))
-        res.headers[Rack::CONTENT_TYPE] ||= Syro::Response::DEFAULT
+      include ::HMote::Helpers
 
-        res.write(view(template, locals, layout))
+      # Renders <tt>template</tt> within the default layout. An optional hash of
+      # local variables can be passed to make available inside the template. It
+      # automatically sets the <tt>Content-Type</tt> header to <tt>"text/html"</tt>.
+      #
+      #   render("about", title: "About", name: "John Doe")
+      #
+      def render(template, locals = {})
+        res.content_type = render_opts[:content_type]
+
+        res.write(view(template, locals))
       end
 
-      def view(template, locals = {}, layout = self.class.settings.dig(:render, :layout))
-        partial(layout, locals.merge(content: partial(template, locals)))
+      # Renders <tt>template</tt> within the default layout. An optional hash of
+      # local variables can be passed to make available inside the template.
+      #
+      #   res.write(view("about", title: "About", name: "John Doe"))
+      #
+      def view(template, locals = {})
+        partial(render_opts[:layout], locals.merge(content: partial(template, locals)))
       end
 
+      # Renders <tt>template</tt> without a layout. An optional hash of local
+      # variables can be passed to make available inside the template.
+      #
+      #   res.write(partial("about", name: "John Doe"))
+      #
       def partial(template, locals = {})
-        tilt(template_path(template), locals, self.class.settings.dig(:render, :engine_opts))
+        hmote(template_path(template), locals.merge(app: self), TOPLEVEL_BINDING)
       end
 
       private
 
-      def tilt(file, locals = {}, opts = {})
-        tilt_cache.fetch(file) {
-          Tilt.new(file, 1, opts)
-        }.render(self, locals.merge(app: self))
+      def template_path(template)
+        File.join(views_path, "#{ template }.mote")
       end
 
-      def tilt_cache
-        Thread.current[:tilt_cache] ||= Tilt::Cache.new
+      def views_path
+        File.expand_path(render_opts[:views], render_opts[:root])
       end
 
-      def template_path(template)
-        dir = self.class.settings.dig(:render, :views)
-        ext = self.class.settings.dig(:render, :engine)
-
-        File.join(dir, "#{ template }.#{ ext }")
+      def render_opts
+        self.class.settings[:render]
       end
     end
   end

data/lib/tynn/request.rb

@@ -5,18 +5,55 @@ class Tynn
   #
   #   env = {
   #     "REQUEST_METHOD" => "GET",
-  #     "QUERY_STRING"   => "email=me@tynn.xyz"
+  #     "QUERY_STRING"   => "q=great",
+  #     # ...
   #   }
   #
   #   req = Tynn::Request.new(env)
   #
-  #   req.get?  # => true
-  #   req.post? # => false
-  #   req.params  # => { "email" => "me@tynn.xyz" }
+  #   req.get?   # => true
+  #   req.path   # => "/search"
+  #   req.params # => { "q" => "great" }
   #
   class Request < Rack::Request
+    # Returns the content length of the request as an integer.
+    #
+    #   req.headers["content-length"]
+    #   # => "20"
+    #
+    #   req.content_length
+    #   # => 20
+    #
+    def content_length
+      super.to_i
+    end
+
+    # Provides access to the request's HTTP headers.
+    #
+    #   req.headers["content-type"] # => "application/json"
+    #   req.headers.fetch("host")   # => "example.org"
+    #   req.headers.key?("https")   # => true
+    #
+    def headers
+      @headers ||= Headers.new(env)
+    end
+
+    # Provides a uniform way to access HTTP headers from the request.
+    #
+    #   headers = Tynn::Request::Headers.new(
+    #     "CONTENT_TYPE" => "appplication/json"
+    #     "HTTP_HOST" => "example.org"
+    #     "HTTPS" => "on"
+    #   )
+    #
+    #   headers["content-type"] # => "application/json"
+    #   headers.fetch("host")   # => "example.org"
+    #   headers.key?("https")   # => true
+    #
+    # This helper class is used by Tynn::Request#headers.
+    #
     class Headers
-      CGI_VARIABLES = Set.new(%w(
+      CGI_VARIABLES = %w(
         AUTH_TYPE
         CONTENT_LENGTH
         CONTENT_TYPE
@@ -35,22 +72,60 @@ class Tynn
         SERVER_PORT
         SERVER_PROTOCOL
         SERVER_SOFTWARE
-      )).freeze
+      ).freeze # :nodoc:
 
-      def initialize(req)
-        @req = req
+      def initialize(env) # :nodoc:
+        @env = env
       end
 
+      # Returns the value for the given <tt>key</tt> mapped
+      # to the request environment (<tt>req.env</tt>).
+      #
+      #   req.headers["content-type"]
+      #   # => "application/json"
+      #
+      #   req.headers["host"]
+      #   # => "127.0.0.1"
+      #
       def [](key)
-        @req.env[transform_key(key)]
+        @env[transform_key(key)]
       end
 
+      # Returns the value for the given <tt>key</tt> mapped
+      # to the request environment. If the key is not found
+      # and a optional argument or code block is not provided,
+      # raises a <tt>KeyError</tt> exception. If an optional
+      # argument is provided, then it returns its value. If
+      # a code block is provided, then it will be run and its
+      # result returned.
+      #
+      #   req.headers.fetch("content-type")
+      #   # => "application/json"
+      #
+      #   req.headers.fetch("https")
+      #   # => KeyError: key not found: "HTTPS"
+      #
+      #   req.headers.fetch("https", "")
+      #   # => ""
+      #
+      #   req.headers.fetch("https") { req.headers["x_forwarded_ssl"] }
+      #   # => "on"
+      #
       def fetch(key, *args, &block)
-        @req.env.fetch(transform_key(key), *args, &block)
+        @env.fetch(transform_key(key), *args, &block)
       end
 
+      # Returns <tt>true</tt> if the given <tt>key</tt> exists in the
+      # request environment. Otherwise, returns <tt>false</tt>.
+      #
+      #   req.headers.key?("content-type")
+      #   # => true
+      #
+      #   req.headers.key?("https")
+      #   # => false
+      #
       def key?(key)
-        @req.env.key?(transform_key(key))
+        @env.key?(transform_key(key))
       end
 
       private
@@ -61,9 +136,5 @@ class Tynn
         key
       end
     end
-
-    def headers
-      @headers ||= Headers.new(self)
-    end
   end
 end

data/lib/tynn/response.rb

@@ -6,20 +6,220 @@ class Tynn
   #   res = Tynn::Response.new
   #
   #   res.status = 200
-  #   res["Content-Type"] = "text/html"
-  #   res.write("foo")
+  #   res.headers["Content-Type"] = "text/plain"
+  #   res.write("hei!")
   #
   #   res.finish
-  #   # => [200, { "Content-Type" => "text/html", "Content-Length" => 3 }, ["foo"]]
+  #   # => [200, { "Content-Type" => "text/plain", "Content-Length" => 4 }, ["hei!"]]
   #
-  class Response < Syro::Response
-    # Sets a cookie into the response.
+  class Response
+    # Initializes a new response object. An optional hash of HTTP headers can be
+    # passed.
+    #
+    #   res = Tynn::Response.new("Content-Type" => "text/plain")
+    #
+    #   res.write("hei!")
+    #
+    #   res.finish
+    #   # => [200, { "Content-Type" => "text/plain", "Content-Length" => "4" }, ["hei!"]]
+    #
+    def initialize(headers = {})
+      @status = nil
+      @headers = headers
+      @body = []
+      @length = 0
+    end
+
+    # Returns the status of the response.
+    #
+    #   res.status # => 200
+    #
+    def status
+      @status
+    end
+
+    # Sets the status of the response.
+    #
+    #   res.status = 200
+    #
+    def status=(status)
+      @status = status.to_i
+    end
+
+    # Returns a hash with the response headers.
+    #
+    #   res.headers
+    #   # => { "Content-Type" => "text/html", "Content-Length" => "42" }
+    #
+    def headers
+      @headers
+    end
+
+    # Returns the body of the response.
+    #
+    #   res.body
+    #   # => []
+    #
+    #   res.write("there is")
+    #   res.write("no try")
+    #
+    #   res.body
+    #   # => ["there is", "no try"]
+    #
+    def body
+      @body
+    end
+
+    # Returns response <tt>Content-Length</tt> header as an integer. If it
+    # is not present, it returns <tt>nil</tt>.
+    #
+    #   res.headers["Content-Length"] # => "42"
+    #   res.content_length            # => 42
+    #
+    def content_length
+      (c = @headers["Content-Length"]) ? c.to_i : c
+    end
+
+    # Returns response <tt>Content-Type</tt> header.
+    #
+    #   res.content_type = "text/html"
+    #   res.content_type # => "text/html"
+    #
+    def content_type
+      @headers["Content-Type"]
+    end
+
+    # Sets response <tt>Content-Type</tt> header to <tt>type</tt>.
+    #
+    #   res.content_type = "text/html"
+    #   res.content_type # => "text/html"
+    #
+    def content_type=(type)
+      @headers["Content-Type"] = type
+    end
+
+    # Returns response <tt>Location</tt> header.
+    #
+    #   res.location = "/users"
+    #   res.location # => "/users"
+    #
+    def location
+      @headers["Location"]
+    end
+
+    # Sets response <tt>Location</tt> header to <tt>url</tt>.
+    #
+    #   res.content_type = "text/html"
+    #   res.content_type # => "text/html"
+    #
+    def location=(url)
+      @headers["Location"] = url
+    end
+
+    # Appends <tt>str</tt> to the response body and updates the
+    # <tt>Content-Length</tt> header.
+    #
+    #   res.body # => []
+    #
+    #   res.write("foo")
+    #   res.write("bar")
+    #
+    #   res.body
+    #   # => ["foo", "bar"]
+    #
+    #   res.headers["Content-Length"]
+    #   # => 6
+    #
+    def write(str)
+      s = str.to_s
+
+      @length += s.bytesize
+
+      @headers["Content-Length"] = @length.to_s
+
+      @body << s
+
+      nil
+    end
+
+    # Returns an Array with three elements: the status, headers and body.
+    # If the status is not set, the status is set to <tt>404</tt> if empty body,
+    # otherwise the status is set to <tt>200</tt>.
+    #
+    #   res.status = 200
+    #   res.finish
+    #   # => [200, {}, []]
+    #
+    #   res.status = nil
+    #   res.finish
+    #   # => [404, {}, []]
+    #
+    #   res.status = nil
+    #   res.content_type = "text/html"
+    #   res.write("hei!")
+    #   res.finish
+    #   # => [200, { "Content-Type" => "text/html", "Content-Length" => "4" }, ["hei!"]]
+    #
+    def finish
+      @status ||= ((@body.empty?) ? 404 : 200)
+
+      [@status, @headers, @body]
+    end
+
+    # Sets the <tt>Location</tt> header to <tt>url</tt> and updates the status
+    # to <tt>status</tt>. By default, <tt>status</tt> is <tt>302</tt>.
+    #
+    #   res.redirect("/path")
+    #
+    #   res.status   # => 302
+    #   res.location # => "/path"
+    #
+    #   res.redirect("https://google.com", 303)
+    #
+    #   res.status   # => 303
+    #   res.location # => "https://google.com"
+    #
+    def redirect(path, status = 302)
+      self.status = status
+      self.location = path
+    end
+
+    # Sets a cookie into the response. The following options are supported:
+    #
+    # [domain and path]
+    #   Define the scope of the cookie. They tell the browser what website
+    #   the cookie belongs to. If a cookie's domain and path are not specified,
+    #   they default to the domain and path of the resource that was requested.
+    #
+    # [expires]
+    #   Defines a specific date and time for when the browser should delete
+    #   the cookie.
+    #
+    # [max_age]
+    #   Sets the cookie’s expiration as an interval of seconds in the future,
+    #   relative to the time the browser received the cookie.
+    #
+    # [httponly]
+    #   If <tt>true</tt>, sets the <tt>HttpOnly</tt> flag. This mitigates the
+    #   risk of client side scripting accessing the cookie.
+    #
+    # [secure]
+    #   If <tt>true</tt>, sets the <tt>Secure</tt> flag. This tells the browser
+    #   to only transmit the cookie over HTTPS.
+    #
+    # [same_site]
+    #   Disables third-party usage for cookies. There are two possible values
+    #   <tt>:Lax</tt> and <tt>:Strict</tt>. In <tt>Strict</tt> mode, the cookie
+    #   is restrain to any cross-site usage; in <tt>Lax</tt> mode, some cross-site
+    #   usage is allowed.
+    #
+    # <tt></tt>
     #
     #   res.set_cookie("foo", "bar")
-    #   res["Set-Cookie"] # => "foo=bar"
+    #   res.headers["Set-Cookie"] # => "foo=bar"
     #
     #   res.set_cookie("foo2", "bar2")
-    #   res["Set-Cookie"] # => "foo=bar\nfoo2=bar2"
+    #   res.headers["Set-Cookie"] # => "foo=bar\nfoo2=bar2"
     #
     #   res.set_cookie("bar", "bar", {
     #     domain: ".example.com",
@@ -31,8 +231,8 @@ class Tynn
     #     same_site: :Lax
     #   })
     #
-    #   res["Set-Cookie"].split("\n").last
-    #   # => "bar=bar; domain=.example.com; path=/; secure; HttpOnly; SameSite=Lax
+    #   res.headers["Set-Cookie"].split("\n").last
+    #   # => "bar=bar; domain=.example.com; path=/; secure; HttpOnly; SameSite=Lax"
     #
     # *NOTE.* This method doesn't sign and/or encrypt the value of the cookie.
     #
@@ -43,15 +243,17 @@ class Tynn
     # Deletes cookie by <tt>key</tt>.
     #
     #   res.set_cookie("foo", "bar")
-    #   res["Set-Cookie"]
+    #   res.headers["Set-Cookie"]
     #   # => "foo=bar"
     #
     #   res.delete_cookie("foo")
-    #   res["Set-Cookie"]
+    #   res.headers["Set-Cookie"]
     #   # => "foo=; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000"
     #
+    # Check #set_cookie for supported options.
+    #
     def delete_cookie(key, options = {})
-      Rack::Utils.delete_cookie_header!(headers, options)
+      Rack::Utils.delete_cookie_header!(headers, key, options)
     end
   end
 end