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

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

@@ -24,19 +24,20 @@ module Locomotive
 
           # map/collect on a given property (support to_f, to_i)
           def map(input, property)
-            flatten_if_necessary(input).map do |e|
+            ::Liquid::StandardFilters::InputIterator.new(input).map do |e|
               e = e.call if e.is_a?(Proc)
 
-              if property == "to_liquid"
+              if property == "to_liquid".freeze
                 e
-              elsif property == "to_f"
+              elsif property == 'to_f'.freeze
                 e.to_f
-              elsif property == "to_i"
+              elsif property == 'to_i'.freeze
                 e.to_i
               elsif e.respond_to?(:[])
                 e[property]
               end
             end
+
           end
 
         end
@@ -46,4 +47,4 @@ module Locomotive
       end
     end
   end
-end
+end

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

@@ -0,0 +1,55 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Filters
+        module Pagination
+
+          # Render the navigation for a paginated collection
+          def default_pagination(paginate, *args)
+            return '' if paginate['parts'].empty?
+
+            options = args_to_options(args)
+
+            previous_link = default_pagination_next_or_previous_link(:previous, paginate, options, 'prev')
+            next_link     = default_pagination_next_or_previous_link(:next, paginate, options, 'next')
+            links         = default_pagination_links(paginate)
+
+            %{<div class="pagination #{options[:css]}">
+                #{previous_link}
+                #{links}
+                #{next_link}
+              </div>}
+          end
+
+          private
+
+          def default_pagination_links(paginate)
+            paginate['parts'].map do |part|
+              if part['is_link']
+                "<a href=\"#{absolute_url(part['url'])}\">#{part['title']}</a>"
+              elsif part['hellip_break']
+                "<span class=\"gap\">#{part['title']}</span>"
+              else
+                "<span class=\"current\">#{part['title']}</span>"
+              end
+            end.join
+          end
+
+          def default_pagination_next_or_previous_link(type, paginate, options, css)
+            label = options[:"#{type}_label"] || I18n.t("pagination.#{type}")
+
+            if paginate[type.to_s].blank?
+              "<span class=\"disabled #{css}_page\">#{label}</span>"
+            else
+              "<a href=\"#{absolute_url(paginate[type.to_s]['url'])}\" class=\"#{css}_page\">#{label}</a>"
+            end
+          end
+
+        end
+
+        ::Liquid::Template.register_filter(Pagination)
+
+      end
+    end
+  end
+end

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

@@ -5,8 +5,7 @@ module Locomotive
         module Resize
 
           def resize(input, resize_string)
-            dragonfly = @context.registers[:services][:dragonfly]
-            dragonfly.resize_url(input, resize_string)
+            @context.registers[:services].image_resizer.resize(input, resize_string) || input
           end
 
         end
@@ -16,4 +15,4 @@ module Locomotive
       end
     end
   end
-end
+end

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

@@ -4,16 +4,6 @@ module Locomotive
       module Filters
         module Text
 
-          # right justify and padd a string
-          def rjust(input, integer, padstr = '')
-            input.to_s.rjust(integer, padstr)
-          end
-
-          # left justify and padd a string
-          def ljust(input, integer, padstr = '')
-            input.to_s.ljust(integer, padstr)
-          end
-
           def underscore(input)
             input.to_s.gsub(' ', '_').gsub('/', '_').underscore
           end
@@ -22,6 +12,10 @@ module Locomotive
             input.to_s.gsub(' ', '-').gsub('/', '-').dasherize
           end
 
+          def encode(input)
+            Rack::Utils.escape(input)
+          end
+
           # alias newline_to_br
           def multi_line(input)
             input.to_s.gsub("\n", '<br/>')
@@ -33,16 +27,22 @@ module Locomotive
             result
           end
 
-          def encode(input)
-            Rack::Utils.escape(input)
+          # right justify and padd a string
+          def rjust(input, integer, padstr = '')
+            input.to_s.rjust(integer, padstr)
+          end
+
+          # left justify and padd a string
+          def ljust(input, integer, padstr = '')
+            input.to_s.ljust(integer, padstr)
           end
 
           def textile(input)
-            ::RedCloth.new(input).to_html
+            @context.registers[:services].textile.to_html(input)
           end
 
           def markdown(input)
-            Locomotive::Steam::Markdown.steam(input)
+            @context.registers[:services].markdown.to_html(input)
           end
 
         end
@@ -52,4 +52,4 @@ module Locomotive
       end
     end
   end
-end
+end

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

@@ -2,22 +2,13 @@ module Locomotive
   module Steam
     module Liquid
       module Filters
-        module Translate
 
-          def translate(key, locale = nil, scope = nil)
-            locale ||= I18n.locale.to_s
-            if scope.blank?
-              translation = @context.registers[:mounting_point].translations[key.to_s]
+        module Translate
 
