racket-mvc 0.0.3

data/README.md

@@ -0,0 +1,40 @@
+# Racket - The noisy Rack MVC framework
+
+[![Build Status](https://travis-ci.org/lasso/racket.svg?branch=master)](https://travis-ci.org/lasso/racket)    [![codecov.io](https://codecov.io/github/lasso/racket/coverage.svg?branch=master)](https://codecov.io/github/lasso/racket?branch=master)
+
+
+## Say what?
+Yes. It is yet another framework built on rack. Using MVC. Doing silly stuff while you look the other way.
+
+## Why? I though there were a gazillion frameworks that did the same thing already...
+You are correct. There are _lots_ of Rack frameworks out there. This one does not pretend to do anything special
+that you could not get from any of them.
+
+## So, I have to ask again. Why did you create this monstrosity?
+Well, when my web host suddenly started insisting on using Phusion Passenger on all of their servers
+I needed to replace my old [Ramaze](http://ramaze.net/) setup without to much hassle. I tried several
+other Rack framework, but none of them seemed capable of replacing my apps without some major rewrites.
+
+## So you just though writing a whole new framework would be easier than using Rails?
+Yes. Writing Rack frameworks is easy! And since I am able to decide exactly what features I want I don't
+need to adopt to a large ecosystem of concepts I do not like.
+
+## So, is it any good?
+Probably not. At the moment it is good _enough_ for my needs, but I plan to add more features/make stuff faster
+as I start porting more of my old apps from Ramaze.
+
+## Where are the tests?
+Have a look in the `spec` directory. The code base have tests covering 100 per cent of the code and I am planning on keeping it that way. At the moment the code is tested using ruby 2.0, ruby 2.1.6 and 2.2.2, but more versions might be added later.
+
+I am using [bacon](https://github.com/chneukirchen/bacon) and [rack-test](https://github.com/brynary/rack-test) for testing. Run the tests by typing `bacon spec/racket.rb`in the root directory. Code coverage reports are provided by [simplecov](https://rubygems.org/gems/simplecov). After the tests have run the an HTML report can be found in the `coverage` directory. If you are not interested in running the tests yourself you could also have a look at the test status at [Travis CI](https://travis-ci.org/lasso/racket) and the code coverage at [Codecov](https://codecov.io/github/lasso/racket). Their stats get updated on every commit.
+
+## Alright, I want to try using this stuff. Where are the docs?
+Unfortunately there aren't any docs yet. The main reason is that most things are not finished yet, I am still
+moving stuff around like crazy. There **will** be a wiki later and I also plan on documenting the code itself heavily
+(using [Yard](http://yardoc.org/)).
+
+## Why is the code licenced under the GNU Affero General Public License? I want a more liberal licence!
+Because I think it is a Good Thing™ to share code. The
+[GNU Affero General Public License licence](https://www.gnu.org/licenses/agpl.html) is very liberal unless you plan
+on beeing egotistical. I you feel you cannot work with that, please choose
+[something else](https://en.wikipedia.org/wiki/Comparison_of_web_application_frameworks#Ruby).

data/Rakefile

@@ -0,0 +1,13 @@
+task default: %w[test]
+
+task :doc do
+  exec 'yard'
+end
+
+task :nodoc do
+  exec 'yard stats --list-undoc'
+end
+
+task :test do
+  exec 'bacon spec/racket.rb'
+end

data/lib/racket.rb

@@ -0,0 +1,53 @@
+=begin
+Racket - The noisy Rack MVC framework
+Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+
+This file is part of Racket.
+
+Racket is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Racket is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Racket.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+require 'pathname'
+require 'rack'
+
+require_relative 'racket/application.rb'
+require_relative 'racket/controller.rb'
+require_relative 'racket/current.rb'
+require_relative 'racket/request.rb'
+require_relative 'racket/response.rb'
+require_relative 'racket/router.rb'
+require_relative 'racket/session.rb'
+require_relative 'racket/view_cache.rb'
+require_relative 'racket/utils.rb'
+require_relative 'racket/version.rb'
+
+module Racket
+  # Requires a file using the current application directory as a base path.
+  #
+  # @param [Object] args
+  # @return nil
+  def require(*args)
+    Application.require(*args)
+    nil
+  end
+
+  # Returns the current version of Racket.
+  #
+  # @return [String]
+  def version
+    Version.current
+  end
+
+  module_function :require, :version
+end

data/lib/racket/application.rb

@@ -0,0 +1,253 @@
+=begin
+Racket - The noisy Rack MVC framework
+Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+
+This file is part of Racket.
+
+Racket is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Racket is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Racket.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+require 'logger'
+
+module Racket
+  # Racket main application class.
+  class Application
+
+    attr_reader :options, :router
+
+    @current = nil
+
+    # Called whenever Rack sends a request to the application.
+    #
+    # @param [Hash] env Rack environment
+    # @return [Array] A Rack response array
+    def self.call(env)
+      @current.call(env)
+    end
+
+    # Returns a route to the specified controller/action/parameter combination.
+    #
+    # @param [Class] controller
+    # @param [Symbol] action
+    # @param [Array] params
+    # @return [String]
+    def self.get_route(controller, action, params)
+      router.get_route(controller, action, params)
+    end
+
+    # Initializes a new Racket::Application object with default options.
+    #
+    # @return [Class]
+    def self.default
+      fail 'Application has already been initialized!' if @current
+      @current = self.new
+      @current.reload
+      self
+    end
+
+    # Sends a message to the logger, but only if the application is running in dev mode.
+    #
+    # @param [String] message
+    # @param [Symbol] level
+    # @return nil
+    def self.inform_dev(message, level = :info)
+      @current.inform(message, level) if options[:mode] == :dev
+      nil
+    end
+
+    # Sends a message to the logger.
+    #
+    # @param [String] message
+    # @param [Symbol] level
+    # @return nil
+    def self.inform_all(message, level = :info)
+      @current.inform(message, level)
+    end
+
+    # Returns options for the currently running Racket::Application.
+    #
+    # @return [Hash]
+    def self.options
+      @current.options
+    end
+
+    # Requires a file using the current application directory as a base path.
+    #
+    # @param [Object] args
+    # @return nil
+    def self.require(*args)
+      @current.require(*args)
+      nil
+    end
+
+    # Returns the router associated with the currenntly running Racket::Application.
+    #
+    # @return [Racket::Router]
+    def self.router
+      @current.router
+    end
+
+    private_class_method :router
+
+    # Initializes a new Racket::Application object with options specified by +options+.
+    #
+    # @param [Hash] options
+    # @return [Class]
+    def self.using(options)
+      fail 'Application has already been initialized!' if @current
+      @current = self.new(options)
+      @current.reload
+      self
+    end
+
+    # Returns the view cache of the currently running application.
+    #
+    # @return [ViewCache]
+    def self.view_cache
+      @current.view_cache
+    end
+
+    # Internal dispatch handler. Should not be called directly.
+    #
+    # @param [Hash] env Rack environment
+    # @return [Array] A Rack response array
+    def call(env)
+      app.call(env)
+    end
+
+    # Writes a message to the logger if there is one present.
+    #
+    # @param [String] message
+    # @param [Symbol] level
+    # @return nil
+    def inform(message, level)
+      options[:logger].send(level, message) if options[:logger]
+      nil
+    end
+
+    # Reloads the application, making any changes to the controller configuration visible
+    # to the application.
+    #
+    # @return [nil]
+    def reload
+      setup_routes
+      # @todo: Clear cached views/layouts
+      nil
+    end
+
+    # Requires a file using the current application directory as a base path.
+    #
+    # @param [Object] args
+    # @return nil
+    def require(*args)
+      ::Kernel.require Utils.build_path(*args)
+      nil
+    end
+
+    # Returns the ViewCache object associated with the current application.
+    #
+    # @return [ViewCache]
+    def view_cache
+      @view_cache ||= ViewCache.new(options[:layout_dir], options[:view_dir])
+    end
+
+    private
+
+    def app
+      @app ||= build_app
+    end
+
+    def build_app
+      instance = self
+      Rack::Builder.new do
+        instance.options[:middleware].each_pair do |klass, opts|
+          Application.inform_dev("Loading middleware #{klass} with options #{opts}.")
+          use klass, opts
+        end
+        run lambda { |env| instance.router.route(env) }
+      end
+    end
+
+    # Creates a new instance of Racket::Application.
+    #
+    # @param [Hash] options
+    # @return [Racket::Application]
+    def initialize(options = {})
+      @options = default_options.merge(options)
+    end
+
+    # Returns a list of default options for Racket::Application.
+    #
+    # @return [Hash]
+    def default_options
+      root_dir = Utils.build_path(Dir.pwd)
+      {
+        controller_dir: Utils.build_path(root_dir, 'controllers'),
+        default_action: :index,
+        default_layout: '_default.*',
+        default_view: nil,
+        layout_dir: Utils.build_path(root_dir, 'layouts'),
+        logger: Logger.new($stdout),
+        middleware: {
+          Rack::Session::Cookie => {
+            key: 'racket.session',
+            old_secret: SecureRandom.hex(16),
+            secret: SecureRandom.hex(16)
+          }
+        },
+        mode: :live,
+        root_dir: root_dir,
+        view_dir: Utils.build_path(root_dir, 'views')
+      }
+    end
+
+    # Loads controllers and associates each controller with a route.
+    #
+    # @return [nil]
+    def load_controllers
+      Application.inform_dev('Loading controllers.')
+      options[:last_added_controller] = []
+      @controller = nil
+      Dir.chdir(@options[:controller_dir]) do
+        files = Pathname.glob(File.join('**', '*.rb'))
+        files.map! { |file| file.to_s }
+        # Sort by longest path so that the longer paths gets matched first
+        # HttpRouter claims to be doing this already, but this "hack" is needed in order
+        # for the router to work.
+        files.sort! do |a, b|
+          b.split('/').length <=> a.split('/').length
+        end
+        files.each do |file|
+          ::Kernel.require File.expand_path(file)
+          path = "/#{File.dirname(file)}"
+          path = '' if path == '/.'
+          @router.map(path, options[:last_added_controller].pop)
+        end
+      end
+      options.delete(:last_added_controller)
+      Application.inform_dev('Done loading controllers.')
+      nil
+    end
+
+    # Initializes routing.
+    #
+    # @return [nil]
+    def setup_routes
+      @router = Router.new
+      load_controllers
+      nil
+    end
+
+  end
+end

data/lib/racket/controller.rb

@@ -0,0 +1,148 @@
+=begin
+Racket - The noisy Rack MVC framework
+Copyright (C) 2015  Lars Olsson <lasso@lassoweb.se>
+
+This file is part of Racket.
+
+Racket is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Racket is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Racket.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+module Racket
+
+  # Base controller class. Your controllers should inherit this class.
+  class Controller
+
+    # Adds a hook to one or more actions.
+    #
+    # @param [Symbol] type
+    # @param [Array] methods
+    # @param [Proc] blk
+    # @return [nil]
+    def self.add_hook(type, methods, blk)
+      key = "#{type}_hooks".to_sym
+      meths = public_instance_methods(false)
+      meths = meths & methods.map { |method| method.to_sym} unless methods.empty?
+      hooks = get_option(key) || {}
+      meths.each { |meth| hooks[meth] = blk }
+      set_option(key, hooks)
+      nil
+    end
+
+    private_class_method :add_hook
+
+    # Adds a before hook to one or more actions. Actions should be given as a list of symbols.
+    # If no symbols are provided, *all* actions on the controller is affected.
+    #
+    # @param [Array] methods
+    # @return [nil]
+    def self.after(*methods, &blk)
+      add_hook(:after, methods, blk) if block_given?
+    end
+
+    # Adds an after hook to one or more actions. Actions should be given as a list of symbols.
+    # If no symbols are provided, *all* actions on the controller is affected.
+    #
+    # @param [Array] methods
+    # @return [nil]
+    def self.before(*methods, &blk)
+      add_hook(:before, methods, blk) if block_given?
+    end
+
+    # :nodoc:
+    def self.inherited(klass)
+      Application.options[:last_added_controller].push(klass)
+    end
+
+    # Returns an option for the current controller class or any of the controller classes
+    # it is inheriting from.
+    #
+    # @param [Symbol] key The option to retrieve
+    # @return [Object]
+    def self.get_option(key)
+      @options ||= {}
+      return @options[key] if @options.key?(key)
+      # We are running out of controller options, do one final lookup in Application.options
+      return Application.options.fetch(key, nil) if superclass == Controller
+      superclass.get_option(key)
+    end
+
+    # Sets an option for the current controller class.
+    #
+    # @param [Symbol] key
+    # @param [Object] value
+    def self.set_option(key, value)
+      @options ||= {}
+      @options[key] = value
+    end
+
+    # Returns an option from the current controller class.
+    #
+    # @param [Symbol] key
+    # @return
+    def controller_option(key)
+      self.class.get_option(key)
+    end
+
+    # Returns a route to an action within the current controller.
+    #
+    # @param [Symbol] action
+    # @param [Array] params
+    # @return [String]
+    def rs(action, *params)
+      Application.get_route(self.class, action, params)
+    end
+
+    # Returns a route to an action within another controller.
+    #
+    # @param [Class] controller
+    # @param [Symbol] action
+    # @param [Array] params
+    # @return [String]
+    def r(controller, action, *params)
+      Application.get_route(controller, action, params)
+    end
+
+    # Redirects the client.
+    #
+    # @param [String] target
+    # @param [Fixnum] status
+    # @return [Object]
+    def redirect(target, status = 302)
+      racket.redirected = true
+      response.redirect(target, status)
+    end
+
+    # Renders an action.
+    #
+    # @param [Symbol] action
+    # @return [String]
+    def render(action)
+      __execute(action)
+      Application.view_cache.render(self)
+    end
+
+    private
+
+    def __execute(action)
+      before_hooks = controller_option(:before_hooks) || {}
+      self.instance_eval &before_hooks[action] if before_hooks.key?(action)
+      meth = method(action)
+      params = racket.params[0...meth.parameters.length]
+      racket.action_result = meth.call(*params)
+      after_hooks = controller_option(:after_hooks) || {}
+      self.instance_eval &after_hooks[action] if after_hooks.key?(action)
+    end
+
+  end
+end