locomotivecms_builder 1.0.0.alpha1

data/lib/locomotive/builder/server/dynamic_assets.rb

@@ -0,0 +1,31 @@
+module Locomotive::Builder
+  class Server
+
+    class DynamicAssets < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        path = env['PATH_INFO']
+
+        if path =~ /^\/(stylesheets|javascripts)\//
+
+          mime_type = MIME::Types.type_for(path).first.try(:to_s) || 'text/plain'
+          asset     = self.mounting_point.theme_assets.detect do |_asset|
+            _asset.path == path
+          end
+
+          if asset
+            [200, { 'Content-Type' => mime_type }, [asset.content!]]
+          else
+            [404, { 'Content-Type' => mime_type }, ['Asset not found']]
+          end
+        else
+          app.call(env)
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,116 @@
+module Locomotive::Builder
+  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/builder/server/favicon.rb

@@ -0,0 +1,17 @@
+module Locomotive::Builder
+  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/builder/server/locale.rb

@@ -0,0 +1,42 @@
+module Locomotive::Builder
+  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
+
+        puts "[Builder|Locale] path = #{self.path.inspect}, locale = #{locale.inspect}"
+
+        env['builder.locale'] = locale
+        env['builder.path']   = self.path
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Locomotive::Builder
+  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['builder.path']
+        self.request        = Rack::Request.new(env)
+        self.mounting_point = env['builder.mounting_point']
+        self.page           = env['builder.page']
+        self.content_entry  = env['builder.content_entry']
+
+        env['builder.liquid_assigns'] ||= {}
+        self.liquid_assigns = env['builder.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)
+        [301, { 'Content-Type' => 'text/html', 'Location' => location }, []]
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,18 @@
+module Locomotive::Builder
+  class Server
+
+    class NotFound < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        if self.page.nil?
+          env['builder.page'] = self.mounting_point.pages['404']
+        end
+
+        app.call(env)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Locomotive::Builder
+  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
+
+        puts "[Builder|Page] #{page.inspect}"
+
+        env['builder.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/builder/server/path.rb

@@ -0,0 +1,34 @@
+module Locomotive::Builder
+  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['builder.path'] = path
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,105 @@
+module Locomotive::Builder
+  class Server
+
+    class Renderer < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        puts "[Builder|Renderer] page = #{page.inspect}"
+
+        if self.page
+          if self.page.redirect?
+            [self.page.redirect_type, { 'Location' => self.page.redirect_url, 'Content-Type' => 'text/html' }, []]
+          else
+            type = self.page.response_type || 'text/html'
+            html = self.render
+
+            [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::Builder::Liquid::Drops::ContentTypes.new,
+          'contents'          => Locomotive::Builder::Liquid::Drops::ContentTypes.new,
+          'current_page'      => self.params[:page],
+          'params'            => self.params,
+          '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/builder/server/templatized_page.rb

@@ -0,0 +1,32 @@
+module Locomotive::Builder
+  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['builder.content_entry'] = content_entry
+        else
+          env['builder.page'] = nil
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/builder/server.rb

@@ -0,0 +1,78 @@
+require 'rack/showexceptions'
+require 'coffee_script'
+
+require 'locomotive/builder/listen'
+require 'locomotive/builder/server/middleware'
+require 'locomotive/builder/server/favicon'
+require 'locomotive/builder/server/dynamic_assets'
+require 'locomotive/builder/server/entry_submission'
+require 'locomotive/builder/server/path'
+require 'locomotive/builder/server/locale'
+require 'locomotive/builder/server/page'
+require 'locomotive/builder/server/templatized_page'
+require 'locomotive/builder/server/not_found'
+require 'locomotive/builder/server/renderer'
+
+require 'locomotive/builder/liquid'
+require 'locomotive/builder/misc'
+
+module Locomotive::Builder
+  class Server
+
+    def initialize(reader, options = {})
+      Locomotive::Builder::Dragonfly.setup!(reader.mounting_point.path)
+
+      @reader = reader
+      @app    = self.create_rack_app(@reader)
+
+      unless options[:disable_listen]
+        Locomotive::Builder::Listen.instance.start(@reader)
+      end
+    end
+
+    def call(env)
+      env['builder.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 EntrySubmission
+
+        use Path
+        use Locale
+
+        use Page
+        use TemplatizedPage
+        use NotFound
+        use Renderer
+
+        run Renderer.new
+      end
+    end
+
+  end
+end

data/lib/locomotive/builder/standalone_server.rb

@@ -0,0 +1,33 @@
+require "locomotive/builder/server"
+$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../..'))
+
+require 'locomotive/builder/version'
+require 'locomotive/builder/exceptions'
+require 'locomotive/mounter'
+
+module Locomotive
+  module Builder
+    class StandaloneServer < Server
+      
+      def initialize(path)
+        # setting the logger
+        logfile = File.join(path, 'log', 'mounter.log')
+        FileUtils.mkdir_p(File.dirname(logfile))
+
+        Locomotive::Mounter.logger = ::Logger.new(logfile).tap do |log|
+          log.level = Logger::DEBUG
+        end
+
+        # get the reader
+        reader = Locomotive::Mounter::Reader::FileSystem.instance
+        reader.run!(path: path)
+        reader
+
+        # run the rack app
+        Bundler.require 'misc'
+        
+        super(reader, disable_listen: true)
+      end
+    end
+  end
+end

data/lib/locomotive/builder/version.rb

@@ -0,0 +1,5 @@
+module Locomotive
+  module Builder
+    VERSION = '1.0.0.alpha1'
+  end
+end