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

data/lib/locomotive/steam/middlewares.rb

@@ -1,15 +1,9 @@
-require_relative 'middlewares/base'
+require_relative 'middlewares/threadsafe'
+require_relative 'middlewares/helpers'
 
-require_relative 'middlewares/favicon'
-require_relative 'middlewares/static_assets'
-require_relative 'middlewares/dynamic_assets'
-require_relative 'middlewares/logging'
-require_relative 'middlewares/entry_submission'
-require_relative 'middlewares/path'
-require_relative 'middlewares/locale'
-require_relative 'middlewares/page'
-require_relative 'middlewares/timezone'
-require_relative 'middlewares/templatized_page'
-require_relative 'middlewares/renderer'
+require_relative_all 'middlewares'
 
-require_relative 'middlewares/stack'
+module Locomotive::Steam
+  module Middlewares
+  end
+end

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

@@ -0,0 +1,25 @@
+module Locomotive::Steam
+  module Middlewares
+
+    class DefaultEnv < Struct.new(:app)
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        env['steam.request']        = request
+        env['steam.services']       = build_services(request)
+        env['steam.liquid_assigns'] = {}
+
+        app.call(env)
+      end
+
+      private
+
+      def build_services(request)
+        Locomotive::Steam::Services.build_instance(request)
+      end
+
+    end
+
+  end
+end

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

@@ -3,38 +3,55 @@ require 'coffee_script'
 module Locomotive::Steam
   module Middlewares
 
-    class DynamicAssets < Base
+    class DynamicAssets
 
       attr_reader :app, :regexp
 
-      def initialize(app)
-        super(app)
+      def initialize(app, options)
+        @app    = app
+        @regexp = /^\/(javascripts|stylesheets)\/(.*)$/o
 
-        @regexp = /^\/(javascripts|stylesheets)\/(.*)$/
-      end
+        @assets = ::Sprockets::Environment.new(options[:root]).tap do |env|
+          install_yui_compressor(env, options)
 
-      def call(env)
-        dup._call(env) # thread-safe purpose
+          %w(fonts stylesheets javascripts).each do |name|
+            env.append_path File.join(options[:root], name)
+          end
+        end
       end
 
-      def _call(env)
+      def call(env)
         if env['PATH_INFO'] =~ self.regexp
           env['PATH_INFO'] = $2
+          @assets.call(env)
+        else
+          app.call(env)
+        end
+      end
 
-          base_path = env['steam.mounting_point'].path
+      private
 
-          begin
-            sprockets = Locomotive::Mounter::Extensions::Sprockets.environment(base_path)
-            sprockets.call(env)
-          rescue Exception => e
-            raise Locomotive::Steam::DefaultException.new "Unable to serve a dynamic asset. Please check the logs.", e
-          end
+      def install_yui_compressor(sprockets, options)
+        return unless options[:minify]
+
+        require 'yui/compressor'
+
+        if is_java_installed?
+          # minify javascripts and stylesheets
+          sprockets.js_compressor  = YUI::JavaScriptCompressor.new
+          sprockets.css_compressor = YUI::CssCompressor.new
         else
-          app.call(env)
+          message = "[Important] YUICompressor requires java to be installed. The JAVA_HOME variable should also be set.\n"
+          Locomotive::Common::Logger.warn message.red
+          false
         end
       end
 
+      def is_java_installed?
+        `which java` != '' && (!ENV['JAVA_HOME'].blank? && File.exists?(ENV['JAVA_HOME']))
+      end
+
     end
 
   end
-end
+end

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

@@ -1,120 +1,158 @@
 module Locomotive::Steam
   module Middlewares
 
-    # Mimic the submission of a content entry
+    # Submit a content entry and persist it
     #
