jeanine 0.2.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9120ffa8994858a7560330fa0afbe1bf18e2f94
-  data.tar.gz: fd326e260cc8c90a5b70b8b8ad4a1cd5b0b9869a
+  metadata.gz: d3df31123e22ecf9f1dd465af168aa34b3199e75
+  data.tar.gz: 9fb4883db99cbf0a30b4895064bcb10f00896c6c
 SHA512:
-  metadata.gz: 8b11b5b73abed4a7df44caf5a7b53ad6d2d52616fc23658e8c0d864239c0dc7b3fdfb6837c6d611f593944ad2518d92cc9af945ec3185a7bdfd783f913c3309c
-  data.tar.gz: 2ca9b7d2196c08e57bda6f983cfb0a1da71c06772bb6b42b76deb0aa941d5cb454eef4041d9834f8b3eeea9644d5a86b22e48de5f6b951a32e39481d9ac631a4
+  metadata.gz: e871411c10b283ab9ad26c5b568870e651dc25110cb1e5ea842e607dfe1d3d28dfac640bb574cfe19ee0bb01575668e1906fdbd2c9d5304e0c85a75977d3bfd4
+  data.tar.gz: 214f87e732bbfa864f5b64574c27b4a284c260c7447dc867af01a94da52edac49308d427da84c19846b8c540a2309ab3d81117b99b6f4330df04b194b3b5c65a

data/exe/jeanine

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/jeanine/cli'
+
+Jeanine::CLI.new(ARGV).execute

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,22 +1,36 @@
-require 'jeanine/callbacks'
 require 'jeanine/mimes'
 require 'jeanine/request'
-require 'jeanine/rescuing'
 require 'jeanine/response'
-require 'jeanine/renderer'
 require 'jeanine/routing'
-require 'jeanine/session'
 
 module Jeanine
   class App
-    include Session
     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
+
       alias :_new :new
       def new(*args, &block)
         initialize!
@@ -41,24 +55,11 @@ module Jeanine
       end
     end
 
-    include Rescuing
-
     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
@@ -71,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/cli.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+
+module Jeanine
+  class CLI
+    def initialize(args)
+      @args = args
+    end
+
+    def execute
+      if @args[0] == 'new'
+        command_new!
+      else
+        $stdout.puts "I don't know how to `#{@args[0]}`. Maybe you meant `new`?"
+      end
+    end
+
+    def command_new!
+      FileUtils.mkdir("#{@args[1]}") unless Dir.exists?("#{@args[1]}")
+      FileUtils.mkdir("#{@args[1]}/config") unless Dir.exists?("#{@args[1]}/config")
+      relative_dir = "lib/jeanine/generator/new"
+      Dir.glob("lib/jeanine/generator/new/**/*.*").each do |file|
+        new_dir = file.gsub(relative_dir, "#{@args[1]}")[0...-3]
+        FileUtils.copy_file(file, new_dir)
+      end
+      relative_dir = "lib/jeanine/generator/new/config"
+      Dir.glob("lib/jeanine/generator/new/config/**/*.*").each do |file|
+        new_dir = file.gsub(relative_dir, "#{@args[1]}/config")[0...-3]
+        FileUtils.copy_file(file, new_dir)
+      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/version.rb

@@ -1,3 +1,3 @@
 module Jeanine
-  VERSION = "0.2.0"
+  VERSION = "0.7.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.2.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Josh Brody
 autorequire: 
-bindir: bin
+bindir: exe
 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,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,16 +66,60 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A framework.
+- !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:
+    - - ">="
+      - !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 lightning-fast, batteries-included Ruby web micro-framework.
 email:
 - git@josh.mn
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- exe/jeanine
 - lib/jeanine.rb
 - lib/jeanine/app.rb
 - lib/jeanine/callbacks.rb
+- lib/jeanine/cli.rb
 - lib/jeanine/core_ext.rb
 - lib/jeanine/core_ext/array.rb
 - lib/jeanine/core_ext/hash.rb
@@ -85,9 +129,9 @@ 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/rescuable.rb
 - lib/jeanine/response.rb
 - lib/jeanine/router.rb
 - lib/jeanine/routing.rb
@@ -96,6 +140,7 @@ files:
 - 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
@@ -122,5 +167,5 @@ rubyforge_project:
 rubygems_version: 2.6.14.3
 signing_key: 
 specification_version: 4
-summary: A framework.
+summary: A lightning-fast, batteries-included Ruby web micro-framework.
 test_files: []

data/lib/jeanine/rescuing.rb

@@ -1,17 +0,0 @@
-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
-        end
-      end
-    end
-
-    def rescue_handlers
-      @rescue_handlers ||= {}
-    end
-  end
-end