racket-mvc 0.0.3

data/lib/racket/current.rb

@@ -0,0 +1,49 @@
+=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
+  # Represents the current state of Racket while processing a request. The state gets mixed into
+  # the controller instance at the start of the request, making it easy to keep track on everything
+  # from within the controller instance.
+  class Current
+    # Holds Racket internal state, available to the controller instance but mostly used for keeping
+    # track of things that don't belong to the actual request.
+    State = Struct.new(:action, :action_result, :params, :redirected)
+
+    # Called whenever a new request needs to be processed.
+    #
+    # @param [Hash] env Rack environment
+    # @param [Symbol] action Keeps track of which action was called on the controller
+    # @param [Array] params Parameters sent to the action
+    # @return [Module] A module encapsulating all state relating to the current request
+    def self.init(env, action, params)
+      racket = State.new(action, nil, params, false)
+      request = Request.new(env)
+      response = Response.new
+      session = Session.new(env['rack.session']) if env.key?('rack.session')
+      Module.new do
+        define_method(:racket) { racket }
+        define_method(:request) { request }
+        define_method(:response) { response }
+        define_method(:session) { session } if env.key?('rack.session')
+      end
+    end
+  end
+end

data/lib/racket/request.rb

@@ -0,0 +1,32 @@
+=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
+  # Represents an incoming request. Mostly matches Rack::Request but removes some methods that
+  # don't fit with racket.
+  class Request < Rack::Request
+    # Force explicit use of request.GET and request.POST
+    # For racket params, use racket.params
+    undef_method :params
+
+    # Unless sessions are loaded explicitly, session methods should not be available
+    undef_method :session, :session_options
+  end
+end

data/lib/racket/response.rb

@@ -0,0 +1,25 @@
+=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
+  # Represents a response from the application
+  class Response < Rack::Response
+  end
+end

data/lib/racket/router.rb

@@ -0,0 +1,114 @@
+=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 'http_router'
+
+module Racket
+  # Handles routing in Racket applications.
+  class Router
+    def initialize
+      @router = HttpRouter.new
+      @routes_by_controller = {}
+      @actions_by_controller = {}
+    end
+
+    # Caches available actions for each controller class. This also works for controller classes
+    # that inherit from other controller classes.
+    #
+    # @param [Class] controller
+    # @return [nil]
+    def cache_actions(controller)
+      actions = Set.new
+      current = controller
+      while current < Controller
+        actions.merge(current.instance_methods(false))
+        current = current.superclass
+      end
+      @actions_by_controller[controller] = actions.to_a
+      nil
+    end
+
+    # Returns a route to the specified controller/action/parameter combination.
+    #
+    # @param [Class] controller
+    # @param [Symbol] action
+    # @param [Array] params
+    # @return [String]
+    def get_route(controller, action, params)
+      route = ''
+      route << @routes_by_controller[controller] if @routes_by_controller.key?(controller)
+      action = action.to_s
+      route << "/#{action}" unless action.empty?
+      route << "/#{params.join('/')}" unless params.empty?
+      route = route[1..-1] if route.start_with?('//') # Special case for root path
+      route
+    end
+
+    # Maps a controller to the specified path.
+    #
+    # @param [String] path
+    # @param [Class] controller
+    # @return [nil]
+    def map(path, controller)
+      controller_base_path = path.empty? ? '/' : path
+      Application.inform_dev("Mapping #{controller} to #{controller_base_path}.")
+      @router.add("#{path}(/*params)").to(controller)
+      @routes_by_controller[controller] = controller_base_path
+      cache_actions(controller)
+      nil
+    end
+
+    # @todo: Allow the user to set custom handlers for different errors
+    def render_404(message = '404 Not found')
+      [404, { 'Content-Type' => 'text/plain' }, message]
+    end
+
+    # Routes a request and renders it.
+    #
+    # @param [Hash] env Rack environment
+    # @return [Array] A Rack response triplet
+    def route(env)
+      # Find controller in map
+      # If controller exists, call it
+      # Otherwise, send a 404
+      matching_routes = @router.recognize(env)
+      unless matching_routes.first.nil?
+        target_klass = matching_routes.first.first.route.dest
+        params = matching_routes.first.first.param_values.first.reject { |e| e.empty? }
+        action = params.empty? ? target_klass.get_option(:default_action) : params.shift.to_sym
+
+        # Check if action is available on target
+        return render_404 unless @actions_by_controller[target_klass].include?(action)
+
+        # Initialize target
+        target = target_klass.new
+        # @fixme: File.dirname should not be used on urls!
+        1.upto(params.count) do
+          env['PATH_INFO'] = File.dirname(env['PATH_INFO'])
+        end
+        target.extend(Current.init(env, action, params))
+        target.render(action)
+      else
+        render_404
+      end
+    end
+
+  end
+end

