locomotivecms_steam 0.1.0

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

@@ -0,0 +1,79 @@
+module Locomotive
+  module Steam
+    class Dragonfly
+
+      attr_accessor :path, :enabled
+
+      def enabled?
+        !!self.enabled
+      end
+
+      def resize_url(source, resize_string)
+        _source = (case source
+        when String then source
+        when Hash   then source['url'] || source[:url]
+        else
+          source.try(:url)
+        end)
+
+        if _source.blank?
+          Locomotive::Steam::Logger.error "Unable to resize on the fly: #{source.inspect}"
+          return
+        end
+
+        return _source unless self.enabled?
+
+        if _source =~ /^http/
+          file = self.class.app.fetch_url(_source)
+        else
+          file = self.class.app.fetch_file(File.join(self.path, 'public', _source))
+        end
+
+        file.process(:thumb, resize_string).url
+      end
+
+      def self.app
+        ::Dragonfly[:images]
+      end
+
+
+      def self.instance
+        @@instance ||= new
+      end
+
+      def self.setup!(path)
+        self.instance.path    = path
+        self.instance.enabled = false
+
+        begin
+          require 'rack/cache'
+          require 'dragonfly'
+
+          ## initialize Dragonfly ##
+          app = ::Dragonfly[:images].configure_with(:imagemagick)
+
+          ## configure it ##
+          ::Dragonfly[:images].configure do |c|
+            convert = `which convert`.strip.presence || '/usr/bin/env convert'
+            c.convert_command  = convert
+            c.identify_command = convert
+
+            c.allow_fetch_url  = true
+            c.allow_fetch_file = true
+
+            c.url_format = '/images/dynamic/:job/:basename.:format'
+          end
+
+          self.instance.enabled = true
+        rescue Exception => e
+          
+          Locomotive::Steam::Logger.warn %{
+[Dragonfly] !disabled!
+[Dragonfly] If you want to take full benefits of all the features in the LocomotiveSteam, we recommend you to install ImageMagick and RMagick. Check out the documentation here: http://doc.locomotivecms.com/editor/installation.
+}
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Haml::Filters
+
+  remove_filter("Markdown") #remove the existing Markdown filter
+
+  module Markdown # the contents of this are as before, but without the lazy_require call
+
+    include Haml::Filters::Base
+
+    def render text
+      Locomotive::Steam::Markdown.steam text
+    end
+
+  end
+
+end

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

@@ -0,0 +1,46 @@
+require 'uri'
+
+module Locomotive
+  module Steam
+    module Httparty
+      class Webservice
+
+        include ::HTTParty
+
+        def self.consume(url, options = {})
+          url = ::HTTParty.normalize_base_uri(url)
+
+          uri = URI.parse(url)
+          options[:base_uri] = "#{uri.scheme}://#{uri.host}"
+          options[:base_uri] += ":#{uri.port}" if uri.port != 80
+          path = uri.request_uri
+
+          options.delete(:format) if options[:format] == 'default'
+
+          username, password = options.delete(:username), options.delete(:password)
+          options[:basic_auth] = { username: username, password: password } if username
+
+          path ||= '/'
+
+          # Locomotive::Steam::Logger.debug "[WebService] consuming #{path}, #{options.inspect}"
+
+          response = self.get(path, options)
+
+          if response.code == 200
+            _response = response.parsed_response
+            if _response.respond_to?(:underscore_keys)
+              _response.underscore_keys
+            else
+              _response.collect(&:underscore_keys)
+            end
+          else
+            Locomotive::Steam::Logger.error "[WebService] consumed #{path}, #{options.inspect}, response = #{response.inspect}"
+            nil
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Locomotive
+  module Mounter
+    module Models
+      class Page
+
+        def render(context)
+          self.parse(context).render(context)
+        end
+
+        protected
+
+        def parse(context)
+          options =  {
+            page:           self,
+            mounting_point: context.registers[:mounting_point],
+            error_mode:     :strict,
+            count_lines:    true
+          }
+
+          begin
+            template = ::Liquid::Template.parse(self.source, options)
+          rescue Liquid::SyntaxError => e
+            # do it again on the raw source instead so that the error line matches
+            # the source file.
+            ::Liquid::Template.parse(self.template.raw_source, options)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/server.rb

@@ -0,0 +1,81 @@
+require 'better_errors'
+require 'coffee_script'
+
+require_relative 'listen'
+require_relative 'server/middleware'
+require_relative 'server/favicon'
+require_relative 'server/dynamic_assets'
+require_relative 'server/logging'
+require_relative 'server/entry_submission'
+require_relative 'server/path'
+require_relative 'server/locale'
+require_relative 'server/page'
+require_relative 'server/timezone'
+require_relative 'server/templatized_page'
+require_relative 'server/renderer'
+
+require_relative 'liquid'
+require_relative 'initializers'
+require_relative 'monkey_patches'
+
+module Locomotive::Steam
+  class Server
+
+    def initialize(reader, options = {})
+      Locomotive::Steam::Dragonfly.setup!(reader.mounting_point.path)
+
+      Sprockets::Sass.add_sass_functions = false
+
+      @reader = reader
+      @app    = self.create_rack_app(@reader)
+
+      BetterErrors.application_root = reader.mounting_point.path
+    end
+
+    def call(env)
+      env['steam.mounting_point'] = @reader.mounting_point
+      @app.call(env)
+    end
+
+    protected
+
+    def create_rack_app(reader)
+      Rack::Builder.new do
+        use Rack::Lint
+
+        use BetterErrors::MiddlewareWrapper
+
+        use Rack::Session::Cookie, {
+          key:          'steam.session',
+          path:         '/',
+          expire_after: 2592000,
+          secret:       'uselessinlocal'
+        }
+
+        use ::Dragonfly::Middleware, :images
+
+        use Rack::Static, {
+          urls: ['/images', '/fonts', '/samples', '/media'],
+          root: File.join(reader.mounting_point.path, 'public')
+        }
+
+        use Favicon
+        use DynamicAssets, reader.mounting_point.path
+
+        use Logging
+
+        use EntrySubmission
+
+        use Path
+        use Locale
+        use Timezone
+
+        use Page
+        use TemplatizedPage
+
+        run Renderer.new
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,33 @@
+module Locomotive::Steam
+  class Server
+
+    class DynamicAssets < Middleware
+
+      attr_reader :app, :sprockets, :regexp
+
+      def initialize(app, site_path)
+        super(app)
+
+        @regexp     = /^\/(javascripts|stylesheets)\/(.*)$/
+
+        @sprockets  = Locomotive::Mounter::Extensions::Sprockets.environment(site_path)
+      end
+
+      def call(env)
+        if env['PATH_INFO'] =~ self.regexp
+          env['PATH_INFO'] = $2
+
+          begin
+            self.sprockets.call(env)
+          rescue Exception => e
+            raise Locomotive::Steam::DefaultException.new "Unable to serve a dynamic asset. Please check the logs.", e
+          end
+        else
+          app.call(env)
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,120 @@
+module Locomotive::Steam
+  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)
+
+          # 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
+          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?
+
+        attributes = self.params[:entry] || self.params[:content] || {}
+
+        @entry = @content_type.build_entry(attributes)
+
+        # 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/steam/server/favicon.rb

@@ -0,0 +1,18 @@
+module Locomotive::Steam
+  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/steam/server/locale.rb

@@ -0,0 +1,42 @@
+module Locomotive::Steam
+  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
+
+        self.log "Detecting locale #{locale.upcase}"
+
+        env['steam.locale'] = locale
+        env['steam.path']   = self.path
+      end
+
+    end
+  end
+end