jeanine 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d88a21a82401395ddca515402a07e3155939eb0
-  data.tar.gz: e6edce8a4097864466149cf6769765332a868c76
+  metadata.gz: 605777e016821bd0a6bd5e400d84dc6c5ad1e2fd
+  data.tar.gz: 5547bdb35a9a9612f6f1d327c3fc0fa14bae5f83
 SHA512:
-  metadata.gz: 17f7d684adeefc7ec56e7244c6c53fddeafb9d037e4a1ee9aab94d8925193a39a95d0a079ba2aad85ae3f5a64b972315a7893f6ced6d07ba7e693923be9cc67e
-  data.tar.gz: 82082d64a1620c947e51aa84d9ada5701825c0525061cd930022b8ef68611338570fc64f20038a4605e48bf1d27578c668ff2923a0ef7d88bc3b55435792877d
+  metadata.gz: e83f8c437da8c145fd618d425e8e1dcf6fb223b492daab6c0ddcb8c24cea734a3d6e0a529ea67713aff2148dd88e13de0f0d5f26f397d06fc66dca7cf6c86995
+  data.tar.gz: b87de6a104f9b2b7ebd09e10a53aee551dd81b5ea9bcbadd43af7a599e472aeb76b5bb927067c5e0f05cac64286e09387ceca0966c04a02b23429f0eea703c3e

data/lib/jeanine.rb

@@ -1,15 +1,14 @@
+require 'rack'
+
 require 'forwardable'
 require 'logger'
 
 require "jeanine/version"
 require 'jeanine/core_ext'
-require 'jeanine/router'
-require 'jeanine/app'
-require 'tilt'
 
 module Jeanine
-  def self.tilt_cache
-    @title_cache ||= Tilt::Cache.new
+  def self._installed_plugins
+    @_installed_plugins ||= []
   end
 
   def self.logger
@@ -23,4 +22,7 @@ module Jeanine
   def self.router
     @router ||= Router.new
   end
+
+  autoload :Router,   'jeanine/router'
+  autoload :App,   'jeanine/app'
 end

data/lib/jeanine/app.rb

@@ -1,17 +1,35 @@
-require 'jeanine/callbacks'
 require 'jeanine/mimes'
 require 'jeanine/request'
 require 'jeanine/response'
-require 'jeanine/renderer'
 require 'jeanine/routing'
 
 module Jeanine
   class App
     include Routing::Evaluation
+
     attr_reader :request, :response
+
+    def self.plugin(name)
+      unless Jeanine._installed_plugins.include?(name)
+        unless const_defined?("Jeanine::#{name}")
+          require "jeanine/#{name.to_s.underscore}"
+        end
+        include Kernel.const_get("Jeanine::#{name}")
+        Jeanine._installed_plugins << name
+      end
+    end
+
+    def self.installed_plugins
+      Jeanine._installed_plugins
+    end
+
+    # plugin :Callbacks
+    # plugin :Rendering
+    # plugin :Rescuing
+    # plugin :Session
+
     class << self
       include Routing::DSL
-      include Callbacks
 
       alias :_new :new
       def new(*args, &block)
@@ -54,11 +72,6 @@ module Jeanine
                   end
     end
 
-    def render(*args)
-      @response.action_variables = instance_variables_cache
-      Renderer.new(@response).render(*args)
-    end
-
     def instance_variables_cache
       instance_variables.each_with_object({}) do |var, obj|
         obj[var] = instance_variable_get(var)

data/lib/jeanine/callbacks.rb

@@ -1,28 +1,106 @@
 module Jeanine
   module Callbacks
-    def _callbacks
-      @_callbacks ||= {
-          before: [],
-          after: [],
-          before_all: [],
-          after_all: []
-      }
+    def self.included(klass)
+      klass.extend InstanceMethods
+      klass.prepend EvaluationMethods
     end
 
