racket-mvc 0.3.1 → 0.3.2

data/lib/racket/version.rb

@@ -25,7 +25,7 @@ module Racket
     # Minor version
     MINOR = 3
     # Teeny version
-    TEENY = 1
+    TEENY = 2
     # Is it a prerelease?
     PRERELEASE = false
 

data/lib/racket/view_manager.rb

@@ -19,17 +19,9 @@
 module Racket
   # Handles rendering in Racket applications.
   class ViewManager
-    # Struct for holding view parameters.
-    ViewParams = Struct.new(:controller, :path, :type)
-
-    attr_reader :layout_cache
-    attr_reader :view_cache
-
     def initialize(layout_base_dir, view_base_dir)
-      @layout_base_dir = layout_base_dir
-      @view_base_dir = view_base_dir
-      @layout_cache = {}
-      @view_cache = {}
+      @locator = Utils::Views::TemplateLocator.new(layout_base_dir, view_base_dir)
+      @renderer = Utils::Views::ViewRenderer
     end
 
     # Renders a controller based on the request path and the variables set in the
@@ -38,63 +30,19 @@ module Racket
     # @param [Controller] controller
     # @return [Hash]
     def render(controller)
-      template_path = Utils.get_template_path(controller)
-      view = get_template(ViewParams.new(controller, template_path, :view))
-      layout = view ? get_template(ViewParams.new(controller, template_path, :layout)) : nil
-      if view then output = Utils.render_template(controller, view, layout)
-      else output = controller.racket.action_result
-      end
-      Utils.send_response(controller.response, output)
+      @renderer.render(controller, *get_view_and_layout(controller))
     end
 
     private
 
-    # Returns a cached template. If the template has not been cached yet, this method will run a
-    # lookup against the provided parameters.
-    #
-    # @param [ViewParams] view_params
-    # @return [String|Proc|nil]
-    def ensure_in_cache(view_params)
-      _, path, type = view_params.to_a
-      store = instance_variable_get("@#{type}_cache".to_sym)
-      return store[path] if store.key?(path)
-      store_in_cache(store, view_params)
-    end
-
-    # Tries to locate a template matching +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 path will only happen once.
-    #
-    # @param [ViewParams] view_params
-    # @return [String|nil]
-    def get_template(view_params)
-      template = ensure_in_cache(view_params)
-      # If template is a Proc, call it
-      if template.is_a?(Proc)
-        controller, path, type = view_params.to_a
-        template =
-          Utils.lookup_template(
-            instance_variable_get("@#{type}_base_dir".to_sym),
-            [File.dirname(path), Utils.call_template_proc(template, controller)].join('/')
-          )
-      end
-      template
-    end
-
-    # Stores the location of a template (not its contents) in the cache.
+    # Returns the view and layout that should be used for rendering.
     #
-    # @param [Object] store Where to store the location
-    # @param [ViewParams] view_params
-    # @return [String|Proc|nil]
-    def store_in_cache(store, view_params)
-      controller, path, type = view_params.to_a
-      base_dir = instance_variable_get("@#{type}_base_dir".to_sym)
-      default_template = controller.settings.fetch("default_#{type}".to_sym)
-      template = Utils.lookup_template_with_default(base_dir, path, default_template)
-      Application.inform_dev(
-        "Using #{type} #{template.inspect} for #{controller.class}.#{controller.racket.action}."
-      )
-      store[path] = template
+    # @param [Racket::Controller] controller
+    # @return [Array]
+    def get_view_and_layout(controller)
+      view = @locator.get_view(controller)
+      layout = view ? @locator.get_layout(controller) : nil
+      [view, layout]
     end
   end
 end

data/spec/_custom.rb

@@ -2,14 +2,11 @@ describe 'A custom Racket test Application' do
   extend Rack::Test::Methods
   def app
     @app ||= Racket::Application.using(
-      {
-        default_layout: 'zebra.*',
-        logger: nil,
-        my_custom_secret: 42,
-        mode: :dev,
-        view_dir: 'templates'
-      },
-      true
+      default_layout: 'zebra.*',
+      logger: nil,
+      my_custom_secret: 42,
+      mode: :dev,
+      view_dir: 'templates'
     )
   end
 

data/spec/_default.rb

@@ -17,20 +17,24 @@ describe 'A default Racket test Application' do
     app.router.routes[DefaultSubController3].should.equal('/sub3')
     app.router.routes[DefaultInheritedController].should.equal('/sub3/inherited')
 