-    class EntrySubmission < Base
-
-      def _call(env)
-        super
-
-        if self.request.post? && env['PATH_INFO'] =~ /^\/entry_submissions\/(.*)/
-          self.process_form($1)
-
-          # puts "html? #{html?} / json? #{json?} / #{self.callback_url} / #{params.inspect}"
-
-          if @entry.valid?
-            if self.html?
-              self.record_submitted_entry
-              self.redirect_to self.callback_url
-            elsif self.json?
-              self.json_response
-            end
+    class EntrySubmission < ThreadSafe
+
+      include Helpers
+
+      HTTP_REGEXP             = /^https?:\/\//o
+      ENTRY_SUBMISSION_REGEXP = /^\/entry_submissions\/(\w+)/o
+      SUBMITTED_TYPE_PARAM    = 'submitted_type_slug'
+      SUBMITTED_PARAM         = 'submitted_entry_slug'
+
+      def _call
+        # we didn't go through the locale middleware yet,
+        # so set the locale manually. Needed to build a localized
+        # version of the entry + error messages (if present).
+        with_locale do
+          if slug = get_content_type_slug
+            entry = create_entry(slug)
+            navigation_behavior(entry)
           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
+            fetch_entry
           end
+        end
+      end
+
+      # Render or redirect depending on:
+      # - the status of the content entry (valid or not)
+      # - the presence of a callback or not
+      # - the type of response asked by the browser (html or json)
+      #
+      def navigation_behavior(entry)
+        if entry.errors.empty?
+          navigation_success(entry)
         else
-          self.fetch_submitted_entry
+          navigation_error(entry)
+        end
+      end
 
-          app.call(env)
+      def navigation_success(entry)
+        if html?
+          redirect_to success_location(entry_to_query_string(entry))
+        elsif json?
+          json_response(entry)
         end
       end
 
-      protected
+      def navigation_error(entry)
+        if html?
+          navigation_html_error(entry)
+        elsif json?
+          json_response(entry, 422)
+        end
+      end
 
-      def record_submitted_entry
-        self.request.session[:now] ||= {}
-        self.request.session[:now][:submitted_entry] = [@content_type.slug, @entry._slug]
+      def navigation_html_error(entry)
+        if error_location =~ HTTP_REGEXP
+          redirect_to error_location
+        else
+          env['PATH_INFO'] = error_location
+          store_in_liquid(entry)
+          self.next
+        end
       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]
+      private
+
+      def store_in_liquid(entry)
+        liquid_assigns[entry.content_type_slug.singularize] = entry
+      end
 
-          entry = (content_type.entries || []).detect { |e| e._slug == data.last }
+      def entry_to_query_string(entry)
+        type, slug = entry.content_type_slug, entry._slug
+        "#{SUBMITTED_TYPE_PARAM}=#{type}&#{SUBMITTED_PARAM}=#{slug}"
+      end
 
-          # do not keep track of the entry
-          content_type.entries.delete(entry) if entry
+      def with_locale(&block)
+        locale = default_locale || params[:locale]
 