-    def _register_callback(type, paths = [], &block)
-      if paths == []
-        _callbacks["#{type}_all".to_sym] << { block: block }
-      else
-        _callbacks[type] << { paths: paths, block: block }
+    module InstanceMethods
+      def _callbacks
+        @_callbacks ||= {
+            before: [],
+            after: [],
+            before_all: [],
+            after_all: []
+        }
+      end
+
+      def before(*paths, &block)
+        _register_callback(:before, paths, &block)
       end
-    end
 
-    def before(*paths, &block)
-      _register_callback(:before, paths, &block)
+      def after(*paths, &block)
+        _register_callback(:after, paths, &block)
+      end
+
+      private
+
+      def _register_callback(type, paths = [], &block)
+        if paths == []
+          _callbacks["#{type}_all".to_sym] << { block: block }
+        else
+          _callbacks[type] << { paths: paths, block: block }
+        end
+      end
     end
 
-    def after(*paths, &block)
-      _register_callback(:after, paths, &block)
+    module EvaluationMethods
+      def route_eval
+        before_find_route!
+        route = find_route
+
+        if route
+          before_evaluate_route!
+          result = instance_eval(&route[:block])
+          @response.write(result)
+          after_evaluate_route!
+        else
+          @response.status = 404
+        end
+        after_response!
+        @response.complete!
+      end
+
+      private
+
+      def before_find_route!
+        run_before_callbacks!(:before_all)
+      end
+
+      def before_evaluate_route!
+        run_before_callbacks!(:before)
+      end
+
+      def after_evaluate_route!
+        run_after_callbacks!(:after)
+      end
+
+      def after_response!
+        run_after_callbacks!(:after_all)
+      end
+
+      def run_before_callbacks!(type)
+        if type == :before_all
+          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
+        else
+          matching_callbacks(type) do |callback|
+            eval_callback(&callback[:block])
+          end
+        end
+      end
+
+      def run_after_callbacks!(type)
+        if type == :after_all
+          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
+        else
+          matching_callbacks(type) do |callback|
+            eval_callback(&callback[:block])
+          end
+        end
+      end
+
+      def matching_callbacks(type)
+        self.class._callbacks[type].select do |callback|
+          paths = callback[:paths]
+          if paths.detect { |path| path.match?(@request.path_info) }
+            yield callback
+          end
+        end
+      end
+
+      def eval_callback(*args, &callback)
+        instance_exec(*args, &callback)
+      end
     end
   end
 end

data/lib/jeanine/core_ext/hash.rb

@@ -5,4 +5,19 @@ class Hash
   def reverse_merge!(other_hash)
     replace(reverse_merge(other_hash))
   end
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  def deep_transform_keys!(&block)
+    keys.each do |key|
+      value = delete(key)
+      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+    end
+    self
+  end
 end

data/lib/jeanine/core_ext/string.rb

@@ -3,4 +3,11 @@ class String
     return nil if self.empty?
     self
   end
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+  end
 end

data/lib/jeanine/environment.rb

@@ -1,18 +1,16 @@
 module Broding
-  module Environment
-    def env
-      @_env ||= (ENV["RACK_ENV"].presence || "development")
-    end
+  def env
+    @_env ||= (ENV["RACK_ENV"].presence || "development")
+  end
 
-    def groups(*groups)
-      hash = groups.extract_options!
-      env = Jeanine.env
-      groups.unshift(:default, env)
-      groups.concat ENV["BRODY_GROUPS"].to_s.split(",")
-      groups.concat hash.map { |k, v| k if v.map(&:to_s).include?(env) }
-      groups.compact!
-      groups.uniq!
-      groups
-    end
+  def groups(*groups)
+    hash = groups.extract_options!
+    env = Jeanine.env
+    groups.unshift(:default, env)
+    groups.concat ENV["BRODY_GROUPS"].to_s.split(",")
+    groups.concat hash.map { |k, v| k if v.map(&:to_s).include?(env) }
+    groups.compact!
+    groups.uniq!
+    groups
   end
 end