data/lib/racket/session.rb

@@ -0,0 +1,37 @@
+=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
+  # Racket::Session is just a thin wrapper around whetever object that is implementing the session
+  # storage. By default this is an instance of Rack::Session::Abstract::SessionHash, but
+  # Racket::Session will happily wrap anything found in the rack environment.
+  #
+  # To provide your own session handler and have it wrapped by Racket::Session, just add your
+  # session handler as a middleware and make sure it writes the current session to the key
+  # rack.session in the rack environment.
+  class Session < SimpleDelegator
+    # Look the same regardless of what the underlying implementation is.
+    def inspect
+      "#<#{self.class}:#{object_id}>"
+    end
+    alias :to_s inspect
+    alias :to_str inspect
+  end
+end

data/lib/racket/utils.rb

@@ -0,0 +1,25 @@
+module Racket
+  # Collects utilities needed by different objects in Racket.
+  class Utils
+    # Builds and returns a path in the file system from the provided arguments. The first element
+    # in the argument list can be either absolute or relative, all other arguments must be relative,
+    # otherwise they will be removed from the final path.
+    #
+    # @param [Array] args
+    # @return [String]
+    def self.build_path(*args)
+      if (args.empty?)
+        path = Pathname.pwd
+      else
+        path = Pathname.new(args.shift)
+        path = Pathname.new(Application.options[:root_dir]).join(path) if path.relative?
+        args.each do |arg|
+          path_part = Pathname.new(arg)
+          next unless path_part.relative?
+          path = path.join(path_part)
+        end
+      end
+      path.cleanpath.expand_path.to_s
+    end
+  end
+end

data/lib/racket/version.rb

@@ -0,0 +1,33 @@
+=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
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    TEENY = 3
+
+    def current
+      [MAJOR, MINOR, TEENY].join('.')
+    end
+
+    module_function :current
+  end
+end

data/lib/racket/view_cache.rb

