locomotivecms_steam 1.2.1 → 1.3.0.rc1

data/lib/locomotive/steam/initializers/sprockets.rb

@@ -2,69 +2,13 @@ require 'sprockets'
 require 'sass'
 require 'coffee_script'
 require 'compass'
+require 'uglifier'
 require 'autoprefixer-rails'
-require 'open3'
 
 require 'execjs'
 
 module Locomotive::Steam
 
-  class YUICompressorRuntimeError < RuntimeError
-    attr_reader :errors
-    #:nocov:
-    def initialize(msg, errors)
-      super(msg)
-      @errors = errors
-    end
-  end
-
-  module YUICompressorErrors
-
-    #:nocov:
-    def compress(stream_or_string)
-      streamify(stream_or_string) do |stream|
-        tempfile      = new_tempfile(stream)
-        full_command  = "%s %s" % [command, tempfile.path]
-
-        output, errors, exit_status = _compress(full_command, tempfile)
-
-        if exit_status.exitstatus.zero?
-          output
-        else
-          # Bourne shells tend to blow up here when the command fails, usually
-          # because java is missing
-          raise YUICompressorRuntimeError.new("Command '%s' returned non-zero exit status" %
-            full_command, errors)
-        end
-      end
-    end
-
-    #:nocov:
-    def _compress(command, tempfile)
-      begin
-        # FIXME: catch only useful information from the stderr output
-        # output, errors, exit_status = '', [], nil
-        output, errors, exit_status = Open3.capture3(command)
-        errors = errors.split("\n").find_all { |l| l =~ /\s+[0-9]/ }
-        [output, errors, exit_status]
-      rescue Exception => e
-        # windows shells tend to blow up here when the command fails
-        raise RuntimeError, "compression failed: %s" % e.message
-      ensure
-        tempfile.close!
-      end
-    end
-
-    #:nocov:
-    def new_tempfile(stream)
-      Tempfile.new('yui_compress').tap do |tempfile|
-        tempfile.write stream.read
-        tempfile.flush
-      end
-    end
-
-  end
-
   class SprocketsEnvironment < ::Sprockets::Environment
 
     attr_reader :steam_path
@@ -76,7 +20,7 @@ module Locomotive::Steam
 
       append_steam_paths
 
-      install_yui_compressor(options)
+      install_minifiers if options[:minify]
 
       install_autoprefixer
 
@@ -97,24 +41,10 @@ module Locomotive::Steam
       Compass::Frameworks::ALL.each { |f| append_path(f.stylesheets_directory) }
     end
 
-    def install_yui_compressor(options)
-      return unless options[:minify]
-
-      if is_java_installed?
-        require 'yui/compressor'
-
-        [YUI::JavaScriptCompressor, YUI::CssCompressor].each do |klass|
-          klass.send(:include, YUICompressorErrors)
-        end
-
-        # minify javascripts and stylesheets
-        self.js_compressor  = YUI::JavaScriptCompressor.new
-        self.css_compressor = YUI::CssCompressor.new
-      else
-        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
+    def install_minifiers
+      # minify javascripts and stylesheets
+      self.js_compressor  = :uglify
+      self.css_compressor = :scss
     end
 
     def install_autoprefixer
@@ -134,10 +64,6 @@ module Locomotive::Steam
       end
     end
 
-    def is_java_installed?
-      `which java` != '' && (!ENV['JAVA_HOME'].blank? && File.exists?(ENV['JAVA_HOME']))
-    end
-
   end
 
 end

data/lib/locomotive/steam/liquid/drops/page.rb

@@ -4,7 +4,7 @@ module Locomotive
       module Drops
         class Page < I18nBase
 
-          delegate :fullpath, :depth, :seo_title, :meta_keywords, :meta_description, :redirect_url, :handle, to: :@_source
+          delegate :position, :fullpath, :depth, :seo_title, :meta_keywords, :meta_description, :redirect_url, :handle, to: :@_source
           delegate :listed?, :published?, :redirect?, :is_layout?, :templatized?, to: :@_source
 
           def title
@@ -30,7 +30,14 @@ module Locomotive
           end
 
           def breadcrumbs
-            @breadcrumbs ||= liquify(*repository.ancestors_of(@_source))
+            return @breadcrumbs if @breadcrumbs
+
+            # remove the last one and replace it by the current instance
+            # which may have a valid reference to a content entry (if templatized)
+            pages = liquify(*repository.ancestors_of(@_source))
+            pages.pop
+
+            @breadcrumbs = pages + [self]
           end
 
           def children

data/lib/locomotive/steam/liquid/filters/date.rb

@@ -66,6 +66,115 @@ module Locomotive
             I18n.l input, format: format, locale: locale
           end
 