-          # add it to the additional liquid assigns for the next liquid rendering
-          if entry
-            self.liquid_assigns[content_type.slug.singularize] = entry
-          end
+        if request.path_info =~ /^\/(#{site.locales.join('|')})+(\/|$)/
+          locale = $1
         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
+        services.locale = locale
 
-        @content_type = self.mounting_point.content_types[permalink]
+        I18n.with_locale(locale, &block)
+      end
 
-        raise "Unknown content type '#{@content_type.inspect}'" if @content_type.nil?
+      def success_location(query); location(:success, query); end
+      def error_location; location(:error); end
 
-        attributes = self.params[:entry] || self.params[:content] || {}
+      def location(state, query = '')
+        location = params[:"#{state}_callback"] || (entry_submissions_path? ? '/' : request.path_info)
 
-        @entry = @content_type.build_entry(attributes)
+        if query.blank?
+          location
+        else
+          location += (location.include?('?') ? '&' : '?') + query
+        end
+      end
 
-        # if not valid, we do not need to keep track of the entry
-        @content_type.entries.delete(@entry) if !@entry.valid?
+      def entry_submissions_path?
+        !(request.path_info =~ ENTRY_SUBMISSION_REGEXP).nil?
       end
 
-      def callback_url
-        (@entry.valid? ? params[:success_callback] : params[:error_callback]) || '/'
+      # Get the slug (or permalink) of the content type either from the PATH_INFO variable (old way)
+      # or from the presence of the content_type_slug param (model_form tag).
+      #
+      def get_content_type_slug
+        if request.post? && (request.path_info =~ ENTRY_SUBMISSION_REGEXP || params[:content_type_slug])
+          $1 || params[:content_type_slug]
+        end
       end
 
-      # Build the JSON response
+      # Create a content entry with a minimal validation.
       #
-      # @param [ Integer ] status The HTTP return code
+      # @param [ String ] slug The slug (or permalink) of the content type
       #
-      # @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
+      def create_entry(slug)
+        if entry = services.entry_submission.submit(slug, entry_attributes)
+          entry
+        else
+          raise %{Unknown content type "#{slug}"}
         end
+      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
+      # Get the content entry from the params.
+      #
+      def fetch_entry
+        if (type_slug = params[SUBMITTED_TYPE_PARAM]) && (slug = params[SUBMITTED_PARAM])
+          if entry = services.entry_submission.find(type_slug, slug)
+            store_in_liquid(entry)
           end
         end
+      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(entry, status = 200)
+        json = services.entry_submission.to_json(entry)
+        render_response(json, status, 'application/json')
+      end
 
-        [status, { 'Content-Type' => 'application/json' }, [
-          { @content_type.slug.singularize => hash }.to_json
-        ]]
+      def entry_attributes
+        HashConverter.to_sym(params[:entry] || params[:content] || {})
       end
 
     end
 
   end
-end
+end

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

@@ -1,10 +1,13 @@
 module Locomotive::Steam
   module Middlewares
 
-    class Favicon < Base
+    class Favicon < Struct.new(:app)
+
+      include Helpers
 
       def call(env)
         if env['PATH_INFO'] == '/favicon.ico'
+          # Default and empty Favicon rendered
           [200, { 'Content-Type' => 'image/vnd.microsoft.icon' }, ['']]
         else
           app.call(env)
@@ -14,4 +17,4 @@ module Locomotive::Steam
     end
 
   end
-end
+end

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

@@ -0,0 +1,44 @@
+module Locomotive::Steam
+  module Middlewares
+
+    module Helpers
+
+      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 render_response(content, code = 200, type = 'text/html')
+        @next_response = [code, { 'Content-Type' => type }, [content]]
+      end
+
+      def redirect_to(location, type = 301)
+        self.log "Redirected to #{location}".blue
+        @next_response = [type, { 'Content-Type' => 'text/html', 'Location' => location }, []]
+      end
+
+      def modify_path(path = nil, &block)
+        path ||= request.path
+
+        segments = path.split('/')
+        yield(segments)
+        path = segments.join('/')
+
+        path = '/' if path.blank?
+        path += "?#{request.query_string}" unless request.query_string.empty?
+        path
+      end
+
+      def log(msg, offset = 2)
+        Locomotive::Common::Logger.info (' ' * offset) + msg
+      end
+
+    end
+
+  end
+end

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

@@ -2,38 +2,46 @@ module Locomotive::Steam
   module Middlewares
 
     # 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 < Base
+    # The
+    #
+    class Locale < ThreadSafe
+
+      include Helpers
 
-      def _call(env)
-        super
+      def _call
+        locale = extract_locale
 
-        self.set_locale!(env)
+        log "Detecting locale #{locale.upcase}"
 
-        app.call(env)
+        I18n.with_locale(locale) do
+          self.next
+        end
       end
 
       protected
 
-      def set_locale!(env)
-        locale  = site.default_locale
-
-        if self.path =~ /^(#{self.site.locales.join('|')})+(\/|$)/
-          locale    = $1
-          self.path = self.path.gsub($1 + $2, '')
-          self.path = 'index' if self.path.blank?
-        end
+      def extract_locale
+        _locale = params[:locale] || default_locale
+        _path   = request.path_info
 
-        ::I18n.locale = locale
+        if _path =~ /^\/(#{site.locales.join('|')})+(\/|$)/
+          _locale  = $1
+          _path    = _path.gsub($1 + $2, '')
 
-        self.log "Detecting locale #{locale.upcase}"
+          # let the other middlewares that the locale was
+          # extracted from the path.
+          env['steam.locale_in_path'] = true
+        end
 
-        env['steam.locale'] = locale
-        env['steam.path']   = self.path
+        env['steam.path']   = _path
+        env['steam.locale'] = services.locale = _locale
       end
 
     end