locomotivecms_steam 0.1.2.pre.beta → 1.0.0.pre.alpha

data/lib/locomotive/steam/middlewares/locale_redirection.rb

@@ -0,0 +1,62 @@
+module Locomotive::Steam
+  module Middlewares
+
+    # Redirect to the same page with or without the locale in the url
+    # based on the "prefix_default_locale" property of the current site.
+    #
+    # See the specs (spec/unit/middlewares/locale_redirection_spec.rb) for more details.
+    #
+    class LocaleRedirection < ThreadSafe
+
+      include Helpers
+
+      def _call
+        if url = redirect_url
+          redirect_to url
+        end
+      end
+
+      protected
+
+      def redirect_url
+        if apply_redirection?
+          if site.prefix_default_locale
+            path_with_default_locale if locale_not_mentioned_in_path?
+          else
+            path_without_default_locale if default_locale? && locale_mentioned_in_path?
+          end
+        end
+      end
+
+      def apply_redirection?
+        site.locales.size > 1 && request.get?
+      end
+
+      def default_locale?
+        locale.to_s == site.default_locale.to_s
+      end
+
+      def locale_mentioned_in_path?
+        env['steam.locale_in_path']
+      end
+
+      def locale_not_mentioned_in_path?
+        !locale_mentioned_in_path?
+      end
+
+      def path_with_default_locale
+        modify_path do |segments|
+          segments.insert(1, site.default_locale)
+        end
+      end
+
+      def path_without_default_locale
+        modify_path do |segments|
+          segments.delete_at(1)
+        end
+      end
+
+    end
+  end
+
+end

data/lib/locomotive/steam/middlewares/logging.rb

@@ -3,12 +3,15 @@ module Locomotive::Steam
 
     # Track the request into the current logger
     #
-    class Logging < Base
+    class Logging < Struct.new(:app)
+
+      include Helpers
 
       def call(env)
         now = Time.now
 
-        log "Started #{env['REQUEST_METHOD'].upcase} \"#{env['PATH_INFO']}\" at #{now}".light_white
+        log "Started #{env['REQUEST_METHOD'].upcase} \"#{env['PATH_INFO']}\" at #{now}".light_white, 0
+        log "Params: #{env.fetch('steam.request').params.inspect}"
 
         app.call(env).tap do |response|
           done_in_ms = ((Time.now - now) * 10000).truncate / 10.0
@@ -24,9 +27,10 @@ module Locomotive::Steam
         when 301 then '301 Found'
         when 302 then '302 Found'
         when 404 then '404 Not Found'
+        when 422 then '422 Unprocessable Entity'
         end
       end
 
     end
   end
-end
+end

data/lib/locomotive/steam/middlewares/page.rb

@@ -1,64 +1,33 @@
 module Locomotive::Steam
   module Middlewares
 
-    # Sanitize the path from the previous middleware in order
-    # to make it work for the renderer.
+    # Retrieve a page from the path and the locale previously
+    # fetched from the request.
     #
-    class Page < Base
+    class Page < ThreadSafe
 
-      def _call(env)
-        super
-        set_page!(env)
-        app.call(env)
-      end
-
-      protected
+      include Helpers
 
-      def set_page!(env)
-        page = fetch_page env['steam.locale']
-        if page
-          log "Found page \"#{page.title}\" [#{page.fullpath}]"
+      def _call
+        if page = fetch_page
+          if !page.not_found?
+            log "Found page \"#{page.title}\" [#{page.fullpath}]"
+          else
+            log "Page not found, rendering the 404 page.".magenta
+          end
         end
 
         env['steam.page'] = page
       end
 
-      def fetch_page locale
-        decorated(locale) do
-          Locomotive::Models[:pages].current_locale = locale
-          Locomotive::Models[:pages].matching_paths(path_combinations(path)).tap do |pages|
-            if pages.size > 1
-              self.log "Found multiple pages: #{pages.all.collect(&:title).join(', ')}"
-            end
-          end.first
-        end
-      end
-
-      def decorated(locale)
-        entity = yield
-        unless entity.nil?
-          Locomotive::Steam::Decorators::PageDecorator.new(
-            Locomotive::Decorators::I18nDecorator.new(entity, locale))
-        end
-      end
-
-      def path_combinations(path)
-        self._path_combinations(path.split('/'))
-      end
-
-      def _path_combinations(segments, can_include_template = true)
-        return nil if segments.empty?
-        segment = segments.shift
+      protected
 
