jeanine 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d62b1858b952c8c8b7575f4a5c8ff60d9401e846d6d9fe9d302573052715706c
-  data.tar.gz: fd9d260653e2164bd98fc333dedcbfedf1e58fd0f7feb33d84435406668a76df
+  metadata.gz: dab8651a092f6e68e49ce6774d3c1c3156e1cf51aed9e266a4afbc438c62c041
+  data.tar.gz: defb2a775a5ae99a7e19deca237f778a7795525339c35f6d1da2cdb917d64179
 SHA512:
-  metadata.gz: bcfb247647f312eb473cf7681b1415dd7cdd828f545711cdb5e7cf641c69127d832617e952ece9f83daf1c09e391624efc70acd7259aa3ad1d168a01b93aa135
-  data.tar.gz: 6afa5f33deb9c2a2094e317bdd5b755aa184a97c7378da944cc73968c4069d17b3e8c37b8f996efb7cd81b8af115aaed13406e45afd9bd5e1382225513c44bbc
+  metadata.gz: dfd4e2901c604b06a262da1d05a660ade74e4810ba25d4917ae1f873bf9f306213ca28b20b2a3c028f4ca5f95706e90d51566edff3bbe10c8559dec735d36377
+  data.tar.gz: 92e87f254903c370d1708fdd09dff0921e77ff3d5fa804fb424cfae86febc7aab1419bbde3665b9813c0801d89d567eb4e8e1a36cd2aba4e90531bfb9620d354

data/lib/jeanine.rb

@@ -1,18 +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.view_paths
-    @_view_paths ||= Set.new(["views"])
-  end
-  def self.tilt_cache
-    @title_cache ||= Tilt::Cache.new
+  def self._installed_plugins
+    @_installed_plugins ||= []
   end
 
   def self.logger
@@ -26,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,26 +1,35 @@
-require 'jeanine/callbacks'
 require 'jeanine/mimes'
 require 'jeanine/request'
-require 'jeanine/rescuing'
 require 'jeanine/response'
-require 'jeanine/renderer'
 require 'jeanine/routing'
-require 'jeanine/session'
-require 'jeanine/view_paths'
 
 module Jeanine
   class App
-    include Session
-    include Rescuing
     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 Callbacks
       include Routing::DSL
-      include Rescuing
-      include ViewPaths
 
       alias :_new :new
       def new(*args, &block)
@@ -47,21 +56,10 @@ module Jeanine
     end
 
     def call(env)
-      begin
-        @env = env
-        @request = Jeanine::Request.new(env)
-        @response = Jeanine::Response.new
-        catch(:halt) { route_eval }
-      rescue => error
-        handler = self.class.rescue_handlers[error.class]
-        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
+      @env = env
+      @request = Jeanine::Request.new(env)
+      @response = Jeanine::Response.new
+      catch(:halt) { route_eval }
     end
 
     private
@@ -74,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,105 @@
 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 before(*paths, &block)
-      _register_callback(:before, paths, &block)
-    end
+    module InstanceMethods
+      def _callbacks
+        @_callbacks ||= {
+            before: [],
+            after: [],
+            before_all: [],
+            after_all: []
+        }
+      end
+
+      def before(*paths, &block)
+        _register_callback(:before, paths, &block)
+      end
+
+      def after(*paths, &block)
+        _register_callback(:after, paths, &block)
+      end
+
+      private
 
-    def after(*paths, &block)
-      _register_callback(:after, paths, &block)
+      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
 
-    private
-    def _register_callback(type, paths = [], &block)
-      if paths == []
-        _callbacks["#{type}_all".to_sym] << { block: block }
-      else
-        _callbacks[type] << { paths: paths, block: 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

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,11 +1,15 @@
-require 'rack'
-
 module Jeanine
   class Mimes
     MimeTypeNotFound = Class.new(StandardError)
     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
@@ -139,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,10 +16,6 @@ module Jeanine
       super
     end
 
-    def headers
-      @headers ||= Jeanine::Headers.new(self)
-    end
-
     def post?
       request_method == 'POST'
     end

data/lib/jeanine/rescuing.rb

@@ -1,17 +1,41 @@
 module Jeanine
   module Rescuing
-    def rescue_from(*exceptions, with: nil, &block)
-      exceptions.each do |exception|
-        if with
-          rescue_handlers[exception] = with
-        else
-          rescue_handlers[exception] = block
+    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
 
-    def rescue_handlers
-      @rescue_handlers ||= {}
+    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

@@ -2,18 +2,13 @@ module Jeanine
   module Routing
     module Evaluation
       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
 
@@ -42,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/version.rb

@@ -1,3 +1,3 @@
 module Jeanine
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/jeanine/view_paths.rb

@@ -1,7 +1,8 @@
+require 'tilt'
+
 module Jeanine
+
   module ViewPaths
-    def append_view_path(path)
-      Jeanine.view_paths << path
-    end
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jeanine
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Josh Brody
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
 description: A framework.
 email:
 - git@josh.mn
@@ -113,7 +127,7 @@ 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/rescuing.rb
 - lib/jeanine/response.rb