locomotivecms_wagon 1.5.8 → 2.0.0.pre.alpha

data/lib/locomotive/wagon/liquid/drops/content_entry.rb

@@ -1,49 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Drops
-        class ContentEntry < Base
-
-          delegate :seo_title, :meta_keywords, :meta_description, to: :@_source
-
-          def _label
-            @_label ||= @_source._label
-          end
-
-          def _permalink
-            @_source._permalink.try(:parameterize)
-          end
-
-          alias :_slug :_permalink
-          alias :_id :_permalink
-
-          def next
-            self
-          end
-
-          def previous
-            self
-          end
-
-          def errors
-            (@_source.errors || []).inject({}) do |memo, name|
-              memo[name] = ::I18n.t('errors.messages.blank')
-              memo
-            end
-          end
-
-          def before_method(meth)
-            return '' if @_source.nil?
-
-            if not @@forbidden_attributes.include?(meth.to_s)
-              @_source.send(meth)
-            else
-              nil
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/drops/content_types.rb

@@ -1,119 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Drops
-        class ContentTypes < ::Liquid::Drop
-
-          def before_method(meth)
-            type = self.mounting_point.content_types[meth.to_s]
-            ProxyCollection.new(type)
-          end
-
-        end
-
-        class ProxyCollection < ::Liquid::Drop
-
-          include Scopeable
-
-          def initialize(content_type)
-            @content_type = content_type
-            @collection = nil
-          end
-
-          def all
-            self.collection
-          end
-
-          def any
-            self.collection.any?
-          end
-
-          def first
-            self.collection.first
-          end
-
-          def last
-            self.collection.last
-          end
-
-          def size
-            self.collection.size
-          end
-
-          alias :length :size
-          alias :count :size
-
-          def each(&block)
-            self.collection.each(&block)
-          end
-
-          def public_submission_url
-            "/entry_submissions/#{@content_type.slug}"
-          end
-
-          def api
-            { 'create' => "/entry_submissions/#{@content_type.slug}" }
-          end
-
-          def before_method(meth)
-            if (meth.to_s =~ /^group_by_(.+)$/) == 0
-              self.group_entries_by(@content_type, $1)
-            elsif (meth.to_s =~ /^(.+)_options$/) == 0
-              self.select_options_for(@content_type, $1)
-            else
-              @content_type.send(meth)
-            end
-          end
-
-          protected
-
-          def group_entries_by(content_type, name)
-            field = @content_type.find_field(name)
-
-            return {} if field.nil? || !%w(belongs_to select).include?(field.type.to_s)
-
-            (@content_type.entries || []).group_by do |entry|
-              entry.send(name.to_sym)
-            end.to_a.collect do |group|
-              { name: group.first, entries: group.last }.with_indifferent_access
-            end
-          end
-
-          def select_options_for(content_type, name)
-            field = @content_type.find_field(name)
-
-            return {} if field.nil? || field.type.to_s != 'select'
-
-            field.select_options.map(&:name)
-          end
-
-          def paginate(options = {})
-            @collection = self.collection.paginate(options)
-            {
-              collection:       @collection,
-              current_page:     @collection.current_page,
-              previous_page:    @collection.previous_page,
-              next_page:        @collection.next_page,
-              total_entries:    @collection.total_entries,
-              total_pages:      @collection.total_pages,
-              per_page:         @collection.per_page
-            }
-          end
-
-          def collection
-            return @collection unless @collection.blank?
-
-            # define the default order_by if not set
-            if @context['with_scope'] && @context['with_scope']['order_by'].blank? && !%w(manually position).include?(@content_type.order_by)
-              field     = @content_type.order_by || 'created_at'
-              direction = @content_type.order_direction || 'asc'
-              @context['with_scope']['order_by'] = "#{field}.#{direction}"
-            end
-
-            @collection = apply_scope(@content_type.entries)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/drops/page.rb