@@ -0,0 +1,110 @@
+=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 'tilt'
+
+module Racket
+  # Handles rendering in Racket applications.
+  class ViewCache
+
+    def initialize(layout_base_dir, template_base_dir)
+      @layout_base_dir = layout_base_dir
+      @template_base_dir = template_base_dir
+      @layouts_by_path = {}
+      @templates_by_path = {}
+    end
+
+    # Renders a controller based on the request path and the variables set in the
+    # controller instance.
+    #
+    # @param [Controller] controller
+    # @return [Hash]
+    def render(controller)
+      unless controller.racket.redirected
+        template =
+          find_template(controller.request.path, controller.controller_option(:default_view))
+        if template
+          output = Tilt.new(template).render(controller)
+          layout =
+            find_layout(controller.request.path, controller.controller_option(:default_layout))
+          output = Tilt.new(layout).render(controller) { output } if layout
+        else
+          output = controller.racket.action_result
+        end
+        controller.response.write(output)
+      end
+      controller.response.finish
+    end
+
+    private
+
+    # Tries to locate a layout matching +url_path+ in the file system and returns the path if a
+    # matching file is found. If no matching file is found, +nil+ is returned. The result is
+    # cached, meaning that the filesystem lookup for a specific url_path will only happen once.
+    #
+    # @param [String] url_path
+    # @param [String|nil] default_layout
+    # @return [String|nil]
+    def find_layout(url_path, default_layout)
+      return @layouts_by_path[url_path] if @layouts_by_path.key?(url_path)
+      @layouts_by_path[url_path] = find_matching_file(@layout_base_dir, url_path, default_layout)
+    end
+
+    # Tries to locate a template matching +url_path+ in the file system and returns the path if a
+    # matching file is found. If no matching file is found, +nil+ is returned. The result is
+    # cached, meaning that the filesystem lookup for a specific url_path will only happen once.
+    #
+    # @param [String] url_path
+    # @param [String|nil] default_view
+    # @return [String|nil]
+    def find_template(url_path, default_view)
+      return @templates_by_path[url_path] if @templates_by_path.key?(url_path)
+      @templates_by_path[url_path] = find_matching_file(@template_base_dir, url_path, default_view)
+    end
+
+    # Locates a file in the filesystem matching an URL path. If there exists a matching file, the
+    # path to it is returned. If there is no matching file, +nil+ is returned.
+    #
+    # @param [String] base_file_path
+    # @param [String] url_path
+    # @param [String|nil] default_file
+    # @return [String|nil]
+    def find_matching_file(base_file_path, url_path, default_file)
+      file_path = File.join(base_file_path, url_path)
+      action = File.basename(file_path)
+      file_path = File.dirname(file_path)
+      return nil unless File.exists?(file_path) && File.directory?(file_path)
+      Dir.chdir(file_path) do
+        files = Pathname.glob("#{action}.*")
+        if files.empty?
+          if default_file
+            files = Pathname.glob(default_file)
+            return nil if files.empty? # No default file found
+            return File.join(file_path, files.first.to_s)
+          end
+          return nil # Neither default file or specified file found
+        end
+        File.join(file_path, files.first.to_s)
+      end
+    end
+
+  end
+
+end

data/spec/_custom.rb

@@ -0,0 +1,48 @@
+describe 'The custom Racket test Application' do
+  extend Rack::Test::Methods
+  def app
+    @app ||= Racket::Application.using(default_layout: 'zebra.*', view_dir: 'templates')
+  end
+
+  it 'should set requested options' do
+    app.options[:default_layout].should.equal('zebra.*')
+    app.options[:view_dir].should.equal('templates')
+  end
+
+  it 'should be able to get/set options on controller' do
+    get '/sub3/a_secret_place'
+    last_response.status.should.equal(302)
+    last_response.headers['Location'].should.equal('/sub3/a_secret_place/42')
+    last_response.body.length.should.equal(0)
+  end
+
+  it 'should return a 404 on a nonexisting url' do
+    get '/nosuchurl'
+    last_response.status.should.equal(404)
+    last_response.body.should.equal('404 Not found')
+  end
+
+  it 'should be able to render a template and a layout' do
+    get '/sub2/template'
+    last_response.status.should.equal(200)
+    last_response.body.should.match(/Message from template/)
+    last_response.body.should.match(/A groovy layout/)
+  end
+
+  it 'should be able to require custom files' do
+    Module.constants.should.not.include(:Blob)
+    Racket.require 'extra/blob'
+    Module.constants.should.include(:Blob)
+    Module.constants.should.not.include(:InnerBlob)
+    Racket.require 'extra', 'blob', 'inner_blob'
+    Module.constants.should.include(:InnerBlob)
+  end
+
+  it 'should be able to use before/after hooks' do
+    get '/sub2/hook_action'
+    last_response.headers.key?('X-Hook-Action').should.equal(true)
+    last_response.headers['X-Hook-Action'].should.equal('run')
+    response = JSON.parse(last_response.body)
+    response.should.equal(["Data added in before block", "Data added in action"])
+  end
+end