tribeca_cms 0.1.1

data/lib/locomotive/liquid/drops/proxy_collection.rb

@@ -0,0 +1,56 @@
+module Locomotive
+  module Liquid
+    module Drops
+
+      class ProxyCollection < ::Liquid::Drop
+
+        def initialize(collection)
+          @collection = collection
+        end
+
+        def first
+          self.collection.first
+        end
+
+        def last
+          self.collection.last
+        end
+
+        def each(&block)
+          self.collection.each(&block)
+        end
+
+        def each_with_index(&block)
+          self.collection.each_with_index(&block)
+        end
+
+        def count
+          @count ||= self.collection.count
+        end
+
+        alias :size   :count
+        alias :length :count
+
+        def empty
+          self.collection.empty?
+        end
+
+        def any
+          self.collection.any?
+        end
+
+        protected
+
+        def paginate(options = {})
+          @collection = collection.page(options[:page]).per(options[:per_page])
+        end
+
+        def collection
+          @collection
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Locomotive
+  module Liquid
+    module Drops
+      class Site < Base
+
+        delegate :name, :seo_title, :meta_keywords, :meta_description, :to => '_source'
+
+        def index
+          @index ||= self._source.pages.root.first
+        end
+
+        def pages
+          @pages ||= liquify(*self._source.pages)
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/liquid/drops/uploader.rb

@@ -0,0 +1,15 @@
+module Locomotive
+  module Liquid
+    module Drops
+      class Uploader < Base
+
+        delegate :url, :size, :to => '_source'
+
+        def filename
+          File.basename(self._source.url)
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/liquid/errors.rb

@@ -0,0 +1,7 @@
+module Locomotive
+  module Liquid
+    class PageNotFound < ::Liquid::Error; end
+
+    class PageNotTranslated < ::Liquid::Error; end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Locomotive
+  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 asset_url(path)
+          ThemeAssetUploader.url_for(@context.registers[:site], path)
+        end
+
+        def absolute_url(url)
+          url.starts_with?('/') ? url : "/#{url}"
+        end
+
+      end
+
+      ::Liquid::Template.register_filter(Base)
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Locomotive
+  module Liquid
+    module Filters
+      module Date
+
+        def distance_of_time_in_words(input, from_time = Time.now)
+          # make sure we deals with instances of Time
+          input     = to_time(input)
+          from_time = to_time(from_time)
+
+          ::ActionController::Base.helpers.distance_of_time_in_words(input, from_time)
+        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.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
+
+        private
+
+        def to_time(input)
+          case input
+          when Date   then input.to_time
+          when String then Time.parse(input)
+          else
+            input
+          end
+        end
+
+      end
+
+      ::Liquid::Template.register_filter(Date)
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Locomotive
+  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::Type.lookup_by_extension('rss').to_s
+          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?
+
+          unless input =~ /^(\/|https?:)/
+            input = asset_url("stylesheets/#{input}")
+          end
+
+          input = "#{input}.css" unless input.ends_with?('.css')
+
+          input
+        end
+
+        # Write the link tag of a theme stylesheet
+        # 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?
+
+          unless input =~ /^(\/|https?:)/
+            input = asset_url("javascripts/#{input}")
+          end
+
+          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
+
+        def theme_image_url(input)
+          return '' if input.nil?
+
+          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">
+        def theme_image_tag(input, *args)
+          image_options = inline_options(args_to_options(args))
+
+          "<img src=\"#{theme_image_url(input)}\" #{image_options}>"
+        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
+
+        # 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
+
+      end
+
+      ::Liquid::Template.register_filter(Html)
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Locomotive
+  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
+
+        # 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
+
+      end
+
+      ::Liquid::Template.register_filter(Misc)
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,45 @@
+module Locomotive
+  module Liquid
+    module Filters
+      module Text
+
+        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
+
+        # right justify and padd a string
+        def rjust(input, integer, padstr = '')
+          input.rjust(integer, padstr)
+        end
+
+        # left justify and padd a string
+        def ljust(input, integer, padstr = '')
+          input.ljust(integer, padstr)
+        end
+
+        def textile(input)
+          ::RedCloth.new(input).to_html
+        end
+
+      end
+
+      ::Liquid::Template.register_filter(Text)
+
+    end
+  end
+end