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

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

@@ -2,26 +2,92 @@ module Locomotive
   module Steam
     module Liquid
       module Drops
-        class Page < Base
-          extend Forwardable
+        class Page < I18nBase
 
-          def_delegators :@_source, :title, :slug, :fullpath, :parent, :depth, :seo_title, :redirect_url, :meta_description, :meta_keywords,
-                   :templatized?, :published?, :redirect?, :listed?, :handle
+          delegate :fullpath, :depth, :seo_title, :meta_keywords, :meta_description, :redirect_url, :handle, to: :@_source
+          delegate :listed?, :published?, :redirect?, :is_layout?, :templatized?, 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 original_title
+            @_source.title
+          end
+
+          def original_slug
+            @_source.slug
+          end
+
+          def parent
+            @parent ||= repository.parent_of(@_source).to_liquid
+          end
+
+          def breadcrumbs
+            @breadcrumbs ||= liquify(*repository.ancestors_of(@_source))
+          end
 
           def children
-            _children = @_source.children || []
-            _children = _children.sort { |a, b| a.position.to_i <=> b.position.to_i }
-            @children ||= liquify(*_children)
+            @children ||= liquify(*repository.children_of(@_source))
           end
 
           def content_type
-            ProxyCollection.new(@_source.content_type) if @_source.content_type
+            if @_source.templatized?
+              # content_type can be either the slug of a content type or a content type
+              content_type = content_type_repository.find(@_source.content_type_id)
+              ContentEntryCollection.new(content_type)
+            else
+              nil
+            end
           end
 
-          def breadcrumbs
-            # TODO
-            ''
+          def editable_elements
+            @editable_elements_hash ||= build_editable_elements_hash
           end
+
+          private
+
+          def repository
+            @context.registers[:services].repositories.page
+          end
+
+          def content_type_repository
+            @context.registers[:services].repositories.content_type
+          end
+
+          def build_editable_elements_hash
+              {}.tap do |hash|
+                repository.editable_elements_of(@_source).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

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

@@ -15,4 +15,4 @@ module Locomotive
       end
     end
   end
-end
+end

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

@@ -2,22 +2,28 @@ module Locomotive
   module Steam
     module Liquid
       module Drops
-        class Site < Base
-          include Scopeable
-          extend Forwardable
+        class Site < I18nBase
 
-          def_delegators :@_source, :name, :seo_title, :meta_description, :meta_keywords
+          delegate :name, :domains, :seo_title, :meta_keywords, :meta_description, to: :@_source
 
           def index
-            @index ||= self.mounting_point.pages['index']
+            @index ||= repository.root.to_liquid
           end
 
           def pages
-            liquify(*apply_scope(self.mounting_point.pages.values))
+            @pages ||= liquify(*self.scoped_pages)
           end
 
-          def domains
-            @_source.domains
+          protected
+
+          def repository
+            @context.registers[:services].repositories.page
+          end
+
+          def scoped_pages
+            conditions = @context['with_scope'] || {}
+            conditions['slug.ne'] = '404'
+            repository.all(conditions)
           end
 
         end

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

@@ -0,0 +1,23 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Drops
+        class UploadedFile < Base
+
+          delegate :size, :filename, to: :@_source
+
+          def url
+            asset_host.compute(@_source.url, @_source.updated_at.try(:to_i))
+          end
+
+          private
+
+          def asset_host
+            @context.registers[:services].asset_host
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -3,15 +3,9 @@ module Locomotive
     module Liquid
       class PageNotFound < ::Liquid::Error; end
 
-      class PageNotTranslated < ::Liquid::Error; end
-
-      class ContentEntryNotTranslated < ::Liquid::Error; end
-
-      class UnknownConditionInScope < ::Liquid::Error; end
+      class SnippetNotFound < ::Liquid::Error; end
 
-      class UnknownConditionInScope < ::Liquid::Error; end
-
-      class ConnectionRefused < ::Liquid::Error; end
+      class PageNotTranslated < ::Liquid::Error; end
     end
   end
-end
+end

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

@@ -0,0 +1,62 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Filters
+        module Base
+
+          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.sort.to_a.collect { |a, b| "#{a}=\"#{b}\"" }).join(' ') << ' '
+          end
+
+          # Get the url 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 css_js_asset_url(input, extension, folder)
+            return '' if input.nil?
+
+            if input =~ /^(\/|https?:)/
+              uri = URI(input)
+            else
+              uri = URI(asset_url("#{folder}/#{input}"))
+            end
+
+            uri.path = "#{uri.path}#{extension}" unless uri.path.ends_with?(extension)
+            uri.to_s
+          end
+
+          def asset_url(path)
+            @context.registers[:services].theme_asset_url.build(path)
+          end
+
+          def absolute_url(url)
+            url.starts_with?('/') ? url : "/#{url}"
+          end
+
+        end
+
+        ::Liquid::Template.register_filter(Base)
+
+      end
+    end
+  end
+end

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

@@ -30,6 +30,18 @@ module Locomotive
             end
           end
 
+          def distance_of_time_in_words(input, from_time = Time.zone.now, include_seconds = false)
+            return '' if input.blank?
+
+            # make sure we deal with instances of Time
+            to_time   = convert_to_time!(input)
+            from_time = convert_to_time!(from_time)
+
+            ::I18n.with_options(scope: :'datetime.distance_in_words') do |locale|
+              _distance_of_time_in_words(locale, from_time, to_time, include_seconds)
+            end
+          end
+
           def localized_date(input, *args)
             return '' if input.blank?
 