-              if translation
-                translation.get(locale) || translation.get(Locomotive::Mounter.locale.to_s)
-              else
-                "[unknown translation key: #{key}]"
-              end
-            else
-              I18n.t(key, scope: scope.split('.'), locale: locale)
-            end
+          def translate(input, locale = nil, scope = nil)
+            @context.registers[:services].translator.translate(input, locale, scope) || input
           end
+
         end
 
         ::Liquid::Template.register_filter(Translate)
@@ -25,4 +16,4 @@ module Locomotive
       end
     end
   end
-end
+end

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

@@ -1,31 +1,10 @@
 module Liquid
-
-  class Drop
-
-    def site
-      @context.registers[:site]
-    end
-
-  end
-
-  class Template
-
-    # creates a new <tt>Template</tt> object from liquid source code
-    parse_method = instance_method(:parse)
-
-    define_method :parse do |source, context={}|
-      if RUBY_VERSION =~ /1\.9/
-        source = source.force_encoding('UTF-8') if source.present?
-      end
-      parse_method.bind(self).call(source, context)
-    end
-
-  end
-
   module StandardFilters
 
     private
 
+    # Fixme: Handle DateTime, Date and Time objects, convert them
+    # into seconds (integer)
     def to_number(obj)
       case obj
       when Numeric
@@ -38,6 +17,33 @@ module Liquid
         0
       end
     end
+
   end
+end
 
+module Liquid
+  module OptionsBuilder
+
+    private
+
+    def parse_options_from_string(string)
+      string.try(:strip!)
+
+      return nil if string.blank?
+
+      string = string.gsub(/^(\s*,)/, '')
+      Solid::Arguments.parse(string)
+    end
+
+    def interpolate_options(options, context)
+      if options
+        options.interpolate(context).first
+      else
+        {}
+      end
+    end
+
+  end
 end
+
+Liquid::Tag.send(:include, Liquid::OptionsBuilder)

data/lib/locomotive/steam/liquid/tags/concerns/i18n_page.rb

@@ -0,0 +1,36 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+        module Concerns
+
+          module I18nPage
+
+            def change_page_locale(locale, drop, &block)
+              page = drop.send(:_source)
+
+              page.__with_locale__(locale) do
+                if page.templatized?
+                  page.content_entry.__with_locale__(locale) { yield }
+                else
+                  yield
+                end
+              end
+            end
+
+            # def build_fullpath(page)
+            #   services.url_builder.url_for(page, locale).tap do |fullpath|
+            #     if page.templatized?
+            #       entry = page.send(:_source).content_entry
+            #       fullpath.gsub!('content_type_template', entry._slug)
+            #     end
+            #   end
+            # end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/steam/liquid/tags/concerns/path.rb