data/lib/jeanine/mimes.rb

@@ -1,9 +1,15 @@
 module Jeanine
   class Mimes
     MimeTypeNotFound = Class.new(StandardError)
-    MIME_TYPES_INVERTED = Rack::Mime::MIME_TYPES.invert
+    MIME_TYPES_INVERTED = ::Rack::Mime::MIME_TYPES.invert
+
+    def self.loaded?
+      @loaded
+    end
 
     def self.load!
+      return if loaded?
+      @loaded = true
       register(:json, Rack::Mime::MIME_TYPES[".json"])
       register(:html, Rack::Mime::MIME_TYPES[".html"])
       register(:text, Rack::Mime::MIME_TYPES[".text"])

data/lib/jeanine/{renderer.rb → rendering.rb}

@@ -1,6 +1,15 @@
 require 'jeanine/view'
+require 'jeanine/view_paths'
 
 module Jeanine
+  def self.view_paths
+    @_view_paths ||= Set.new(["views"])
+  end
+
+  def self.tilt_cache
+    @title_cache ||= Tilt::Cache.new
+  end
+
   class Renderer
     def self._renderers
       @_renderers ||= Set.new
@@ -81,6 +90,16 @@ module Jeanine
       Thread.current[:tilt_cache] ||= Tilt::Cache.new
     end
 
+    def find_template!(template)
+      Jeanine.view_paths.to_a.each do |path|
+        template_with_path = "#{path}/#{template}"
+        if File.exist?(template_with_path)
+          return template_with_path
+        end
+      end
+      raise "Template not found in view paths. Looking for #{template} in #{Jeanine.view_paths.to_a.join(', ')}"
+    end
+
     def html(engine, template_name, options = {}, locals = {}, &block)
       locals          = options.delete(:locals) || locals || {}
       layout          = options[:layout]
@@ -94,6 +113,7 @@ module Jeanine
         unless layout.include?("layouts/")
           layout = "layouts/#{layout}"
         end
+        layout = find_template!(layout)
         options = options.merge(layout: false, scope: scope)
         catch(:layout_missing) { return html(engine, layout, options, locals) { output } }
       end
@@ -104,7 +124,8 @@ module Jeanine
       Tilt::Cache.new.fetch engine, template_name, options do
         template = Tilt[engine]
         raise "Template engine not found: #{engine}" if template.nil?
-        template.new("views/#{template_name}", options)
+        template_name = find_template!(template_name)
+        template.new(template_name, options)
       end
     end
 
@@ -127,4 +148,21 @@ module Jeanine
       text
     end
   end
+
+  module Rendering
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def render(*args)
+      @response.action_variables = instance_variables_cache
+      Renderer.new(@response).render(*args)
+    end
+
+    module ClassMethods
+      def append_view_path(path)
+        Jeanine.view_paths << path
+      end
+    end
+  end
 end

data/lib/jeanine/request.rb

@@ -1,5 +1,4 @@
 require 'rack/request'
-require 'jeanine/headers'
 
 module Jeanine
   class Request < Rack::Request
@@ -17,8 +16,8 @@ module Jeanine
       super
     end
 
-    def headers
-      @headers ||= Jeanine::Headers.new(self)
+    def params
+      super.deep_transform_keys!(&:to_sym)
     end
 
     def post?

data/lib/jeanine/rescuable.rb

@@ -0,0 +1,41 @@
+module Jeanine
+  module Rescuable
+    def self.included(base)
+      base.extend ClassMethods
+      base.prepend InstanceMethods
+    end
+
+    module InstanceMethods
+      def call(env)
+        begin
+          super
+        rescue => error
+          handler = self.class.rescue_handlers[error.class.to_s]
+          raise error unless handler
+          if handler.is_a?(Symbol)
+            @response.write(send(handler, error))
+          else
+            @response.write(instance_exec(error, &handler))
+          end
+          @response.complete!
+        end
+      end
+    end
+
+    module ClassMethods
+      def rescue_from(*exceptions, with: nil, &block)
+        exceptions.each do |exception|
+          if with
+            rescue_handlers[exception.to_s] = with
+          else
+            rescue_handlers[exception.to_s] = block
+          end
+        end
+      end
+
+      def rescue_handlers
+        @rescue_handlers ||= {}
+      end
+    end
+  end
+end