+          def end_of_year(input)
+            return '' if input.blank?
+
+            if input.respond_to? :end_of_year
+              return input.end_of_year
+            end
+
+            if input.is_a?(String)
+              Time.zone.parse(input).end_of_year rescue ''
+            end
+          end
+
+          def beginning_of_year(input)
+            return '' if input.blank?
+
+            if input.respond_to? :beginning_of_year
+              return input.beginning_of_year
+            end
+
+            if input.is_a?(String)
+              Time.zone.parse(input).beginning_of_year rescue ''
+            end
+          end
+
+          def end_of_month(input)
+            return '' if input.blank?
+
+            if input.respond_to? :end_of_month
+              return input.end_of_month
+            end
+
+            if input.is_a?(String)
+              Time.zone.parse(input).end_of_month rescue ''
+            end
+          end
+
+          def beginning_of_month(input)
+            return '' if input.blank?
+
+            if input.respond_to? :beginning_of_month
+              return input.beginning_of_month
+            end
+
+            if input.is_a?(String)
+              Time.zone.parse(input).beginning_of_month rescue ''
+            end
+          end
+
+          def end_of_week(input)
+            return '' if input.blank?
+
+            if input.respond_to? :end_of_week
+              return input.end_of_week
+            end
+
+            if input.is_a?(String)
+              Time.zone.parse(input).end_of_week rescue ''
+            end
+          end
+
+          def beginning_of_week(input)
+            return '' if input.blank?
+
+            if input.respond_to? :beginning_of_week
+              return input.beginning_of_week
+            end
+
+            if input.is_a?(String)
+              Time.zone.parse(input).beginning_of_week rescue ''
+            end
+          end
+
+          def end_of_day(input)
+            return '' if input.blank?
+
+            if input.respond_to? :end_of_day
+              return input.end_of_day
+            end
+
+            if input.is_a?(String)
+              Time.zone.parse(input).end_of_day rescue ''
+            end
+          end
+
+          def beginning_of_day(input)
+            return '' if input.blank?
+
+            if input.respond_to? :beginning_of_day
+              return input.beginning_of_day
+            end
+
+            if input.is_a?(String)
+              Time.zone.parse(input).beginning_of_day rescue ''
+            end
+          end
+
+          def adjust_date(input, adjustment, unit)
+            return '' if input.blank?
+
+            adjustment = adjustment.to_i
+            unit = unit.to_sym
+
+            if (adjustment.respond_to? unit)
+              input + adjustment.send(unit)
+            else
+              input
+            end
+          end
+
           alias :format_date :localized_date
 
           private

data/lib/locomotive/steam/liquid/tags/action.rb

@@ -38,7 +38,12 @@ module Locomotive
 
           def render(context)
             Locomotive::Common::Logger.info "[action] executing #{@description}"
-            service(context).run(super, safe_params(context), context)
+            begin
+              service(context).run(super, safe_params(context), context)
+            rescue Locomotive::Steam::ActionError => e
+              e.action = @description
+              raise e
+            end
             ''
           end
 

data/lib/locomotive/steam/liquid/tags/authorize.rb