@@ -43,94 +55,106 @@ module Locomotive
                 fragments = ::Date._strptime(input, format)
                 input = ::Date.new(fragments[:year], fragments[:mon], fragments[:mday])
               rescue
-                input = Time.zone.parse(input)
+                input = Time.parse(input)
               end
             end
 
             return input.to_s unless input.respond_to?(:strftime)
 
+            input = input.in_time_zone(@context.registers[:site].timezone) if input.respond_to?(:in_time_zone)
+
             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?
+          private
 
-            # make sure we deals with instances of Time
-            to_time   = to_time(input)
-            from_time = to_time(from_time)
+          def convert_to_time(input)
+            case input
+            when ::Date   then input.to_time
+            when ::String then Time.zone.parse(input)
+            else
+              input
+            end
+          end
 
-            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
+          def convert_to_time!(input)
+            convert_to_time(input).to_time
+          end
 
-            ::I18n.with_options({ scope: :'datetime.distance_in_words' }) do |locale|
+          def _distance_of_time_in_words(locale, from_time, to_time, include_seconds = false)
+            in_minutes, in_seconds = get_distance_in_minutes_and_seconds(from_time, to_time)
+
+            case in_minutes
+              when 0..1            then to_distance_in_seconds(locale, in_minutes, in_seconds, include_seconds)
+              when 2..44           then locale.t :x_minutes,      count: in_minutes
+              when 45..89          then locale.t :about_x_hours,  count: 1
+              when 90..1439        then locale.t :about_x_hours,  count: (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: (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: (in_minutes.to_f / 43200.0).round
+              else
+                to_distance_in_years(locale, from_time, to_time, in_minutes)
+            end
+          end
 
-              case distance_in_minutes
-                when 0..1
-                  return distance_in_minutes == 0 ?
+          def to_distance_in_seconds(locale, distance_in_minutes, distance_in_seconds, include_seconds)
+            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
+            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
           end
 
-          private
-
-          def to_time(input)
-            case input
-            when Date   then input.to_time
-            when String then Time.zone.parse(input)
+          def to_distance_in_years(locale, from_time, to_time, distance_in_minutes)
+            # 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.
+            minute_offset_for_leap_year = get_minute_offset_for_leap_year(from_time, to_time)
+            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
-              input
+              locale.t(:almost_x_years, count: distance_in_years + 1)
             end
           end
 
+          def get_minute_offset_for_leap_year(from_time, to_time)
+            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)}
+            leap_years * 1440
+          end
+
+          def get_distance_in_minutes_and_seconds(from_time, to_time)
+            in_minutes = (((to_time - from_time).abs) / 60).round
+            in_seconds = ((to_time - from_time).abs).round
+
+            [in_minutes, in_seconds]
+          end
+
         end
 
         ::Liquid::Template.register_filter(Date)
       end
     end
   end
-end
+end

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

@@ -4,7 +4,7 @@ module Locomotive
       module Filters
         module Html
 
-          # Returns a link tag that browsers and news readers can use to auto-detect an RSS or ATOM feed.
+          # Return 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' }}
@@ -12,7 +12,7 @@ module Locomotive
             options = args_to_options(args)
 
             rel   = options[:rel] || 'alternate'
-            type  = options[:type] || MIME::Types.type_for('rss').first
+            type  = options[:type] || 'application/rss+xml'
             title = options[:title] || 'RSS'
 
             %{<link rel="#{rel}" type="#{type}" title="#{title}" href="#{input}" />}
@@ -21,18 +21,10 @@ module Locomotive
           # 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
+            css_js_asset_url(input, '.css', 'stylesheets')
           end
 
-          # Write the link to a stylesheet resource
+          # Write the link tag of a theme stylesheet
           # input: url of the css file
           def stylesheet_tag(input, media = 'screen')
             return '' if input.nil?
@@ -45,52 +37,43 @@ module Locomotive
           # 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
+            css_js_asset_url(input, '.js', 'javascripts')
           end
 
           # Write the link to javascript resource
           # input: url of the javascript file
-          def javascript_tag(input)
+          def javascript_tag(input, *args)
             return '' if input.nil?
 
+            javascript_options = inline_options(args_to_options(args))
             input = javascript_url(input)
 
-             %{<script src="#{input}" type="text/javascript"></script>}
+            %{<script src="#{input}" type="text/javascript" #{javascript_options}></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))
+          def theme_image_url(input)
+            return '' if input.nil?
 
-            "<img src=\"#{get_url_from_asset(input)}\" #{image_options}>"
+            input = "images/#{input}" unless input.starts_with?('/')
+
+            asset_url(input)
           end
 
           # Write a theme image tag
           # input: name of file including folder
-          # example: 'about/myphoto.jpg' | theme_image # <img src="images/about/myphoto.jpg" />
+          # 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)
+            %{<img src="#{theme_image_url(input)}" #{image_options}>}
           end
 
-          def image_format(input, *args)
-            format = args_to_options(args).first
-            "#{input}.#{format}"
+          # 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
 
           # Embed a flash movie into a page
@@ -100,84 +83,16 @@ module Locomotive
           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>}
+            html = <<-EOF
+<object #{embed_options}>
+  <param name="movie" value="#{path}">
+  <embed src="#{path}" #{embed_options}>
+  </embed>
+</object>
+EOF
+            html.gsub(/ >/, '>').strip
           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)
@@ -185,4 +100,4 @@ module Locomotive
       end
     end
   end
-end
+end