tynn 2.0.0.beta3 → 2.0.0.beta4

data/lib/tynn.rb

@@ -1,57 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "tynn/base"
+require "rack"
+require "seg"
+require_relative "tynn/request"
+require_relative "tynn/response"
+require_relative "tynn/utils"
 require_relative "tynn/version"
 
 class Tynn
-  # Loads given <tt>plugin</tt> into the application.
-  #
-  # [plugin]
-  #   A module that can contain a <tt>ClassMethods</tt> or <tt>InstanceMethods</tt>
-  #   module to extend Tynn. If <tt>plugin</tt> responds to <tt>setup</tt>, it will
-  #   be called last, and should be used to set up the plugin.
-  #
-  # [*args]
-  #   A list of arguments passed to <tt>plugin#setup</tt>.
-  #
-  # [&block]
-  #   A block passed to <tt>plugin#setup</tt>.
-  #
-  # <tt></tt>
-  #
-  #   # Using default plugins
-  #   require "tynn"
-  #   require "tynn/environment"
-  #   require "tynn/static"
-  #
-  #   Tynn.plugin(Tynn::Environment)
-  #   Tynn.plugin(Tynn::Static, %(/css /js /images))
-  #
-  #   # Using a custom plugin
-  #   class MyAppNamePlugin
-  #     def self.setup(app, name, &block)
-  #       app.app_name = name
-  #     end
-  #
-  #     module ClassMethods
-  #       def app_name
-  #         @app_name
-  #       end
-  #
-  #       def app_name=(name)
-  #         @app_name = name
-  #       end
-  #     end
-  #
-  #     module InstanceMethods
-  #       def app_name
-  #         self.class.app_name
-  #       end
-  #     end
-  #   end
-  #
-  #   Tynn.plugin(MyAppNamePlugin, "MyApp")
-  #
   def self.plugin(plugin, *args, &block)
     if defined?(plugin::InstanceMethods)
       include(plugin::InstanceMethods)
@@ -66,5 +22,185 @@ class Tynn
     end
   end
 
-  plugin(Tynn::Base)
+  module ClassMethods
+    def define(&block)
+      build_app { |env| new(block).call(env) }
+
+      app.freeze
+
+      middleware.freeze
+
+      Tynn::Utils.deep_freeze!(settings)
+    end
+
+    def build_app(&block)
+      @app = middleware.reverse.inject(block) { |a, e| e.call(a) }
+    end
+
+    def use(middleware, *args, &block)
+      if self.middleware.frozen?
+        Tynn::Utils.raise_error("Application middleware is frozen")
+      else
+        self.middleware.push(proc { |app| middleware.new(app, *args, &block) })
+      end
+    end
+
+    def middleware
+      @middleware ||= []
+    end
+
+    def call(env)
+      app.call(env)
+    end
+
+    def app
+      (defined?(@app) && @app) or
+        Tynn::Utils.raise_error("Application handler is missing")
+    end
+
+    def inherited(subclass)
+      subclass.instance_variable_set(:@settings, Tynn::Utils.deep_dup(settings))
+    end
+
+    def settings
+      @settings ||= {}
+    end
+
+    def set(option, value)
+      v = settings[option]
+
+      if Hash === v
+        value = v.merge(value)
+      end
+
+      set!(option, value)
+    end
+
+    def set!(option, value)
+      settings[option] = value
+    end
+
+    def default_headers
+      settings.fetch(:default_headers, {})
+    end
+  end
+
+  # Copyright (c)      2016 Francesco Rodriguez
+  # Copyright (c) 2015-2016 Michel Martens (Portions of https://github.com/soveran/syro)
+  #
+  # Permission is hereby granted, free of charge, to any person obtaining a copy
+  # of this software and associated documentation files (the "Software"), to deal
+  # in the Software without restriction, including without limitation the rights
+  # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  # copies of the Software, and to permit persons to whom the Software is
+  # furnished to do so, subject to the following conditions:
+  #
+  # The above copyright notice and this permission notice shall be included in
+  # all copies or substantial portions of the Software.
+  #
+  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  # THE SOFTWARE.
+
+  module InstanceMethods
+    def initialize(code)
+      @__code = code
+      @__captures = []
+    end
+
+    def call(env)
+      @__env = env
+      @__req = Tynn::Request.new(env)
+      @__res = Tynn::Response.new(nil, Hash[self.class.default_headers])
+      @__seg = ::Seg.new(env["PATH_INFO"])
+
+      catch(:halt) do
+        instance_eval(&@__code)
+
+        @__res.finish
+      end
+    end
+
+    def req
+      @__req
+    end
+
+    def res
+      @__res
+    end
+
+    def on(arg)
+      captures.clear
+
+      if match(arg)
+        yield(*captures)
+      end
+    end
+
+    private def match(arg)
+      case arg
+      when String then @__seg.consume(arg)
+      when Symbol then @__seg.capture(0, captures)
+      when Proc   then arg.call
+      when true   then true
+      else false
+      end
+    end
+
+    private def captures
+      @__captures
+    end
+
+    def halt(response)
+      throw(:halt, response)
+    end
+
+    def run(app, vars = nil)
+      path, script = @__env["PATH_INFO"], @__env["SCRIPT_NAME"]
+
+      @__env["PATH_INFO"] = @__seg.curr
+      @__env["SCRIPT_NAME"] = @__seg.prev
+
+      @__env.delete("tynn.vars")
+      @__env["tynn.vars"] = vars if vars
+
+      halt(app.call(@__env))
+    ensure
+      @__env["PATH_INFO"], @__env["SCRIPT_NAME"] = path, script
+    end
+
+    def vars
+      @__env.fetch("tynn.vars", {})
+    end
+
+    def get
+      root? && req.get?
+    end
+
+    def post
+      root? && req.post?
+    end
+
+    def patch
+      root? && req.patch?
+    end
+
+    def put
+      root? && req.put?
+    end
+
+    def delete
+      root? && req.delete?
+    end
+
+    def root?
+      @__seg.root?
+    end
+  end
+
+  plugin(self)
 end