@@ -1,84 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Drops
-        class Page < Base
-
-          delegate :fullpath, :parent, :depth, :seo_title, :redirect_url, :meta_description, :meta_keywords,
-                   :templatized?, :published?, :redirect?, :listed?, :handle, to: :@_source
-
-          def title
-            title =  @_source.templatized? ? @context['entry'].try(:_label) : nil
-            title || @_source.title
-          end
-
-          def slug
-            slug = @_source.templatized? ? @context['entry'].try(:_slug).try(:singularize) : nil
-            slug || @_source.slug
-          end
-
-          def is_layout?
-            @_source.is_layout
-          end
-
-          def original_title
-            @_source.title
-          end
-
-          def original_slug
-            @_source.slug
-          end
-
-          def children
-            _children = @_source.children || []
-            _children = _children.sort { |a, b| a.position.to_i <=> b.position.to_i }
-            @children ||= liquify(*_children)
-          end
-
-          def content_type
-            ProxyCollection.new(@_source.content_type) if @_source.content_type
-          end
-
-          def editable_elements
-            @editable_elements_hash ||= build_editable_elements_hash
-          end
-
-          def breadcrumbs
-            # TODO
-            ''
-          end
-
-          private
-
-          def build_editable_elements_hash
-            {}.tap do |hash|
-              @_source.editable_elements.each do |el|
-                safe_slug = el.slug.parameterize.underscore
-                keys      = el.block.try(:split, '/').try(:compact) || []
-
-                _hash = _build_editable_elements_hashes(hash, keys)
-
-                _hash[safe_slug] = el.content
-              end
-            end
-          end
-
-          def _build_editable_elements_hashes(hash, keys)
-            _hash = hash
-
-            keys.each do |key|
-              safe_key = key.parameterize.underscore
-
-              _hash[safe_key] = {} if _hash[safe_key].nil?
-
-              _hash = _hash[safe_key]
-            end
-
-            _hash
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/drops/session_proxy.rb

@@ -1,18 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Drops
-
-        class SessionProxy < ::Liquid::Drop
-
-          def before_method(meth)
-            request = @context.registers[:request]
-            request.session[meth.to_sym]
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/drops/site.rb

@@ -1,26 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Drops
-        class Site < Base
-          include Scopeable
-
-          delegate :name, :seo_title, :meta_description, :meta_keywords, to: :@_source
-
-          def index
-            @index ||= self.mounting_point.pages['index']
-          end
-
-          def pages
-            liquify(*apply_scope(self.mounting_point.pages.values))
-          end
-
-          def domains
-            @_source.domains
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/wagon/liquid/errors.rb

@@ -1,17 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      class PageNotFound < ::Liquid::Error; end
-
-      class PageNotTranslated < ::Liquid::Error; end
-
-      class ContentEntryNotTranslated < ::Liquid::Error; end
-
-      class UnknownConditionInScope < ::Liquid::Error; end
-
-      class UnknownConditionInScope < ::Liquid::Error; end
-
-      class ConnectionRefused < ::Liquid::Error; end
-    end
-  end
-end

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

