locomotivecms_steam 0.1.0

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

@@ -0,0 +1,32 @@
+module Locomotive::Steam
+  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}".light_white
+
+        app.call(env).tap do |response|
+          done_in_ms = ((Time.now - now) * 10000).truncate / 10.0
+          log "Completed #{code_to_human(response.first)} in #{done_in_ms}ms\n\n".green
+        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/steam/server/middleware.rb

@@ -0,0 +1,61 @@
+module Locomotive::Steam
+  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['steam.path']
+        self.request        = Rack::Request.new(env)
+        self.mounting_point = env['steam.mounting_point']
+        self.page           = env['steam.page']
+        self.content_entry  = env['steam.content_entry']
+
+        env['steam.liquid_assigns'] ||= {}
+        self.liquid_assigns = env['steam.liquid_assigns']
+      end
+
+      def site
+        self.mounting_point.site
+      end
+
+      def params
+        self.request.params.deep_symbolize_keys
+      end
+
+      def html?
+        ['text/html', 'application/x-www-form-urlencoded'].include?(self.request.media_type) &&
+        !self.request.xhr? &&
+        !self.json?
+      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::Steam::Logger.info msg
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,69 @@
+module Locomotive::Steam
+  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.safe_fullpath}]"
+        end
+
+        env['steam.page'] = page
+      end
+
+      def fetch_page
+        
+
+        matchers = self.path_combinations(self.path)
+
+        pages = self.mounting_point.pages.values.find_all do |_page|
+          matchers.include?(_page.safe_fullpath) ||
+          matchers.include?(_page.safe_fullpath.try(:underscore))
+        end.sort_by { |p| p.position || Float::INFINITY }
+
+        if pages.size > 1
+          self.log "Found multiple pages: #{pages.collect(&:title).join(', ')}"
+        end
+
+        pages.first
+      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/steam/server/path.rb

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

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

@@ -0,0 +1,118 @@
+module Locomotive::Steam
+  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_page
+
+            self.log 'Rendered liquid page template'
+
+            [200, { 'Content-Type' => type }, [html]]
+          end
+        else
+          [404, { 'Content-Type' => 'text/html' }, [self.render_404]]
+        end
+      end
+
+      protected
+
+      def render_page
+        context = self.locomotive_context
+        begin
+          self.page.render(context)
+        rescue Exception => e
+          raise RendererException.new(e, self.page.title, self.page.template, context)
+        end
+      end
+
+      def render_404
+        if self.page = self.mounting_point.pages['404']
+          self.render_page
+        else
+          'Page not found'
+        end
+      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::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.mounting_point.default_locale.to_s,
+          'locales'           => self.mounting_point.locales.map(&:to_s),
+          'current_user'      => {},
+          'session'           => Locomotive::Steam::Liquid::Drops::SessionProxy.new,
+          'steam'             => true,
+          'editing'           => false
+        }
+      end
+
+      # Return the default Liquid registers used inside the Locomotive Liquid context
+      #
+      # @return [ Hash ] The default liquid registers object
+      #
+      def locomotive_default_registers
+        {
+          request:        self.request,
+          site:           self.site,
+          page:           self.page,
+          mounting_point: self.mounting_point,
+          inline_editor:  false,
+          logger:         Locomotive::Steam::Logger
+        }
+      end
+
+    end
+
+  end
+end

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

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

data/lib/locomotive/steam/server/timezone.rb

@@ -0,0 +1,18 @@
+module Locomotive::Steam
+  class Server
+
+    # Set the timezone according to the settings of the site
+    #
+    class Timezone < Middleware
+
+      def call(env)
+        self.set_accessors(env)
+
+        Time.use_zone(site.try(:timezone) || 'UTC') do
+          app.call(env)
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/standalone_server.rb

@@ -0,0 +1,33 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../..'))
+
+require_relative 'logger'
+require_relative 'version'
+require_relative 'exceptions'
+require_relative 'server'
+
+require 'locomotive/mounter'
+
+module Locomotive
+  module Steam
+    class StandaloneServer < Server
+
+      def initialize(path, options={})
+        options.fetch(:logger) do
+          Locomotive::Steam::Logger.setup(path, false)
+        end
+
+        reader = options.fetch(:reader) do
+          _reader = Locomotive::Mounter::Reader::FileSystem.instance
+          Proc.new { |_path| _reader.run!(path: _path) }
+        end
+        reader.call path
+
+        Bundler.require 'monkey_patches'
+        Bundler.require 'initializers'
+
+        # run the rack app
+        super(reader, disable_listen: true)
+      end
+    end
+  end
+end

data/lib/locomotive/steam/version.rb

@@ -0,0 +1,5 @@
+module Locomotive
+  module Steam
+    VERSION = '0.1.0'
+  end
+end

data/lib/steam.rb

@@ -0,0 +1,4 @@
+require_relative 'locomotive/steam/version'
+require_relative 'locomotive/steam/logger'
+require_relative 'locomotive/steam/exceptions'
+

data/locomotivecms_steam.gemspec

@@ -0,0 +1,42 @@
+require_relative 'lib/steam'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'locomotivecms_steam'
+  spec.version       = Locomotive::Steam::VERSION
+  spec.authors       = ['Didier Lafforgue', 'Rodrigo Alvarez', 'Arnaud Sellenet', 'Joel Azemar']
+  spec.email         = ['did@locomotivecms.com', 'papipo@gmail.com', 'arnaud@sellenet.fr', 'joel.azemar@gmail.com']
+  spec.description   = %q{The LocomotiveCMS steam is a front end server LocomotiveCMS libraries}
+  spec.summary       = %q{The LocomotiveCMS steam is a technical piece for compiled and steam front end stuff for LocomotiveCMS libraries}
+  spec.homepage      = 'http://www.locomotivecms.com'
+  spec.homepage      = 'https://github.com/locomotivecms/steam'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '~> 10.1'
+  spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'launchy'
+  spec.add_development_dependency 'vcr'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'i18n-spec'
+
+  spec.add_dependency 'rack-cache',            '~> 1.1'
+  spec.add_dependency 'sprockets',             '~> 2.0'
+  spec.add_dependency 'sprockets-sass',        '~> 1.0'
+  spec.add_dependency 'better_errors',         '~> 1.0'
+  spec.add_dependency 'dragonfly',             '~> 0.9'
+  spec.add_dependency 'activesupport',         '~> 3.2'
+  spec.add_dependency 'listen',                '~> 2.7'
+  spec.add_dependency 'will_paginate',         '~> 3.0'
+  spec.add_dependency 'redcarpet',             '~> 3.1'
+
+  spec.add_dependency 'locomotivecms_mounter'
+  spec.add_dependency 'locomotivecms-solid'
+
+  spec.required_ruby_version = '~> 2.0'
+end