-        (can_include_template ? [segment, '*'] : [segment]).map do |_segment|
-          if (_combinations = _path_combinations(segments.clone, can_include_template && _segment != '*'))
-            [*_combinations].map do |_combination|
-              File.join(_segment, _combination)
-            end
-          else
-            [_segment]
+      def fetch_page
+        services.page_finder.match(path).tap do |pages|
+          if pages.size > 1
+            self.log "Found multiple pages: #{pages.map(&:title).join(', ')}"
           end
-        end.flatten
+        end.first || services.page_finder.find('404')
       end
 
     end

data/lib/locomotive/steam/middlewares/path.rb

@@ -4,20 +4,17 @@ module Locomotive::Steam
     # Sanitize the path from the previous middleware in order
     # to make it work for the renderer.
     #
-    class Path < Base
-
-      def _call(env)
-        super
-
-        self.set_path!(env)
+    class Path < Struct.new(:app)
 
+      def call(env)
+        set_path!(env)
         app.call(env)
       end
 
       protected
 
       def set_path!(env)
-        path = env['PATH_INFO'].clone
+        path = env['steam.path'] || request.path_info
 
         path.gsub!(/\.[a-zA-Z][a-zA-Z0-9]{2,}$/, '')
         path.gsub!(/^\//, '')
@@ -31,4 +28,4 @@ module Locomotive::Steam
     end
 
   end
-end
+end

data/lib/locomotive/steam/middlewares/renderer.rb

@@ -1,141 +1,100 @@
 module Locomotive::Steam
   module Middlewares
 
-    class Renderer < Base
+    class Renderer < ThreadSafe
 
-      def _call(env)
-        super
+      include Helpers
 
+      def _call
         if page
-          if page.redirect?
-            redirect_to(page.redirect_url, page.redirect_type)
-          else
-            type = page.response_type || 'text/html'
-            html = render_page
-
-            log 'Rendered liquid page template'
-
-            [200, { 'Content-Type' => type }, [html]]
-          end
+          render_page
         else
-          [404, { 'Content-Type' => 'text/html' }, [render_404]]
+          render_missing_404
         end
       end
 
-      protected
+      private
 
       def render_page
-        context = self.locomotive_context
-        # begin
-        #   binding.pry
-          render(page, context)
-        # rescue Exception => e
-
-        #   raise RendererException.new(e, self.page.title, self.page.template, context)
-        # end
+        if page.redirect_url
+          redirect_to(page.redirect_url, page.redirect_type)
+        else
+          content = parse_and_render_liquid
+          render_response(content, page.not_found? ? 404: 200)
+        end
       end
 
-      def render(page, context)
-        parse(page, context).render(context)
+      def render_missing_404
+        log "[Warning] Your 404 page is missing. Please create it.".red
+        render_response('Missing 404 page', 404)
       end
 
-      protected
+      def parse_and_render_liquid
+        document = services.liquid_parser.parse(page)
+        document.render(liquid_context)
+      end
 
-      def parse(page, context)
+      def liquid_context
+        ::Liquid::Context.new(liquid_assigns, {}, liquid_registers, true)
+      end
 
-        options =  {
+      def liquid_registers
+        {
+          request:        request,
+          locale:         locale,
+          site:           site,
           page:           page,
-          mapper: context.registers[:mapper],
-          error_mode:     :strict,
-          count_lines:    true
+          services:       services,
+          repositories:   services.repositories,
+          logger:         Locomotive::Common::Logger
         }
-
-        begin
-          ::Liquid::Template.parse(page.source(I18n.locale), options)
-        rescue ::Liquid::SyntaxError
-          # do it again on the raw source instead so that the error line matches
-          # the source file.
-          ::Liquid::Template.parse(self.template.raw_source, options)
-        end
       end
 
-
-      def render_404
-        if self.page = Locomotive::Models[:pages]['404']
-          self.render_page
-        else
-          'Page not found'
-        end
+      def liquid_assigns
+        _default_liquid_assigns.merge(
+          _locale_liquid_assigns.merge(
+            _request_liquid_assigns.merge(
+              _steam_liquid_assigns)))
       end
 
-      # Build the Liquid context used to render the Locomotive page. It
-      # stores both assigns and registers.
-      #
-      # @param [ Hash ] other_assigns Assigns coming for instance from the controler (optional)
-      #
-      # @return [ Object ] A new instance of the Liquid::Context class.
-      #
-      def locomotive_context(other_assigns = {})
-        assigns = self.locomotive_default_assigns
-
-        # assigns from other middlewares
-        assigns.merge!(self.liquid_assigns)
-
-        assigns.merge!(other_assigns)
-
-        # templatized page
-        if self.page && self.content_entry
-          ['content_entry', 'entry', self.page.content_type.slug.singularize].each do |key|
-            assigns[key] = self.content_entry
-          end
-        end
+      def _default_liquid_assigns
+        {
+          'current_page'      => params[:page],
+          'params'            => params.stringify_keys,
+          'now'               => Time.zone.now,
+          'today'             => Date.today,
+          'mode'              => Locomotive::Steam.configuration.mode,
+          'wagon'             => Locomotive::Steam.configuration.mode == :test
+        }
+      end
 
-        # Tip: switch from false to true to enable the re-thrown exception flag
-        ::Liquid::Context.new({}, assigns, self.locomotive_default_registers, true)
+      def _steam_liquid_assigns
+        {
+          'site'          => site.to_liquid,
+          'page'          => page.to_liquid,
+          'models'        => Locomotive::Steam::Liquid::Drops::ContentTypes.new,
+          'contents'      => Locomotive::Steam::Liquid::Drops::ContentTypes.new,
+          'current_user'  => {},
+          'session'       => Locomotive::Steam::Liquid::Drops::SessionProxy.new,
+        }.merge(env['steam.liquid_assigns'])
       end
 
-      # Return the default Liquid assigns used inside the Locomotive Liquid context
-      #
-      # @return [ Hash ] The default liquid assigns object
-      #
-      def locomotive_default_assigns
+      def _locale_liquid_assigns
         {
-          'site'              => self.site.to_liquid,
-          'page'              => self.page,
-          'models'            => Locomotive::Steam::Liquid::Drops::ContentTypes.new,
-          'contents'          => Locomotive::Steam::Liquid::Drops::ContentTypes.new,
-          'current_page'      => self.params[:page],
-          'params'            => self.params.stringify_keys,
-          'path'              => self.request.path,
-          'fullpath'          => self.request.fullpath,
-          'url'               => self.request.url,
-          'ip_address'        => self.request.ip,
-          'post?'             => self.request.post?,
-          'host'              => self.request.host_with_port,
-          'now'               => Time.zone.now,
-          'today'             => Date.today,
-          'locale'            => I18n.locale.to_s,
-          'default_locale'    => self.site.default_locale.to_s,
-          'locales'           => self.site.locales.map(&:to_s),
-          'current_user'      => {},
-          'session'           => Locomotive::Steam::Liquid::Drops::SessionProxy.new,
-          'steam'             => true,
-          'editing'           => false
+          'locale'         => locale,
+          'default_locale' => site.default_locale.to_s,
+          'locales'        => site.locales.map(&:to_s)
         }
       end
 
-      # Return the default Liquid registers used inside the Locomotive Liquid context
-      #
-      # @return [ Hash ] The default liquid registers object
-      #
-      def locomotive_default_registers
+      def _request_liquid_assigns
         {
-          request:        self.request,
-          site:           self.site,
-          page:           self.page,
-          services:       self.services,
-          inline_editor:  false,
-          logger:         Locomotive::Common::Logger
+          'path'        => request.path,
+          'fullpath'    => request.fullpath,
+          'url'         => request.url,
+          'ip_address'  => request.ip,
+          'post?'       => request.post?,
+          'host'        => request.host_with_port
         }
       end
 

data/lib/locomotive/steam/middlewares/robots.rb

@@ -0,0 +1,20 @@
+module Locomotive::Steam
+  module Middlewares
+
+    class Robots < Struct.new(:app, :options)
+
+      include Helpers
+
+      def call(env)
+        if env['PATH_INFO'] == '/robots.txt'
+          site = env['steam.site']
+          render_response(site[:robots_txt] || '', 200, 'text/plain')
+        else
+          app.call(env)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/middlewares/site.rb

@@ -0,0 +1,42 @@
+module Locomotive::Steam
+  module Middlewares
+
+    # Fetch a site using the site_finder service. Look for an existing
+    # site in the rack env variable (context: when launched from the Engine).
+    #
+    class Site < ThreadSafe
+
+      include Helpers
+
+      def _call
+        env['steam.site'] ||= services.site_finder.find
+        services.repositories.current_site = site = env['steam.site']
+
+        # render a simple message if the service was not able to find a site
+        # based on the request.
+        render_no_site unless site
+
+        # log anyway
+        log_site(site)
+      end
+
+      private
+
+      def render_no_site
+        render_response('Hi, we are sorry but no site was found.', 404, 'text/html')
+      end
+
+      def log_site(site)
+        if site.nil?
+          msg = "Unable to find a site, url asked: #{request.url} ".colorize(color: :light_white, background: :red)
+        else
+          msg = site.name.colorize(color: :light_white, background: :blue)
+        end
+
+        log msg, 0
+      end
+
+    end
+
+  end
+end