locomotivecms_steam 0.1.0

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

@@ -0,0 +1,36 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        class PathTo < ::Liquid::Tag
+
+          include PathHelper
+
+          Syntax = /(#{::Liquid::Expression}+)(#{::Liquid::TagAttributes}?)/
+
+          def initialize(tag_name, markup, tokens, context)
+            if markup =~ Syntax
+              @handle = $1
+              @_options = {}
+              markup.scan(::Liquid::TagAttributes) do |key, value|
+                @_options[key] = value
+              end
+            else
+              raise SyntaxError.new("Syntax Error in 'path_to' - Valid syntax: path_to <page|page_handle|content_entry>(, locale: [fr|de|...], with: <page_handle>")
+            end
+
+            super
+          end
+
+          def render(context)
+            render_path(context)
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('path_to', PathTo)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+        module SEO
+
+          class Base < ::Liquid::Tag
+
+            def render(context)
+              %{
+                #{self.render_title(context)}
+                #{self.render_metadata(context)}
+              }
+            end
+
+            protected
+
+            def render_title(context)
+              title = self.value_for(:seo_title, context)
+              title = context.registers[:site].name if title.blank?
+
+              %{
+                <title>#{title}</title>
+              }
+            end
+
+            def render_metadata(context)
+              %{
+                <meta name="description" content="#{self.value_for(:meta_description, context)}" />
+                <meta name="keywords" content="#{self.value_for(:meta_keywords, context)}" />
+              }
+            end
+
+            # Removes whitespace and quote characters from the input
+            def sanitized_string(string)
+              string ? string.strip.gsub(/"/, '') : ''
+            end
+
+            def value_for(attribute, context)
+              object = self.metadata_object(context)
+              value = object.try(attribute.to_sym).blank? ? context.registers[:site].send(attribute.to_sym) : object.send(attribute.to_sym)
+              self.sanitized_string(value)
+            end
+
+            def metadata_object(context)
+              context['content_instance'] || context['page']
+            end
+          end
+
+          class Title < Base
+
+            def render(context)
+              self.render_title(context)
+            end
+
+          end
+
+          class Metadata < Base
+
+            def render(context)
+              self.render_metadata(context)
+            end
+
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('seo', SEO::Base)
+        ::Liquid::Template.register_tag('seo_title', SEO::Title)
+        ::Liquid::Template.register_tag('seo_metadata', SEO::Metadata)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        # Assign sets a variable in your session.
+        #
+        #   {% session_assign foo = 'monkey' %}
+        #
+        # You can then use the variable later in the page.
+        #
+        #   {{ session.foo }}
+        #
+        class SessionAssign < ::Liquid::Tag
+          Syntax = /(#{::Liquid::VariableSignature}+)\s*=\s*(#{::Liquid::QuotedFragment}+)/
+
+          def initialize(tag_name, markup, tokens, options)
+            if markup =~ Syntax
+              @to = $1
+              @from = $2
+            else
+              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.session_assign"), options[:line])
+            end
+
+            super
+          end
+
+          def render(context)
+            request = context.registers[:request]
+
+            request.session[@to.to_sym] = context[@from]
+            ''
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('session_assign', SessionAssign)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        class Snippet < ::Liquid::Include
+
+          def render(context)
+            name    = @template_name.gsub(/[\"\']/, '')
+            snippet = context.registers[:mounting_point].snippets[name]
+
+            raise ::Liquid::StandardError.new("Unknown snippet \"#{name}\"") if snippet.nil?
+
+            partial   = self.parse_template(snippet)
+
+            variable  = context[@variable_name || @template_name[1..-2]]
+
+            context.stack do
+              @attributes.each do |key, value|
+                context[key] = context[value]
+              end
+
+              output = (if variable.is_a?(Array)
+                variable.collect do |variable|
+                  context[@template_name[1..-2]] = variable
+                  partial.render(context)
+                end
+              else
+                context[@template_name[1..-2]] = variable
+                partial.render(context)
+              end)
+
+              Locomotive::Steam::Logger.info "  Steamed snippet #{name}"
+
+              output
+            end
+          end
+
+          protected
+
+          def parse_template(snippet)
+            begin
+              ::Liquid::Template.parse(snippet.source)
+            rescue ::Liquid::Error => e
+              # do it again on the raw source instead so that the error line matches
+              # the source file.
+              begin
+                ::Liquid::Template.parse(snippet.template.raw_source)
+              rescue ::Liquid::Error => e
+                e.backtrace.unshift "#{snippet.template.filepath}:#{e.line + 1}:in `#{snippet.name}'"
+                e.line = self.line - 1
+                raise e
+              end
+            end
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('include', Snippet)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+        class WithScope < ::Liquid::Block
+
+          SlashedString = /\/[^\/]*\//
+          TagAttributes = /(\w+|\w+\.\w+)\s*\:\s*(#{SlashedString}|#{::Liquid::QuotedFragment})/
+
+          def initialize(tag_name, markup, tokens, options)
+            @tag_options = HashWithIndifferentAccess.new
+            markup.scan(TagAttributes) do |key, value|
+              @tag_options[key] = value
+            end
+            super
+          end
+
+          def render(context)
+            context.stack do
+              context['with_scope'] = decode(@tag_options, context)
+              render_all(@nodelist, context)
+            end
+          end
+
+          private
+
+          def decode(attributes, context)
+            attributes.each_pair do |key, value|
+              attributes[key] = (case value
+              when /^true|false$/i    then value == 'true'
+              when /^\/[^\/]*\/$/     then Regexp.new(value[1..-2])
+              when /^["|'](.+)["|']$/ then $1.gsub(/^["|']/, '').gsub(/["|']$/, '')
+              else
+                context[value] || value
+              end)
+            end
+          end
+        end
+
+        ::Liquid::Template.register_tag('with_scope', WithScope)
+      end
+    end
+  end
+end

data/lib/locomotive/steam/listen.rb

@@ -0,0 +1,64 @@
+require 'listen'
+
+module Locomotive::Steam
+  class Listen
+
+    attr_accessor :reader
+
+    def self.instance
+      @@instance = new
+    end
+
+    def start(reader)
+      # if $parent_pid && $parent_pid == Process.pid
+      #   puts "bypassing Listen in the parent process"
+      #   return false
+      # end
+
+      puts "Listening here: #{Process.pid}"
+
+      self.reader = reader
+
+      self.definitions.each do |definition|
+        self.apply(definition)
+      end
+    end
+
+    def definitions
+      [
+        ['config', /\.yml/, [:site, :content_types, :pages, :snippets, :content_entries, :translations]],
+        ['app/views', /\.liquid/, [:pages, :snippets]],
+        ['app/content_types', /\.yml/, [:content_types, :content_entries]],
+        ['data', /\.yml/, :content_entries]
+      ]
+    end
+
+    protected
+
+    def apply(definition)
+      reloader = Proc.new do |modified, added, removed|
+        resources = [*definition.last]
+        names     = resources.map { |n| "\"#{n}\"" }.join(', ')
+
+        Locomotive::Steam::Logger.info "* Reloaded #{names} at #{Time.now}"
+
+        begin
+          reader.reload(resources)
+        rescue Exception => e
+          Locomotive::Steam::MounterException.new('Unable to reload', e)
+        end
+      end
+
+      filter  = definition[1]
+      path    = File.join(self.reader.mounting_point.path, definition.first)
+      path    = File.expand_path(path)
+
+      listener = ::Listen.to(path, only: filter, &reloader)
+
+      # non blocking listener
+      listener.start #(false)
+    end
+
+  end
+
+end

data/lib/locomotive/steam/logger.rb

@@ -0,0 +1,54 @@
+module Locomotive
+  module Steam
+
+    class Logger
+
+      attr_accessor :logger, :logfile_path, :stdout
+
+      def initialize
+        self.logger = nil
+      end
+
+      # Setup the single instance of the ruby logger.
+      #
+      # @param [ String ] path The path to the log file (default: log/steam.log)
+      # @param [ Boolean ] stdout Instead of having a file, log to the standard output
+      #
+      def setup(path, stdout = false)
+        require 'logger'
+
+        self.stdout = stdout
+
+        self.logfile_path = File.expand_path(File.join(path, 'log', 'steam.log'))
+        FileUtils.mkdir_p(File.dirname(logfile_path))
+
+        out = self.stdout ? STDOUT : self.logfile_path
+
+        self.logger = ::Logger.new(out).tap do |log|
+          log.level     = ::Logger::DEBUG
+          log.formatter = proc do |severity, datetime, progname, msg|
+            "#{msg}\n"
+          end
+        end
+      end
+
+      def self.instance
+        @@instance ||= self.new
+      end
+
+      def self.setup(path, stdout = false)
+        self.instance.setup(path, stdout)
+      end
+
+      class << self
+        %w(debug info warn error fatal unknown).each do |name|
+          define_method(name) do |message|
+            self.instance.logger.send(name.to_sym, message)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/monkey_patches.rb

@@ -0,0 +1,5 @@
+require_relative 'monkey_patches/httparty.rb'
+require_relative 'monkey_patches/dragonfly.rb'
+require_relative 'monkey_patches/mounter.rb'
+require_relative 'monkey_patches/haml.rb'
+require_relative 'monkey_patches/better_errors.rb'

data/lib/locomotive/steam/monkey_patches/better_errors.rb

@@ -0,0 +1,70 @@
+require 'ostruct'
+
+module BetterErrors
+  class MiddlewareWrapper
+
+    def initialize(app)
+      @@middleware ||= BetterErrors::Middleware.new(app)
+      @@middleware.instance_variable_set(:@app, app)
+    end
+
+    def call(env)
+      env['action_dispatch.request.parameters'] = Rack::Request.new(env).params
+
+      @@middleware.call(env)
+    end
+
+  end
+
+  module FrameWithLiquidContext
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      attr_accessor :liquid_context
+
+      alias_method_chain :local_variables, :liquid_context
+
+      class << self
+
+        alias_method_chain :from_exception, :liquid_context
+
+      end
+    end
+
+    def local_variables_with_liquid_context
+      if self.liquid_context
+        scope = self.liquid_context.scopes.last.clone
+
+        scope.delete_if { |k, _| %w(models contents params session).include?(k) }.tap do |_scope|
+          _scope['site'] = _scope['site'].send(:_source).to_hash
+          _scope['page'] = _scope['page'].to_hash.delete_if { |k, _| %w(template).include?(k) }
+        end
+      else
+        self.local_variables_without_liquid_context
+      end
+    rescue Exception => e
+      puts "[BetterError] Fatal error: #{e.message}".red
+      puts e.backtrace.join("\n")
+      {}
+    end
+
+    module ClassMethods
+
+      def from_exception_with_liquid_context(exception)
+        from_exception_without_liquid_context(exception).tap do |list|
+          if exception.respond_to?(:liquid_context)
+            list.first.liquid_context = exception.liquid_context
+          end
+        end
+      end
+
+    end
+  end
+
+  class StackFrame
+    include FrameWithLiquidContext
+  end
+
+end