-    app.router.action_cache[DefaultRootController].length.should.equal(5)
-    app.router.action_cache[DefaultRootController].include?(:index).should.equal(true)
-    app.router.action_cache[DefaultRootController].include?(:my_first_route).should.equal(true)
-    app.router.action_cache[DefaultRootController].include?(:my_second_route).should.equal(true)
-    app.router.action_cache[DefaultSubController1].length.should.equal(4)
-    app.router.action_cache[DefaultSubController1].include?(:route_to_root).should.equal(true)
-    app.router.action_cache[DefaultSubController1].include?(:route_to_nonexisting)
+    app.router.action_cache.items[DefaultRootController].length.should.equal(5)
+    app.router.action_cache.items[DefaultRootController].include?(:index).should.equal(true)
+    app.router.action_cache.items[DefaultRootController].include?(:my_first_route)
       .should.equal(true)
-    app.router.action_cache[DefaultSubController2].length.should.equal(5)
-    app.router.action_cache[DefaultSubController2].include?(:index).should.equal(true)
-    app.router.action_cache[DefaultSubController2].include?(:current_action).should.equal(true)
-    app.router.action_cache[DefaultSubController2].include?(:current_params).should.equal(true)
-    app.router.action_cache[DefaultSubController3].should.equal([:index])
-    app.router.action_cache[DefaultInheritedController].should.equal([:index])
+    app.router.action_cache.items[DefaultRootController].include?(:my_second_route)
+      .should.equal(true)
+    app.router.action_cache.items[DefaultSubController1].length.should.equal(4)
+    app.router.action_cache.items[DefaultSubController1].include?(:route_to_root).should.equal(true)
+    app.router.action_cache.items[DefaultSubController1].include?(:route_to_nonexisting)
+      .should.equal(true)
+    app.router.action_cache.items[DefaultSubController2].length.should.equal(5)
+    app.router.action_cache.items[DefaultSubController2].include?(:index).should.equal(true)
+    app.router.action_cache.items[DefaultSubController2].include?(:current_action)
+      .should.equal(true)
+    app.router.action_cache.items[DefaultSubController2].include?(:current_params)
+      .should.equal(true)
+    app.router.action_cache.items[DefaultSubController3].should.equal([:index])
+    app.router.action_cache.items[DefaultInheritedController].should.equal([:index])
   end
 
   it 'should set rack variables correctly' do
@@ -160,9 +164,9 @@ describe 'A default Racket test Application' do
   end
 
   it 'should be able to build paths correctly' do
-    Racket::Utils.build_path.should.equal(Pathname.pwd.to_s)
+    Racket::Utils.build_path.should.equal(Pathname.pwd)
     Racket::Utils.build_path('foo', 'bar', 'baz').should.equal(
-      File.join(Pathname.pwd.to_s, 'foo', 'bar', 'baz')
+      Pathname.pwd.join('foo').join('bar').join('baz')
     )
   end
 

data/spec/racket.rb

@@ -23,9 +23,23 @@ require 'racket/helpers/file.rb'
 require 'rack/test'
 require 'bacon'
 
+# Method tests should always be run first.
 require File.join(TEST_DIR, '_request.rb')
 
-Dir.chdir(TEST_DEFAULT_APP_DIR) { require File.join(TEST_DIR, '_default.rb') }
-Dir.chdir(TEST_CUSTOM_APP_DIR) { require File.join(TEST_DIR, '_custom.rb') }
+# Application tests.
+suites = [
+  -> { Dir.chdir(TEST_DEFAULT_APP_DIR) { require File.join(TEST_DIR, '_default.rb') } },
+  -> { Dir.chdir(TEST_CUSTOM_APP_DIR) { require File.join(TEST_DIR, '_custom.rb') } }
+]
 
+# Leave off randomization for now. Sessions does not seem to be reset correctly between suites!
+# suites.shuffle!
+
+# Run application tests.
+suites.each do |suite|
+  Racket::Application.reset!
+  suite.call
+end
+
+# Invalid application test should always be run last.
 require File.join(TEST_DIR, '_invalid.rb')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: racket-mvc
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Lars Olsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-10 00:00:00.000000000 Z
+date: 2015-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_router
@@ -160,8 +160,10 @@ files:
 - lib/racket/settings/base.rb
 - lib/racket/settings/controller.rb
 - lib/racket/utils.rb
+- lib/racket/utils/application.rb
 - lib/racket/utils/exceptions.rb
 - lib/racket/utils/file_system.rb
+- lib/racket/utils/helpers.rb
 - lib/racket/utils/routing.rb
 - lib/racket/utils/views.rb
 - lib/racket/version.rb