locomotivecms_steam 0.1.0

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

@@ -0,0 +1,48 @@
+module Locomotive
+  module Steam
+    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
+
+          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/steam/liquid/drops/content_types.rb

@@ -0,0 +1,117 @@
+module Locomotive
+  module Steam
+    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 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)
+              @context['with_scope']['order_by'] = @content_type.order_by + '.' + @content_type.order_direction
+            end
+
+            @collection = apply_scope(@content_type.entries)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Drops
+        class Page < Base
+
+          delegate :title, :slug, :fullpath, :parent, :depth, :seo_title, :redirect_url, :meta_description, :meta_keywords,
+                   :templatized?, :published?, :redirect?, :listed?, :handle, to: :@_source
+
+          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 breadcrumbs
+            # TODO
+            ''
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Locomotive
+  module Steam
+    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/steam/liquid/drops/site.rb

@@ -0,0 +1,26 @@
+module Locomotive
+  module Steam
+    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/steam/liquid/errors.rb

@@ -0,0 +1,17 @@
+module Locomotive
+  module Steam
+    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/steam/liquid/filters/date.rb

@@ -0,0 +1,136 @@
+module Locomotive
+  module Steam
+    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/steam/liquid/filters/html.rb

@@ -0,0 +1,188 @@
+module Locomotive
+  module Steam
+    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
+
+          # Steam 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