@@ -0,0 +1,114 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+        module Concerns
+          module Path
+
+            Syntax = /(#{::Liquid::VariableSignature}+)(\s*,.+)?/o
+
+            def initialize(tag_name, markup, options)
+              if markup =~ Syntax
+                @handle, _options = $1, $2
+
+                # FIXME: the with option needs a string with quotes.
+                # this is a hack for sites which don't follow the new syntax.
+                make_options_compatible_with_previous_version(_options)
+
+                @raw_path_options = parse_options_from_string(_options)
+              else
+                self.wrong_syntax!
+              end
+
+              super
+            end
+
+            def render_path(context, &block)
+              set_vars_from_context(context)
+
+              # return a drop or model?
+              if page = self.retrieve_page_drop_from_handle
+                # make sure we've got the page/content entry (if templatized)
+                # in the right locale
+                change_page_locale(locale, page) do
+                  path = build_fullpath(page)
+
+                  block_given? ? block.call(page, path) : path
+                end
+              else
+                '' # no page found
+              end
+            end
+
+            protected
+
+            def services
+              @context.registers[:services]
+            end
+
+            def repository
+              services.repositories.page
+            end
+
+            def retrieve_page_drop_from_handle
+              handle = @context[@handle] || @handle
+
+              case handle
+              when String
+                _retrieve_page_drop_from(handle)
+              when Locomotive::Steam::Liquid::Drops::ContentEntry
+                _retrieve_templatized_page_drop_from(handle)
+              when Locomotive::Steam::Liquid::Drops::Page
+                handle
+              else
+                nil
+              end
+            end
+
+            def _retrieve_page_drop_from(handle)
+              if page = repository.by_handle(handle)
+                page.to_liquid.tap { |d| d.context = @context }
+              end
+            end
+
+            def _retrieve_templatized_page_drop_from(drop)
+              entry = drop.send(:_source)
+
+              if page = repository.template_for(entry, @path_options[:with])
+                page.to_liquid.tap { |d| d.context = @context }
+              end
+            end
+
+            def build_fullpath(page)
+              services.url_builder.url_for(page.send(:_source), locale)
+            end
+
+            def locale
+              @path_options[:locale] || @locale
+            end
+
+            def set_vars_from_context(context)
+              @context      = context
+              @path_options = evaluate_path_options(context)
+              @site         = context.registers[:site]
+              @locale       = context.registers[:locale]
+            end
+
+            def evaluate_path_options(context)
+              interpolate_options(@raw_path_options, context)
+            end
+
+            def make_options_compatible_with_previous_version(options)
+              if options
+                %w(with locale).each do |name|
+                  options.gsub!(/#{name}: ([\w-]+)/, name + ': "\1"')
+                end
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,12 +1,13 @@
 module Locomotive
   module Steam
     module Liquid
-        module Tags
+      module Tags
+
         # Consume web services as easy as pie directly in liquid !
         #
         # Usage:
         #
-        # {% consume blog from 'http://nocoffee.tumblr.com/api/read.json?num=3', username: 'john', password: 'easy', format: 'json', expires_in: 3000 %}
+        # {% consume blog from 'http://nocoffee.tumblr.com/api/read.json?num=3' username: 'john', password: 'easy', format: 'json', expires_in: 3000 %}
         #   {% for post in blog.posts %}
         #     {{ post.title }}
         #   {% endfor %}
@@ -14,28 +15,29 @@ module Locomotive
         #
         class Consume < ::Liquid::Block
 
-          Syntax = /(#{::Liquid::VariableSignature}+)\s*from\s*(#{::Liquid::QuotedString}|#{::Liquid::VariableSignature}+)/
+          Syntax = /(#{::Liquid::VariableSignature}+)\s*from\s*(#{::Liquid::QuotedString}|#{::Liquid::VariableSignature}+)(.*)?/o
 
-          def initialize(tag_name, markup, tokens, options)
+          def initialize(tag_name, markup, options)
             if markup =~ Syntax
-              @target = $1
+              @name = $1.to_s
 
               self.prepare_url($2)
-              self.prepare_options(markup)
+              @api_options = parse_options_from_string($3)
             else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.consume"), options[:line])
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'consume' - Valid syntax: consume <var> from \"<url>\" [username: value, password: value]")
             end
 
-            @local_cache_key = self.hash
-
             super
           end
 
           def render(context)
+            self.set_api_options(context)
+
             if instance_variable_defined? :@variable_name
               @url = context[@variable_name]
             end
-            render_all_without_cache(context)
+
+            render_all_and_cache_it(context)
           end
 
           protected
@@ -43,60 +45,54 @@ module Locomotive
           def prepare_url(token)
             if token.match(::Liquid::QuotedString)
               @url = token.gsub(/['"]/, '')
-            elsif token.match(::Liquid::VariableSignature)
-              @variable_name = token
             else
-              raise ::Liquid::SyntaxError.new("Syntax Error in 'consume' - Valid syntax: consume <var> from \"<url>\" [username: value, password: value]")
-            end
-          end
-
-          def prepare_options(markup)
-            @options = {}
-            markup.scan(::Liquid::TagAttributes) do |key, value|
-              @options[key] = value if key != 'http'
+              @variable_name = token
             end
-            @options['timeout'] = @options['timeout'].to_f if @options['timeout']
-            @expires_in = (@options.delete('expires_in') || 0).to_i
           end
 
-          def cached_response
-            @@local_cache ||= {}
-            @@local_cache[@local_cache_key]
+          def set_api_options(context)
+            @api_options  = interpolate_options(@api_options, context)
+            @expires_in   = @api_options.delete(:expires_in) || 0
           end
 
-          def cached_response=(response)
-            @@local_cache ||= {}
-            @@local_cache[@local_cache_key] = response
+          def render_all_and_cache_it(context)
+            cache_service(context).fetch(page_fragment_cache_key, expires_in: @expires_in, force: @expires_in == 0) do
+              self.render_all_without_cache(context)
+            end
           end
 
           def render_all_without_cache(context)
             context.stack do
               begin
-                context.scopes.last[@target.to_s] = external_api_service(context).consume(@url, @options.symbolize_keys)
-
-                self.cached_response = context.scopes.last[@target.to_s]
+                context.scopes.last[@name] = service(context).consume(@url, @api_options)
               rescue Timeout::Error
-                context.scopes.last[@target.to_s] = self.cached_response
-              rescue ::Liquid::Error => e
-                raise e
-              rescue => e
-                liquid_e = ::Liquid::Error.new(e.message, line)
-                liquid_e.set_backtrace(e.backtrace)
-                raise liquid_e
+                context.scopes.last[@name] = last_response(context)
               end
 
-              render_all(@nodelist, context)
+              @body.render(context)
             end
           end
 
-          def external_api_service(context)
-            context.registers[:services][:external_api]
+          def service(context)
+            context.registers[:services].external_api
+          end
+
+          def cache_service(context)
+            context.registers[:services].cache
+          end
+
+          def last_response(context)
+            cache_service(context).read(page_fragment_cache_key)
+          end
+
+          def page_fragment_cache_key
+            Digest::SHA1.hexdigest(@name + @url)
           end
 
         end
 
-        ::Liquid::Template.register_tag('consume', Consume)
+        ::Liquid::Template.register_tag('consume'.freeze, Consume)
       end
     end
   end
-end
+end