locomotivecms_wagon 1.5.8 → 2.0.0.pre.alpha

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

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

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

@@ -1,55 +0,0 @@
-module Locomotive
-  module Wagon
-    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::Wagon::Markdown.render(input)
-          end
-
-        end
-
-        ::Liquid::Template.register_filter(Text)
-
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module Locomotive
-  module Wagon
-    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/wagon/liquid/patches.rb

@@ -1,47 +0,0 @@
-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/wagon/liquid/scopeable.rb

@@ -1,151 +0,0 @@
-module Locomotive
-  module Wagon
-    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::Wagon::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(/[\s\.]/).map(&:to_sym)
-
-          Locomotive::Wagon::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.name = :_slug if %w(id _id).include?(name.to_s)
-
-            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/wagon/liquid/tags/consume.rb

@@ -1,100 +0,0 @@
-module Locomotive
-  module Wagon
-    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_api_arguments($3)
-            else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.consume"), options[:line])
-            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)
-          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_api_arguments(string)
-            string = string.gsub(/^(\s*,)/, '').strip
-            @api_arguments = Solid::Arguments.parse(string)
-          end
-
-          def set_api_options(context)
-            @api_options  = @api_arguments.interpolate(context).first || {}
-            @expires_in   = @api_options.delete(:expires_in) || 0
-          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::Wagon::Httparty::Webservice.consume(@url, @api_options)
-                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

data/lib/locomotive/wagon/liquid/tags/csrf.rb

@@ -1,34 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        module Csrf
-
-          class Param < ::Liquid::Tag
-
-            def render(context)
-              %{<input type="hidden" name="authenticity_token" value="helloworld" />}
-            end
-
-          end
-
-          class Meta < ::Liquid::Tag
-
-            def render(context)
-              %{
-                <meta name="csrf-param" content="authenticity_token" />
-                <meta name="csrf-token" content="helloworld" />
-              }
-            end
-
-          end
-
-        end
-
-        ::Liquid::Template.register_tag('csrf_param', Csrf::Param)
-        ::Liquid::Template.register_tag('csrf_meta', Csrf::Meta)
-
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/editable/base.rb

@@ -1,50 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        module Editable
-          class Base < ::Liquid::Block
-
-            Syntax = /(#{::Liquid::QuotedFragment})(\s*,\s*#{::Liquid::Expression}+)?/
-
-            def initialize(tag_name, markup, tokens, options)
-              if markup =~ Syntax
-                @slug = $1.gsub(/[\"\']/, '')
-                @_options = {}
-                markup.scan(::Liquid::TagAttributes) { |key, value| @_options[key.to_sym] = value.gsub(/^'/, '').gsub(/'$/, '') }
-              else
-                raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.#{tag_name}"), options[:line])
-              end
-
-              super
-            end
-
-            def render(context)
-              current_page = context.registers[:page]
-
-              element = current_page.find_editable_element(self.current_block_name(context), @slug)
-
-              if element.present?
-                render_element(context, element)
-              else
-                super
-              end
-            end
-
-            protected
-
-            def render_element(context, element)
-              element.content
-            end
-
-            def current_block_name(context)
-              context['block'].try(:name)
-            end
-
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/editable/control.rb

@@ -1,19 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        module Editable
-          class Control < Base
-
-            def render(context)
-              super
-            end
-
-          end
-
-          ::Liquid::Template.register_tag('editable_control', Control)
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/editable/file.rb

@@ -1,15 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        module Editable
-          class File < Base
-
-          end
-
-          ::Liquid::Template.register_tag('editable_file', File)
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/editable/long_text.rb

@@ -1,15 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        module Editable
-          class LongText < ShortText
-
-          end
-
-          ::Liquid::Template.register_tag('editable_long_text', LongText)
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/editable/short_text.rb

@@ -1,20 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        module Editable
-          class ShortText < Base
-
-            def render(context)
-              Locomotive::Wagon::Logger.warn "  [#{self.current_block_name(context)}/#{@slug}] The editable_{short|long}_text tags are deprecated. Use editable_text instead.".colorize(:orange)
-              super(context)
-            end
-
-          end
-
-          ::Liquid::Template.register_tag('editable_short_text', ShortText)
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/editable/text.rb

@@ -1,15 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        module Editable
-          class Text < Base
-
-          end
-
-          ::Liquid::Template.register_tag('editable_text', Text)
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/editable.rb

@@ -1,6 +0,0 @@
-require 'locomotive/wagon/liquid/tags/editable/base'
-require 'locomotive/wagon/liquid/tags/editable/text'
-require 'locomotive/wagon/liquid/tags/editable/short_text'
-require 'locomotive/wagon/liquid/tags/editable/long_text'
-require 'locomotive/wagon/liquid/tags/editable/file'
-require 'locomotive/wagon/liquid/tags/editable/control'

data/lib/locomotive/wagon/liquid/tags/extends.rb

@@ -1,25 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        class Extends < ::Liquid::Extends
-
-          def parse_parent_template
-            mounting_point = @options[:mounting_point]
-
-            page = if @template_name == 'parent'
-              @options[:page].parent
-            else
-              mounting_point.pages[@template_name]
-            end
-
-            ::Liquid::Template.parse(page.source, { mounting_point: mounting_point, page: page })
-          end
-
-        end
-
-        ::Liquid::Template.register_tag('extends', Extends)
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/fetch_page.rb

@@ -1,41 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-
-        # Fetch a page from its handle and assign it to a liquid variable.
-        #
-        # Usage:
-        #
-        # {% fetch_page 'about_us' as a_page %}
-        # <p>{{ a_page.title }}</p>
-        #
-        class FetchPage < ::Liquid::Tag
-
-          Syntax = /(#{::Liquid::VariableSignature}+)\s+as\s+(#{::Liquid::VariableSignature}+)/
-
-          def initialize(tag_name, markup, tokens, context)
-            if markup =~ Syntax
-              @handle = $1
-              @var = $2
-            else
-              raise SyntaxError.new("Syntax Error in 'fetch_page' - Valid syntax: fetch_page page_handle as variable")
-            end
-
-            super
-          end
-
-          def render(context)
-            mounting_point = context.registers[:mounting_point]
-            context.scopes.last[@var] = mounting_point.pages.values.find { |_page| _page.handle == @handle }
-            ''
-          end
-
-        end
-
-        ::Liquid::Template.register_tag('fetch_page', FetchPage)
-      end
-
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/tags/google_analytics.rb

@@ -1,28 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Tags
-        class GoogleAnalytics < ::Liquid::Tag
-
-          Syntax = /(#{::Liquid::Expression}+)?/
-
-          def initialize(tag_name, markup, tokens, options)
-            if markup =~ Syntax
-              @account_id = $1.gsub('\'', '')
-            else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.google_analytics"), options[:line])
-            end
-
-            super
-          end
-
-          def render(context)
-           "<!-- google analytics for #{@account_id} -->"
-          end
-        end
-
-        ::Liquid::Template.register_tag('google_analytics', GoogleAnalytics)
-      end
-    end
-  end
-end