data/lib/tynn/environment.rb

@@ -1,115 +1,32 @@
 # frozen_string_literal: true
 
 class Tynn
-  # Adds helper methods to get and check the current environment.
-  # By default, the environment is based on <tt>ENV["RACK_ENV"]</tt>.
-  #
-  #   require "tynn"
-  #   require "tynn/environment"
-  #
-  #   Tynn.plugin(Tynn::Environment)
-  #
-  #   # Accessing the current environment.
-  #   Tynn.environment  # => :development
-  #
-  #   # Checking the current environment.
-  #   Tynn.development? # => true
-  #   Tynn.production?  # => false
-  #   Tynn.test?        # => false
-  #   Tynn.staging?     # => false
-  #
-  #   # Changing the current environment.
-  #   Tynn.set(:environment, :test)
-  #
-  #   # Performing operations in specific environments.
-  #   Tynn.configure(:development, :test) do
-  #     # ...
-  #   end
-  #
   module Environment
-    def self.setup(app, env: ENV["RACK_ENV"]) # :nodoc:
+    def self.setup(app, env: ENV["RACK_ENV"])
       app.set(:environment, (env || :development).to_sym)
     end
 
     module ClassMethods
-      # Yields if current environment matches one of the given environments.
-      #
-      #   class MyApp < Tynn
-      #     configure(:development, :staging) do
-      #       use(BetterErrors::Middleware)
-      #     end
-      #
-      #     configure(:production) do
-      #       plugin(Tynn::SSL)
-      #     end
-      #   end
-      #
       def configure(*envs)
         yield(self) if envs.include?(environment)
       end
 
-      # Returns the current environment for the application.
-      #
-      #   Tynn.environment
-      #   # => :development
-      #
-      #   Tynn.set(environment, :test)
-      #
-      #   Tynn.environment
-      #   # => :test
-      #
       def environment
         settings[:environment]
       end
 
-      # Checks if current environment is development. Returns <tt>true</tt> if
-      # <tt>environment</tt> is <tt>:development</tt>. Otherwise, <tt>false</tt>.
-      #
-      #   Tynn.set(:environment, :test)
-      #   Tynn.development? # => false
-      #
-      #   Tynn.set(:environment, :development)
-      #   Tynn.development? # => true
-      #
       def development?
         environment == :development
       end
 
-      # Checks if current environment is test. Returns <tt>true</tt> if
-      # <tt>environment</tt> is <tt>:test</tt>. Otherwise, <tt>false</tt>.
-      #
-      #   Tynn.set(:environment, :development)
-      #   Tynn.test? # => false
-      #
-      #   Tynn.set(:environment, :test)
-      #   Tynn.test? # => true
-      #
       def test?
         environment == :test
       end
 
-      # Checks if current environment is production. Returns <tt>true</tt> if
-      # <tt>environment</tt> is <tt>:production</tt>. Otherwise, <tt>false</tt>.
-      #
-      #   Tynn.set(:environment, :development)
-      #   Tynn.production? # => false
-      #
-      #   Tynn.set(:environment, :production)
-      #   Tynn.production? # => true
-      #
       def production?
         environment == :production
       end
 
-      # Checks if current environment is staging. Returns <tt>true</tt> if
-      # <tt>environment</tt> is <tt>:staging</tt>. Otherwise, <tt>false</tt>.
-      #
-      #   Tynn.set(environment, :test)
-      #   Tynn.staging? # => false
-      #
-      #   Tynn.set(:environment, :staging)
-      #   Tynn.staging? # => true
-      #
       def staging?
         environment == :staging
       end

data/lib/tynn/json.rb

@@ -3,39 +3,38 @@
 require "json"
 
 class Tynn
-  # Adds helper methods for JSON generation.
-  #
-  #   require "tynn"
-  #   require "tynn/json"
-  #
-  #   Tynn.plugin(Tynn::JSON)
-  #
   module JSON
