locomotivecms_wagon 1.0.0

data/lib/locomotive/wagon/server/entry_submission.rb

@@ -0,0 +1,116 @@
+module Locomotive::Wagon
+  class Server
+
+    # Mimic the submission of a content entry
+    #
+    class EntrySubmission < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        if self.request.post? && env['PATH_INFO'] =~ /^\/entry_submissions\/(.*)/
+          self.process_form($1)
+
+          if @entry.valid?
+            if self.html?
+              self.record_submitted_entry
+              self.redirect_to self.callback_url
+            elsif self.json?
+              self.json_response
+            end
+          else
+            if self.html?
+              if self.callback_url =~ /^http:\/\//
+                self.redirect_to self.callback_url
+              else
+                env['PATH_INFO'] = self.callback_url
+                self.liquid_assigns[@content_type.slug.singularize] = @entry
+                app.call(env)
+              end
+            elsif self.json?
+              self.json_response(422)
+            end
+          end
+        else
+          self.fetch_submitted_entry
+
+          app.call(env)
+        end
+      end
+
+      protected
+
+      def record_submitted_entry
+        self.request.session[:now] ||= {}
+        self.request.session[:now][:submitted_entry] = [@content_type.slug, @entry._slug]
+      end
+
+      def fetch_submitted_entry
+        if data = self.request.session[:now].try(:delete, :submitted_entry)
+          content_type = self.mounting_point.content_types[data.first.to_s]
+
+          entry = (content_type.entries || []).detect { |e| e._slug == data.last }
+
+          # do not keep track of the entry
+          content_type.entries.delete(entry) if entry
+
+          # add it to the additional liquid assigns for the next liquid rendering
+          if entry
+            self.liquid_assigns[content_type.slug.singularize] = entry
+          end
+        end
+      end
+
+      # Mimic the creation of a content entry with a minimal validation.
+      #
+      # @param [ String ] permalink The permalink (or slug) of the content type
+      #
+      #
+      def process_form(permalink)
+        permalink = permalink.split('.').first
+
+        @content_type = self.mounting_point.content_types[permalink]
+
+        raise "Unknown content type '#{@content_type.inspect}'" if @content_type.nil?
+
+        @entry = @content_type.build_entry(self.params[:entry] || self.params[:content])
+
+        # if not valid, we do not need to keep track of the entry
+        @content_type.entries.delete(@entry) if !@entry.valid?
+      end
+
+      def callback_url
+        (@entry.valid? ? params[:success_callback] : params[:error_callback]) || '/'
+      end
+
+      # Build the JSON response
+      #
+      # @param [ Integer ] status The HTTP return code
+      #
+      # @return [ Array ] The rack response depending on the validation status and the requested format
+      #
+      def json_response(status = 200)
+        locale = self.mounting_point.default_locale
+
+        if self.request.path =~ /^\/(#{self.mounting_point.locales.join('|')})+(\/|$)/
+          locale = $1
+        end
+
+        hash = @entry.to_hash(false).tap do |_hash|
+          if !@entry.valid?
+            _hash['errors'] = @entry.errors.inject({}) do |memo, name|
+              memo[name] = ::I18n.t('errors.messages.blank', locale: locale)
+              memo
+            end
+          end
+        end
+
+        [status, { 'Content-Type' => 'application/json' }, [
+          { @content_type.slug.singularize => hash }.to_json
+        ]]
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/wagon/server/favicon.rb

@@ -0,0 +1,17 @@
+module Locomotive::Wagon
+  class Server
+
+    class Favicon < Middleware
+
+      def call(env)
+        if env['PATH_INFO'] == '/favicon.ico'
+          [200, { 'Content-Type' => 'image/vnd.microsoft.icon' }, ['']]
+        else
+          app.call(env)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/wagon/server/locale.rb

@@ -0,0 +1,42 @@
+module Locomotive::Wagon
+  class Server
+
+    # Set the locale from the path if possible or use the default one
+    # Examples:
+    #   /fr/index   => locale = :fr
+    #   /fr/        => locale = :fr
+    #   /index      => locale = :en (default one)
+    #
+    class Locale < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        self.set_locale!(env)
+
+        app.call(env)
+      end
+
+      protected
+
+      def set_locale!(env)
+        locale  = self.mounting_point.default_locale
+
+        if self.path =~ /^(#{self.mounting_point.locales.join('|')})+(\/|$)/
+          locale    = $1
+          self.path = self.path.gsub($1 + $2, '')
+          self.path = 'index' if self.path.blank?
+        end
+
+        Locomotive::Mounter.locale = locale
+        ::I18n.locale = locale
+
+        self.log "Detecting locale #{locale.upcase}"
+
+        env['wagon.locale'] = locale
+        env['wagon.path']   = self.path
+      end
+
+    end
+  end
+end

data/lib/locomotive/wagon/server/logging.rb

@@ -0,0 +1,32 @@
+module Locomotive::Wagon
+  class Server
+
+    # Track the request into the current logger
+    #
+    class Logging < Middleware
+
+      def call(env)
+        now = Time.now
+
+        log "Started #{env['REQUEST_METHOD'].upcase} \"#{env['PATH_INFO']}\" at #{now}"
+
+        app.call(env).tap do |response|
+          done_in_ms = (Time.now - now) * 1000
+          log "Completed #{code_to_human(response.first)} in #{done_in_ms}ms\n\n"
+        end
+      end
+
+      protected
+
+      def code_to_human(code)
+        case code.to_i
+        when 200 then '200 OK'
+        when 301 then '301 Found'
+        when 302 then '302 Found'
+        when 404 then '404 Not Found'
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/wagon/server/middleware.rb

@@ -0,0 +1,59 @@
+module Locomotive::Wagon
+  class Server
+
+    class Middleware
+
+      attr_accessor :app, :request, :path, :liquid_assigns
+
+      attr_accessor :mounting_point, :page, :content_entry
+
+      def initialize(app = nil)
+        @app = app
+      end
+
+      def call(env)
+        app.call(env)
+      end
+
+      protected
+
+      def set_accessors(env)
+        self.path           = env['wagon.path']
+        self.request        = Rack::Request.new(env)
+        self.mounting_point = env['wagon.mounting_point']
+        self.page           = env['wagon.page']
+        self.content_entry  = env['wagon.content_entry']
+
+        env['wagon.liquid_assigns'] ||= {}
+        self.liquid_assigns = env['wagon.liquid_assigns']
+      end
+
+      def site
+        self.mounting_point.site
+      end
+
+      def params
+        self.request.params.deep_symbolize_keys
+      end
+
+      def html?
+        self.request.media_type == 'text/html' || !self.request.xhr?
+      end
+
+      def json?
+        self.request.content_type == 'application/json' || File.extname(self.request.path) == '.json'
+      end
+
+      def redirect_to(location, type = 301)
+        self.log "Redirected to #{location}"
+        [type, { 'Content-Type' => 'text/html', 'Location' => location }, []]
+      end
+
+      def log(msg)
+        Locomotive::Wagon::Logger.info msg
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/wagon/server/not_found.rb

@@ -0,0 +1,19 @@
+module Locomotive::Wagon
+  class Server
+
+    class NotFound < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        if self.page.nil?
+          self.log "Page not found"
+          env['wagon.page'] = self.mounting_point.pages['404']
+        end
+
+        app.call(env)
+      end
+
+    end
+  end
+end

data/lib/locomotive/wagon/server/page.rb

@@ -0,0 +1,61 @@
+module Locomotive::Wagon
+  class Server
+
+    # Sanitize the path from the previous middleware in order
+    # to make it work for the renderer.
+    #
+    class Page < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        self.set_page!(env)
+
+        app.call(env)
+      end
+
+      protected
+
+      def set_page!(env)
+        page = self.fetch_page
+
+        if page
+          self.log "Found page \"#{page.title}\" [/#{page.inspect}]"
+        end
+
+        env['wagon.page'] = page
+      end
+
+      def fetch_page
+        matchers = self.path_combinations(self.path)
+
+        self.mounting_point.pages.values.detect do |_page|
+          matchers.include?(_page.safe_fullpath) ||
+          matchers.include?(_page.safe_fullpath.try(:underscore))
+        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
+
+        (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]
+          end
+        end.flatten
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/wagon/server/path.rb

@@ -0,0 +1,34 @@
+module Locomotive::Wagon
+  class Server
+
+    # Sanitize the path from the previous middleware in order
+    # to make it work for the renderer.
+    #
+    class Path < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        self.set_path!(env)
+
+        app.call(env)
+      end
+
+      protected
+
+      def set_path!(env)
+        path = env['PATH_INFO'].clone
+
+        path.gsub!(/\.[a-zA-Z][a-zA-Z0-9]{2,}$/, '')
+        path.gsub!(/^\//, '')
+        path.gsub!(/^[A-Z]:\//, '')
+
+        path = 'index' if path.blank?
+
+        env['wagon.path'] = path
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/wagon/server/renderer.rb

@@ -0,0 +1,105 @@
+module Locomotive::Wagon
+  class Server
+
+    class Renderer < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        if self.page
+          if self.page.redirect?
+            self.redirect_to(self.page.redirect_url, self.page.redirect_type)
+          else
+            type = self.page.response_type || 'text/html'
+            html = self.render
+
+            self.log "  Rendered liquid page template"
+
+            [200, { 'Content-Type' => type }, [html]]
+          end
+        else
+          # no page at all, even not the 404 page
+          [404, { 'Content-Type' => 'text/html' }, ['Page not found']]
+        end
+      end
+
+      protected
+
+      def render
+        context = self.locomotive_context
+
+        template = ::Liquid::Template.parse(self.page.source, {
+          page:           self.page,
+          mounting_point: self.mounting_point
+        })
+
+        template.render(context)
+      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
+
+        # Tip: switch from false to true to enable the re-thrown exception flag
+        ::Liquid::Context.new({}, assigns, self.locomotive_default_registers, true)
+      end
+
+      # Return the default Liquid assigns used inside the Locomotive Liquid context
+      #
+      # @return [ Hash ] The default liquid assigns object
+      #
+      def locomotive_default_assigns
+        {
+          'site'              => self.site.to_liquid,
+          'page'              => self.page,
+          'models'            => Locomotive::Wagon::Liquid::Drops::ContentTypes.new,
+          'contents'          => Locomotive::Wagon::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,
+          'now'               => Time.now.utc,
+          'today'             => Date.today,
+          'locale'            => I18n.locale.to_s,
+          'default_locale'    => self.mounting_point.default_locale.to_s,
+          'locales'           => self.mounting_point.locales.map(&:to_s),
+          'current_user'      => {}
+        }
+      end
+
+      # Return the default Liquid registers used inside the Locomotive Liquid context
+      #
+      # @return [ Hash ] The default liquid registers object
+      #
+      def locomotive_default_registers
+        {
+          site:           self.site,
+          page:           self.page,
+          mounting_point: self.mounting_point,
+          inline_editor:  false
+        }
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/wagon/server/templatized_page.rb

@@ -0,0 +1,32 @@
+module Locomotive::Wagon
+  class Server
+
+    class TemplatizedPage < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        if self.page && self.page.templatized?
+          self.set_content_entry!(env)
+        end
+
+        app.call(env)
+      end
+
+      protected
+
+      def set_content_entry!(env)
+        %r(^#{self.page.safe_fullpath.gsub('*', '([^\/]+)')}$) =~ self.path
+
+        permalink = $1
+
+        if content_entry = self.page.content_type.find_entry(permalink)
+          env['wagon.content_entry'] = content_entry
+        else
+          env['wagon.page'] = nil
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/wagon/server.rb

@@ -0,0 +1,81 @@
+require 'rack/showexceptions'
+require 'coffee_script'
+
+require 'locomotive/wagon/listen'
+require 'locomotive/wagon/server/middleware'
+require 'locomotive/wagon/server/favicon'
+require 'locomotive/wagon/server/dynamic_assets'
+require 'locomotive/wagon/server/logging'
+require 'locomotive/wagon/server/entry_submission'
+require 'locomotive/wagon/server/path'
+require 'locomotive/wagon/server/locale'
+require 'locomotive/wagon/server/page'
+require 'locomotive/wagon/server/templatized_page'
+require 'locomotive/wagon/server/not_found'
+require 'locomotive/wagon/server/renderer'
+
+require 'locomotive/wagon/liquid'
+require 'locomotive/wagon/misc'
+
+module Locomotive::Wagon
+  class Server
+
+    def initialize(reader, options = {})
+      Locomotive::Wagon::Dragonfly.setup!(reader.mounting_point.path)
+
+      @reader = reader
+      @app    = self.create_rack_app(@reader)
+
+      unless options[:disable_listen]
+        Locomotive::Wagon::Listen.instance.start(@reader)
+      end
+    end
+
+    def call(env)
+      env['wagon.mounting_point'] = @reader.mounting_point
+      @app.call(env)
+    end
+
+    protected
+
+    def create_rack_app(reader)
+      Rack::Builder.new do
+        use Rack::ShowExceptions
+        use Rack::Lint
+
+        use Rack::Session::Cookie, {
+          key:          'rack.session',
+          domain:       '0.0.0.0',
+          path:         '/',
+          expire_after: 2592000,
+          secret:       'uselessinlocal'
+        }
+
+        use ::Dragonfly::Middleware, :images
+
+        use Rack::Static, {
+          urls: ['/images', '/fonts', '/samples'],
+          root: File.join(reader.mounting_point.path, 'public')
+        }
+
+        use Favicon
+        use DynamicAssets
+
+        use Logging
+
+        use EntrySubmission
+
+        use Path
+        use Locale
+
+        use Page
+        use TemplatizedPage
+        use NotFound
+        use Renderer
+
+        run Renderer.new
+      end
+    end
+
+  end
+end

data/lib/locomotive/wagon/standalone_server.rb

@@ -0,0 +1,28 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../..'))
+
+require 'locomotive/wagon/logger'
+require 'locomotive/wagon/version'
+require 'locomotive/wagon/exceptions'
+require 'locomotive/wagon/server'
+require 'locomotive/mounter'
+
+module Locomotive
+  module Wagon
+    class StandaloneServer < Server
+
+      def initialize(path)
+        Locomotive::Wagon::Logger.setup(path, false)
+
+        # get the reader
+        reader = Locomotive::Mounter::Reader::FileSystem.instance
+        reader.run!(path: path)
+        reader
+
+        Bundler.require 'misc'
+
+        # run the rack app
+        super(reader, disable_listen: true)
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/version.rb

@@ -0,0 +1,5 @@
+module Locomotive
+  module Wagon
+    VERSION = '1.0.0'
+  end
+end