@@ -0,0 +1,65 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        # Redirect the current site visitor to another page if she/he
+        # is not authenticated.
+        # More information about the authentication feature here:
+        # https://locomotive-v3.readme.io/v3.3/docs/introduction-1
+        #
+        # The Liquid tag requires 2 parameters:
+        # - the slug of the content type used for the authentication (a content type with a password field)
+        # - the handle of the page we want the user to be redirected to if unauthenticated
+        #
+        # Basically the authorize tag checks if the liquid context has
+        # a reference to the current authenticated content entry.
+        # If not, it raises a redirection exception forcing the Steam middleware stack
+        # to process a HTTP redirection.
+        #
+        # Example:
+        #
+        #   {% authorize 'accounts', 'sign_in' %}
+        #
+        class Authorize < ::Liquid::Tag
+
+          Syntax = /(#{::Liquid::QuotedString}+)\s*,\s*(#{::Liquid::QuotedString}+)/o
+
+          def initialize(tag_name, markup, options)
+            if markup =~ Syntax
+              @content_type_slug, @page_handle = $1.try(:gsub, /['"]/, ''), $2.try(:gsub, /['"]/, '')
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'authorize' - Valid syntax: authorize [content type slug], [page handle]")
+            end
+
+            super
+          end
+
+          def render(context)
+            @context = context
+
+            unless authenticated_entry = context["current_#{@content_type_slug.singularize}"]
+              services.page_redirection.redirect_to(@page_handle, locale)
+            end
+
+            ''
+          end
+
+          private
+
+          def locale
+            @context.registers[:locale]
+          end
+
+          def services
+            @context.registers[:services]
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('authorize'.freeze, Authorize)
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/liquid/tags/snippet.rb

@@ -6,7 +6,7 @@ module Locomotive
         class Snippet < ::Liquid::Include
 
           def parse(tokens)
-            ActiveSupport::Notifications.instrument("steam.parse.include", page: options[:page], name: @template_name)
+            ActiveSupport::Notifications.instrument('steam.parse.include', page: options[:page], name: @template_name)
 
             # look for editable elements
             name = evaluate_snippet_name
@@ -17,7 +17,15 @@ module Locomotive
 
           def render(context)
             @template_name = evaluate_snippet_name(context)
-            super
+            # @options doesn't include the page key if cache is on
+            @options[:page] = context.registers[:page]
+
+            begin
+              super
+            rescue Locomotive::Steam::ParsingRenderingError => e
+              e.file = @template_name + ' [Snippet]'
+              raise e
+            end
           end
 
           private

data/lib/locomotive/steam/liquid/template.rb

@@ -21,7 +21,9 @@ module Locomotive
 
           def parse(source, options = {})
             template = new
-            template.parse(source, options)
+            template.parse(source, options.merge({
+              line_numbers: true
+            }))
           end
 
         end

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

@@ -0,0 +1,187 @@
+module Locomotive::Steam
+  module Middlewares
+
+    # Process all the authentication actions:
+    # - sign in
+    # - new reset password
+    # - reset password
+    # - sign out
+    #
+    # It is also in charge to load the current authenticated resource
+    # from the session and put it in the liquid context.
+    #
+    class Auth < ThreadSafe
+
+      include Helpers
+
+      def _call
+        load_authenticated_entry
+
+        auth_options = AuthOptions.new(site, params)
+
+        return unless auth_options.valid?
+
+        send(:"#{auth_options.action}", auth_options)
+      end
+
+      private
+
+      def sign_in(options)
+        return if authenticated?
+
+        status, entry = services.auth.sign_in(options)
+
+        if status == :signed_in
+          store_authenticated(entry)
+          redirect_to options.callback || mounted_on
+        end
+
+        append_message(status)
+      end
+
+      def sign_out(options)
+        return unless authenticated?
+
+        store_authenticated(nil)
+
+        append_message(:signed_out)
+      end
+
+      def forgot_password(options)
+        return if authenticated?
+
+        status = services.auth.forgot_password(options, default_liquid_context)
+
+        append_message(status)
+      end
+
+      def reset_password(options)
+        return if authenticated?
+
+        status, entry = services.auth.reset_password(options)
+
+        if status == :password_reset
+          store_authenticated(entry)
+          redirect_to options.callback || mounted_on
+        end
+
+        append_message(status)
+      end
+
+      def load_authenticated_entry
+        entry_type = request.session[:authenticated_entry_type]
+        entry_id   = request.session[:authenticated_entry_id]
+
+        if entry = services.auth.find_authenticated_resource(entry_type, entry_id)
+          env['authenticated_entry'] = entry
+          liquid_assigns["current_#{entry_type.singularize}"] = entry
+        end
+      end
+
+      def authenticated?
+        !!env['authenticated_entry']
+      end
+
+      def store_authenticated(entry)
+        type = entry ? entry.content_type.slug : request.session[:authenticated_entry_type]
+
+        request.session[:authenticated_entry_type]  = type.to_s
+        request.session[:authenticated_entry_id]    = entry.try(:_id).to_s
+
+        log "[Auth] authenticated #{type.to_s.singularize} ##{entry.try(:_id).to_s}"
+
+        liquid_assigns["current_#{type.singularize}"] = entry
+      end
+
+      def append_message(message)
+        log "[Auth] status message = #{message.inspect}"
+
+        message ||= 'error'
+        liquid_assigns["auth_#{message}"] = "auth_#{message}"
+      end
+
+      class AuthOptions
+
+        ACTIONS = %w(sign_in sign_out forgot_password reset_password)
+
+        attr_reader :site, :params
+
+        def initialize(site, params)
+          @site, @params = site, params
+        end
+
+        def valid?
+          ACTIONS.include?(action)
+        end
+
+        def action
+          params[:auth_action]
+        end
+
+        def type
+          params[:auth_content_type]
+        end
+
+        def id_field
+          params[:auth_id_field] || :email
+        end
+
+        def password_field
+          params[:auth_password_field].try(:to_sym) || :password
+        end
+
+        def id
+          params[:auth_id]
+        end
+
+        def password
+          params[:auth_password]
+        end
+
+        def callback
+          params[:auth_callback]
+        end
+
+        def reset_password_url
+          params[:auth_reset_password_url]
+        end
+
+        def reset_token
+          params[:auth_reset_token]
+        end
+
+        def from
+          params[:auth_email_from] || 'support@locomotivecms.com'
+        end
+
+        def subject
+          params[:auth_email_subject] || 'Instructions for changing your password'
+        end
+
+        def email_handle
+          params[:auth_email_handle]
+        end
+
+        def smtp
+          name = params[:auth_email_smtp_namespace] || 'smtp'
+          namespace = site.metafields.try(:[], name)
+
+          if namespace.blank?
+            Locomotive::Common::Logger.error "[Auth] Missing SMTP settings in the Site metafields. Namespace: #{name}".light_red
+            return {}
+          end
+
+          {
+            address:    namespace[params[:auth_email_smtp_address_alias] || 'address'],
+            port:       namespace[params[:auth_email_smtp_port_alias] || 'port'],
+            user_name:  namespace[params[:auth_email_smtp_user_name_alias] || 'user_name'],
+            password:   namespace[params[:auth_email_smtp_password_alias] || 'password']
+          }
+        end
+
+      end
+
+    end
+
+  end
+end