-    def self.setup(app, options = {}) # :nodoc:
+    def self.setup(app, options = {})
       app.set(:json, {
-        content_type: "application/json"
+        content_type: "application/json",
+        on_parse_error: proc { halt([400, {}, []]) },
+        read_opts: { create_additions: false },
+        write_opts: {}
       }.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>.
-      #
-      #   Tynn.define do
-      #     on "hash" do
-      #       json(foo: "bar")
-      #     end
-      #
-      #     on "array" do
-      #       json([1, 2, 3])
-      #     end
-      #   end
-      #
-      def json(data)
+      def json_params
+        @__json_params ||= ::JSON.parse(req.body.read, json_opts[:read_opts])
+      rescue ::JSON::ParserError
+        rescue_json_parse_error
+      ensure
+        req.body.rewind
+      end
+
+      def rescue_json_parse_error
+        case (rescuer = json_opts[:on_parse_error])
+        when Symbol then send(rescuer)
+        when Proc   then instance_eval(&rescuer)
+        end
+      end
+
+      private :rescue_json_parse_error
+
+      def json(data, opts = json_opts[:write_opts])
         res.content_type = json_opts[:content_type]
 
-        res.write(::JSON.generate(data))
+        res.write(data.to_json(opts))
       end
 
       private

data/lib/tynn/render.rb

@@ -1,67 +1,106 @@
 # frozen_string_literal: true
 
-require "tilt"
+require_relative "utils"
 
 class Tynn
   module Render
-    def self.setup(app, options = {}) # :nodoc:
+    def self.setup(app, options = {})
       app.set(:render, {
         content_type: "text/html",
-        engine: "erb",
-        engine_opts: { escape_html: true },
         layout: "layout",
         root: Dir.pwd,
         views: "views"
       }.merge(options))
     end
 
+    # Copyright (c)      2016 Francesco Rodriguez
+    # Copyright (c) 2011-2016 Michel Martens (https://github.com/soveran/mote)
+    #
+    # Permission is hereby granted, free of charge, to any person obtaining a copy
+    # of this software and associated documentation files (the "Software"), to deal
+    # in the Software without restriction, including without limitation the rights
+    # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    # copies of the Software, and to permit persons to whom the Software is
+    # furnished to do so, subject to the following conditions:
+    #
+    # The above copyright notice and this permission notice shall be included in
+    # all copies or substantial portions of the Software.
+    #
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    # THE SOFTWARE.
+
+    module Engine
+      PATTERN = /(<%)\s+(.*?)\s+%>(?:\n)|(<%==?)(.*?)%>/m
+
+      module_function
+
+      def parse(file, vars, context = self)
+        terms = File.read(file).split(PATTERN)
+        parts = "proc do |locals = {}, __o = ''|\n".dup
+
+        while var = vars.shift
+          parts << sprintf("%s = locals[%p]\n", var, var)
+        end
+
+        while term = terms.shift
+          parts << parse_expression(terms, term)
+        end
+
+        parts << "__o; end"
+
+        context.instance_eval(parts, file, -(vars.size.succ))
+      end
+
+      def parse_expression(terms, term)
+        case term
+        when "<%"   then terms.shift << "\n"
+        when "<%="  then "__o << Tynn::Utils.h((" + terms.shift << ").to_s)\n"
+        when "<%==" then "__o << (" + terms.shift << ").to_s\n"
+        else             "__o << " + term.dump << "\n"
+        end
+      end
+    end
+
     module InstanceMethods
-      # 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))
+      def render(template, content_type: nil, layout: render_layout, locals: {})
+        res.content_type = content_type || render_opts[:content_type]
+        res.write(view(template, layout: layout, locals: locals))
       end
 
-      # 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)))
+      def view(template, layout: render_layout, locals: {})
+        partial(layout, locals: locals.merge(content: partial(template, locals: 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.merge(app: self), render_opts[:engine_opts])
+      def partial(template, locals: {})
+        render_file(template_path(template), locals.merge(app: self))
       end
 
       private
 
       def template_path(template)
-        File.join(views_path, "#{ template }.#{ render_opts[:engine] }")
+        File.join(views_path, "#{ template }.erb")
       end
 
       def views_path
         File.expand_path(render_opts[:views], render_opts[:root])
       end
 
-      def tilt(file, locals = {}, opts = {})
-        tilt_cache.fetch(file) { Tilt.new(file, 1, opts) }.render(self, locals)
+      def render_file(file, locals)
+        render_cache[file] ||= Engine.parse(file, locals.keys, TOPLEVEL_BINDING)
+        render_cache[file].call(locals)
+      end
+
+      def render_cache
+        Thread.current[:render_cache] ||= {}
       end
 
-      def tilt_cache
-        Thread.current[:tilt_cache] ||= Tilt::Cache.new
+      def render_layout
+        render_opts[:layout]
       end
 
       def render_opts