data/lib/jeanine/routing/evaluation.rb

@@ -1,20 +1,14 @@
 module Jeanine
   module Routing
     module Evaluation
-      IGNORED_INSTANCE_VARIABLES = [:@env]
       def route_eval
-        before_find_route!
         route = find_route
-
         if route
-          before_evaluate_route!
           result = instance_eval(&route[:block])
           @response.write(result)
-          after_evaluate_route!
         else
           @response.status = 404
         end
-        after_response!
         @response.complete!
       end
 
@@ -34,7 +28,7 @@ module Jeanine
         while index < matches.captures.size
           param = route[:params][index]
           @request.params[param] = matches.captures[index]
-          if index == match.captures.size
+          if index == matches.captures.size
             @request.params[param].gsub!(@request.format)
           end
           index += 1
@@ -43,54 +37,6 @@ module Jeanine
         route
       end
 
-      def before_find_route!
-        run_before_callbacks!(:before_all)
-      end
-
-      def before_evaluate_route!
-        run_before_callbacks!(:before)
-      end
-
-      def after_evaluate_route!
-        run_after_callbacks!(:after)
-      end
-
-      def after_response!
-        run_after_callbacks!(:after_all)
-      end
-
-      def run_before_callbacks!(type)
-        if type == :before_all
-          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
-        else
-          matching_callbacks(type) do |callback|
-            eval_callback(&callback[:block])
-          end
-        end
-      end
-
-      def run_after_callbacks!(type)
-        if type == :after_all
-          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
-        else
-          matching_callbacks(type) do |callback|
-            eval_callback(&callback[:block])
-          end
-        end
-      end
-
-      def matching_callbacks(type)
-        self.class._callbacks[type].select do |callback|
-          paths = callback[:paths]
-          if paths.detect { |path| path.match?(@request.path_info) }
-            yield callback
-          end
-        end
-      end
-
-      def eval_callback(*args, &callback)
-        instance_exec(*args, &callback)
-      end
     end
   end
 end

data/lib/jeanine/session.rb

@@ -0,0 +1,7 @@
+module Jeanine
+  module Session
+    def session
+      env['rack.session']
+    end
+  end
+end

data/lib/jeanine/version.rb

@@ -1,3 +1,3 @@
 module Jeanine
-  VERSION = "0.1.0"
+  VERSION = "0.6.0"
 end

data/lib/jeanine/view_paths.rb

@@ -0,0 +1,8 @@
+require 'tilt'
+
+module Jeanine
+
+  module ViewPaths
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jeanine
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Josh Brody
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-07 00:00:00.000000000 Z
+date: 2020-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -53,7 +53,49 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -85,15 +127,18 @@ files:
 - lib/jeanine/headers.rb
 - lib/jeanine/mimes.rb
 - lib/jeanine/path_proxy.rb
-- lib/jeanine/renderer.rb
+- lib/jeanine/rendering.rb
 - lib/jeanine/request.rb
+- lib/jeanine/rescuable.rb
 - lib/jeanine/response.rb
 - lib/jeanine/router.rb
 - lib/jeanine/routing.rb
 - lib/jeanine/routing/dsl.rb
 - lib/jeanine/routing/evaluation.rb
+- lib/jeanine/session.rb
 - lib/jeanine/version.rb
 - lib/jeanine/view.rb
+- lib/jeanine/view_paths.rb
 homepage: https://github.com/joshmn/jeanine
 licenses:
 - MIT