locomotivecms_steam 0.1.0

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

@@ -0,0 +1,49 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Filters
+        module Misc
+
+          # was called modulo at first
+          def str_modulo(word, index, modulo)
+            (index.to_i + 1) % modulo == 0 ? word : ''
+          end
+
+          # Get the nth element of the passed in array
+          def index(array, position)
+            array.at(position) if array.respond_to?(:at)
+          end
+
+          def default(input, value)
+            input.blank? ? value : input
+          end
+
+          def random(input)
+            rand(input.to_i)
+          end
+
+          # map/collect on a given property (support to_f, to_i)
+          def map(input, property)
+            flatten_if_necessary(input).map do |e|
+              e = e.call if e.is_a?(Proc)
+
+              if property == "to_liquid"
+                e
+              elsif property == "to_f"
+                e.to_f
+              elsif property == "to_i"
+                e.to_i
+              elsif e.respond_to?(:[])
+                e[property]
+              end
+            end
+          end
+
+        end
+
+        ::Liquid::Template.register_filter(Misc)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Filters
+        module Resize
+
+          def resize(input, resize_string)
+            Locomotive::Steam::Dragonfly.instance.resize_url(input, resize_string)
+          end
+
+        end
+
+        ::Liquid::Template.register_filter(Resize)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Locomotive
+  module Steam
+    module Liquid
+      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
+
+          def dasherize(input)
+            input.to_s.gsub(' ', '-').gsub('/', '-').dasherize
+          end
+
+          # alias newline_to_br
+          def multi_line(input)
+            input.to_s.gsub("\n", '<br/>')
+          end
+
+          def concat(input, *args)
+            result = input.to_s
+            args.flatten.each { |a| result << a.to_s }
+            result
+          end
+
+          def encode(input)
+            Rack::Utils.escape(input)
+          end
+
+          def textile(input)
+            ::RedCloth.new(input).to_html
+          end
+
+          def markdown(input)
+            Locomotive::Steam::Markdown.steam(input)
+          end
+
+        end
+
+        ::Liquid::Template.register_filter(Text)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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]
+
+              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
+          end
+        end
+
+        ::Liquid::Template.register_filter(Translate)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Liquid
+
+  class Drop
+
+    def mounting_point
+      @context.registers[:mounting_point]
+    end
+
+    def site
+      @context.registers[:site]
+    end
+
+  end
+
+  class Template
+
+    # creates a new <tt>Template</tt> object from liquid source code
+    def parse_with_utf8(source, context = {})
+      if RUBY_VERSION =~ /1\.9/
+        source = source.force_encoding('UTF-8') if source.present?
+      end
+      self.parse_without_utf8(source, context)
+    end
+
+    alias_method_chain :parse, :utf8
+
+  end
+
+  module StandardFilters
+
+    private
+
+    def to_number(obj)
+      case obj
+      when Numeric
+        obj
+      when String
+        (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
+      when DateTime, Date, Time
+        obj.to_time.to_i
+      else
+        0
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,149 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Scopeable
+
+        def apply_scope(entries)
+          if @context['with_scope'].blank?
+            entries
+          else
+            # extract the conditions
+            _conditions = @context['with_scope'].clone.delete_if { |k, _| %w(order_by per_page page).include?(k) }
+
+            # build the chains of conditions
+            conditions = _conditions.map { |name, value| Condition.new(name, value) }
+
+            Locomotive::Steam::Logger.info "[with_scope] conditions: #{conditions.map(&:to_s).join(', ')}"
+
+            # get only the entries matching ALL the conditions
+            _entries = entries.find_all do |content|
+              accepted = true
+
+              conditions.each do |_condition|
+                unless _condition.matches?(content)
+                  accepted = false
+                  break # no to go further
+                end
+              end
+
+              accepted
+            end
+
+            self._apply_scope_order(_entries, @context['with_scope']['order_by'])
+          end
+        end
+
+        def _apply_scope_order(entries, order_by)
+          return entries if order_by.blank?
+
+          name, direction = order_by.split.map(&:to_sym)
+
+          Locomotive::Steam::Logger.info "[with_scope] order_by #{name} #{direction || 'asc'}"
+
+          if direction == :asc || direction.nil?
+            entries.sort { |a, b| a.send(name) <=> b.send(name) }
+          else
+            entries.sort { |a, b| b.send(name) <=> a.send(name) }
+          end
+        end
+
+        class Condition
+
+          OPERATORS = %w(all gt gte in lt lte ne nin size)
+
+          attr_accessor :name, :operator, :right_operand
+
+          def initialize(name, value)
+            self.name, self.right_operand = name, value
+
+            self.process_right_operand
+
+            # default value
+            self.operator = :==
+
+            self.decode_operator_based_on_name
+          end
+
+          def matches?(entry)
+            value = self.get_value(entry)
+
+            self.decode_operator_based_on_value(value)
+
+            case self.operator
+            when :==      then value == self.right_operand
+            when :ne      then value != self.right_operand
+            when :matches then self.right_operand =~ value
+            when :gt      then value > self.right_operand
+            when :gte     then value >= self.right_operand
+            when :lt      then value < self.right_operand
+            when :lte     then value <= self.right_operand
+            when :size    then value.size == self.right_operand
+            when :all     then [*self.right_operand].contains?(value)
+            when :in, :nin
+              _matches = if value.is_a?(Array)
+                [*value].contains?([*self.right_operand])
+              else
+                [*self.right_operand].include?(value)
+              end
+              self.operator == :in ? _matches : !_matches
+            else
+              raise UnknownConditionInScope.new("#{self.operator} is unknown or not implemented.")
+            end
+          end
+
+          def to_s
+            "#{name} #{operator} #{self.right_operand.to_s}"
+          end
+
+          protected
+
+          def get_value(entry)
+            value = entry.send(self.name)
+
+            if value.respond_to?(:_slug)
+              # belongs_to
+              value._slug
+            elsif value.respond_to?(:map)
+              # many_to_many or tags ?
+              value.map { |v| v.respond_to?(:_slug) ? v._slug : v }
+            else
+              value
+            end
+          end
+
+          def process_right_operand
+            if self.right_operand.respond_to?(:_slug)
+              # belongs_to
+              self.right_operand = self.right_operand._slug
+            elsif self.right_operand.respond_to?(:map) && self.right_operand.first.respond_to?(:_slug)
+              # many_to_many
+              self.right_operand = self.right_operand.map do |entry|
+                entry.try(&:_slug)
+              end
+            end
+          end
+
+          def decode_operator_based_on_name
+            if name =~ /^([a-z0-9_-]+)\.(#{OPERATORS.join('|')})$/
+              self.name     = $1.to_sym
+              self.operator = $2.to_sym
+            end
+
+            if self.right_operand.is_a?(Regexp)
+              self.operator = :matches
+            end
+          end
+
+          def decode_operator_based_on_value(value)
+            case value
+            when Array
+              self.operator = :in if self.operator == :==
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Locomotive
+  module Steam
+    module Liquid
+        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 %}
+        #   {% for post in blog.posts %}
+        #     {{ post.title }}
+        #   {% endfor %}
+        # {% endconsume %}
+        #
+        class Consume < ::Liquid::Block
+
+          Syntax = /(#{::Liquid::VariableSignature}+)\s*from\s*(#{::Liquid::QuotedString}|#{::Liquid::VariableSignature}+)/
+
+          def initialize(tag_name, markup, tokens, options)
+            if markup =~ Syntax
+              @target = $1
+
+              self.prepare_url($2)
+              self.prepare_options(markup)
+            else
+              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.consume"), options[:line])
+            end
+
+            @local_cache_key = self.hash
+
+            super
+          end
+
+          def render(context)
+            if instance_variable_defined? :@variable_name
+              @url = context[@variable_name]
+            end
+            render_all_without_cache(context)
+          end
+
+          protected
+
+          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'
+            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]
+          end
+
+          def cached_response=(response)
+            @@local_cache ||= {}
+            @@local_cache[@local_cache_key] = response
+          end
+
+          def render_all_without_cache(context)
+            context.stack do
+              begin
+                context.scopes.last[@target.to_s] = Locomotive::Steam::Httparty::Webservice.consume(@url, @options.symbolize_keys)
+                self.cached_response = context.scopes.last[@target.to_s]
+              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
+              end
+
+              render_all(@nodelist, context)
+            end
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('consume', Consume)
+      end
+    end
+  end
+end