@@ -1,136 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Filters
-        module Date
-
-          def parse_date_time(input, format = nil)
-            return '' if input.blank?
-
-            format    ||= I18n.t('time.formats.default')
-            date_time = ::DateTime._strptime(input, format)
-
-            if date_time
-              ::Time.zone.local(date_time[:year], date_time[:mon], date_time[:mday], date_time[:hour], date_time[:min], date_time[:sec] || 0)
-            else
-              ::Time.zone.parse(input) rescue ''
-            end
-          end
-
-          def parse_date(input, format)
-            return '' if input.blank?
-
-            format  ||= I18n.t('date.formats.default')
-            date    = ::Date._strptime(input, format)
-
-            if date
-              ::Date.new(date[:year], date[:mon], date[:mday])
-            else
-              ::Date.parse(value) rescue ''
-            end
-          end
-
-          def localized_date(input, *args)
-            return '' if input.blank?
-
-            format, locale = args
-
-            locale ||= I18n.locale
-            format ||= I18n.t('date.formats.default', locale: locale)
-
-            if input.is_a?(String)
-              begin
-                fragments = ::Date._strptime(input, format)
-                input = ::Date.new(fragments[:year], fragments[:mon], fragments[:mday])
-              rescue
-                input = Time.zone.parse(input)
-              end
-            end
-
-            return input.to_s unless input.respond_to?(:strftime)
-
-            I18n.l input, format: format, locale: locale
-          end
-
-          alias :format_date :localized_date
-
-          def distance_of_time_in_words(input, from_time = Time.zone.now, include_seconds = false)
-            return '' if input.blank?
-
-            # make sure we deals with instances of Time
-            to_time   = to_time(input)
-            from_time = to_time(from_time)
-
-            from_time = from_time.to_time if from_time.respond_to?(:to_time)
-            to_time = to_time.to_time if to_time.respond_to?(:to_time)
-            distance_in_minutes = (((to_time - from_time).abs)/60).round
-            distance_in_seconds = ((to_time - from_time).abs).round
-
-            ::I18n.with_options({ scope: :'datetime.distance_in_words' }) do |locale|
-
-              case distance_in_minutes
-                when 0..1
-                  return distance_in_minutes == 0 ?
-                         locale.t(:less_than_x_minutes, count: 1) :
-                         locale.t(:x_minutes, count: distance_in_minutes) unless include_seconds
-
-                  case distance_in_seconds
-                    when 0..4   then locale.t :less_than_x_seconds, count: 5
-                    when 5..9   then locale.t :less_than_x_seconds, count: 10
-                    when 10..19 then locale.t :less_than_x_seconds, count: 20
-                    when 20..39 then locale.t :half_a_minute
-                    when 40..59 then locale.t :less_than_x_minutes, count: 1
-                    else             locale.t :x_minutes,           count: 1
-                  end
-
-                when 2..44           then locale.t :x_minutes,      count: distance_in_minutes
-                when 45..89          then locale.t :about_x_hours,  count: 1
-                when 90..1439        then locale.t :about_x_hours,  count: (distance_in_minutes.to_f / 60.0).round
-                when 1440..2519      then locale.t :x_days,         count: 1
-                when 2520..43199     then locale.t :x_days,         count: (distance_in_minutes.to_f / 1440.0).round
-                when 43200..86399    then locale.t :about_x_months, count: 1
-                when 86400..525599   then locale.t :x_months,       count: (distance_in_minutes.to_f / 43200.0).round
-                else
-                  fyear = from_time.year
-                  fyear += 1 if from_time.month >= 3
-                  tyear = to_time.year
-                  tyear -= 1 if to_time.month < 3
-                  leap_years = (fyear > tyear) ? 0 : (fyear..tyear).count{|x| ::Date.leap?(x)}
-                  minute_offset_for_leap_year = leap_years * 1440
-                  # Discount the leap year days when calculating year distance.
-                  # e.g. if there are 20 leap year days between 2 dates having the same day
-                  # and month then the based on 365 days calculation
-                  # the distance in years will come out to over 80 years when in written
-                  # english it would read better as about 80 years.
-                  minutes_with_offset         = distance_in_minutes - minute_offset_for_leap_year
-                  remainder                   = (minutes_with_offset % 525600)
-                  distance_in_years           = (minutes_with_offset / 525600)
-                  if remainder < 131400
-                    locale.t(:about_x_years,  count: distance_in_years)
-                  elsif remainder < 394200
-                    locale.t(:over_x_years,   count: distance_in_years)
-                  else
-                    locale.t(:almost_x_years, count: distance_in_years + 1)
-                  end
-              end
-            end
-          end
-
-          private
-
-          def to_time(input)
-            case input
-            when Date   then input.to_time
-            when String then Time.zone.parse(input)
-            else
-              input
-            end
-          end
-
-        end
-
-        ::Liquid::Template.register_filter(Date)
-      end
-    end
-  end
-end

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

@@ -1,188 +0,0 @@
-module Locomotive
-  module Wagon
-    module Liquid
-      module Filters
-        module Html
-
-          # Returns a link tag that browsers and news readers can use to auto-detect an RSS or ATOM feed.
-          # input: url of the feed
-          # example:
-          #   {{ '/foo/bar' | auto_discovery_link_tag: 'rel:alternate', 'type:application/atom+xml', 'title:A title' }}
-          def auto_discovery_link_tag(input, *args)
-            options = args_to_options(args)
-
-            rel   = options[:rel] || 'alternate'
-            type  = options[:type] || MIME::Types.type_for('rss').first
-            title = options[:title] || 'RSS'
-
-            %{<link rel="#{rel}" type="#{type}" title="#{title}" href="#{input}" />}
-          end
-
-          # Write the url of a theme stylesheet
-          # input: name of the css file
-          def stylesheet_url(input)
-            return '' if input.nil?
-
-            if input =~ /^https?:/
-              input
-            else
-              input = "/stylesheets/#{input}" unless input =~ /^\//
-              input = "#{input}.css" unless input.ends_with?('.css')
-              input
-            end
-          end
-
-          # Write the link to a stylesheet resource
-          # input: url of the css file
-          def stylesheet_tag(input, media = 'screen')
-            return '' if input.nil?
-
-            input = stylesheet_url(input)
-
-            %{<link href="#{input}" media="#{media}" rel="stylesheet" type="text/css" />}
-          end
-
-          # Write the url to javascript resource
-          # input: name of the javascript file
-          def javascript_url(input)
-            return '' if input.nil?
-
-            input = "/javascripts/#{input}" unless input =~ /^(\/|https?:)/
-
-            input = "#{input}.js" unless input.ends_with?('.js')
-
-            input
-          end
-
-          # Write the link to javascript resource
-          # input: url of the javascript file
-          def javascript_tag(input)
-            return '' if input.nil?
-
-            input = javascript_url(input)
-
-             %{<script src="#{input}" type="text/javascript"></script>}
-          end
-
-          # Write an image tag
-          # input: url of the image OR asset drop
-          def image_tag(input, *args)
-            image_options = inline_options(args_to_options(args))
-
-            "<img src=\"#{get_url_from_asset(input)}\" #{image_options}>"
-          end
-
-          # Write a theme image tag
-          # input: name of file including folder
-          # example: 'about/myphoto.jpg' | theme_image # <img src="images/about/myphoto.jpg" />
-          def theme_image_tag(input, *args)
-            image_options = inline_options(args_to_options(args))
-            "<img src=\"#{theme_image_url(input)}\" #{image_options}/>"
-          end
-
-          def theme_image_url(input)
-            return '' if input.nil?
-
-            input = "images/#{input}" unless input.starts_with?('/')
-
-            File.join('/', input)
-          end
-
-          def image_format(input, *args)
-            format = args_to_options(args).first
-            "#{input}.#{format}"
-          end
-
-          # Embed a flash movie into a page
-          # input: url of the flash movie OR asset drop
-          # width: width (in pixel or in %) of the embedded movie
-          # height: height (in pixel or in %) of the embedded movie
-          def flash_tag(input, *args)
-            path = get_url_from_asset(input)
-            embed_options = inline_options(args_to_options(args))
-            %{
-              <object #{embed_options}>
-                <param name="movie" value="#{path}" />
-                <embed src="#{path}" #{embed_options}/>
-                </embed>
-              </object>
-            }.gsub(/ >/, '>').strip
-          end
-
-          # Render the navigation for a paginated collection
-          def default_pagination(paginate, *args)
-            return '' if paginate['parts'].empty?
-
-            options = args_to_options(args)
-
-            previous_label = options[:previous_label] || I18n.t('pagination.previous')
-            next_label = options[:next_label] || I18n.t('pagination.next')
-
-            previous_link = (if paginate['previous'].blank?
-              "<span class=\"disabled prev_page\">#{previous_label}</span>"
-            else
-              "<a href=\"#{absolute_url(paginate['previous']['url'])}\" class=\"prev_page\">#{previous_label}</a>"
-            end)
-
-            links = ""
-            paginate['parts'].each do |part|
-              links << (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
-
-            next_link = (if paginate['next'].blank?
-              "<span class=\"disabled next_page\">#{next_label}</span>"
-            else
-              "<a href=\"#{absolute_url(paginate['next']['url'])}\" class=\"next_page\">#{next_label}</a>"
-            end)
-
-            %{<div class="pagination #{options[:css]}">
-                #{previous_link}
-                #{links}
-                #{next_link}
-              </div>}
-          end
-
-          protected
-
-          # Convert an array of properties ('key:value') into a hash
-          # Ex: ['width:50', 'height:100'] => { :width => '50', :height => '100' }
-          def args_to_options(*args)
-            options = {}
-            args.flatten.each do |a|
-              if (a =~ /^(.*):(.*)$/)
-                options[$1.to_sym] = $2
-              end
-            end
-            options
-          end
-
-          # Write options (Hash) into a string according to the following pattern:
-          # <key1>="<value1>", <key2>="<value2", ...etc
-          def inline_options(options = {})
-            return '' if options.empty?
-            (options.stringify_keys.to_a.collect { |a, b| "#{a}=\"#{b}\"" }).join(' ') << ' '
-          end
-
-          # Get the path to be used in html tags such as image_tag, flash_tag, ...etc
-          # input: url (String) OR asset drop
-          def get_url_from_asset(input)
-            input.respond_to?(:url) ? input.url : input
-          end
-
-          def absolute_url(url)
-            url =~ /^\// ? url : "/#{url}"
-          end
-        end
-
-        ::Liquid::Template.register_filter(Html)
-
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-module Locomotive
-  module Wagon
-    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