locomotivecms_builder 1.0.0.alpha1

data/lib/locomotive/builder/generators/snippet.rb

@@ -0,0 +1,54 @@
+require 'thor/group'
+require 'active_support'
+require 'active_support/core_ext'
+
+module Locomotive
+  module Builder
+    module Generators
+      class Snippet < Thor::Group
+
+        include Thor::Actions
+
+        argument :slug
+        argument :target_path # path to the site
+
+        attr_accessor :haml, :locales
+
+        def ask_for_haml_and_locales
+          self.locales = []
+          self.haml    = yes?('Do you prefer a HAML template ?')
+
+          if yes?('Is your snippet localized ?')
+            self.locales = ask('What are the locales other than the default one (comma separated) ?').split(',').map(&:strip)
+          end
+        end
+
+        def create_snippet
+          extension = self.haml ? 'liquid.haml' : 'liquid'
+
+          options   = { slug: slug, translated: false }
+          file_path = File.join(pages_path, slug)
+
+          template "template.#{extension}.tt", "#{file_path}.#{extension}", options
+
+          self.locales.each do |locale|
+            options[:translated] = true
+            template "template.#{extension}.tt", "#{file_path}.#{locale}.#{extension}", options
+          end
+        end
+
+        def self.source_root
+          File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'generators', 'snippet')
+        end
+
+        protected
+
+        def pages_path
+          File.join(target_path, 'app', 'views', 'snippets')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/builder/liquid/drops/base.rb

@@ -0,0 +1,44 @@
+# Code taken from Mephisto sources (http://mephistoblog.com/)
+module Locomotive
+  module Builder
+    module Liquid
+      module Drops
+        class Base < ::Liquid::Drop
+
+          @@forbidden_attributes = %w{_id _version _index}
+
+          attr_reader :_source
+
+          def initialize(source)
+            @_source = source
+          end
+
+          def id
+            (@_source.respond_to?(:id) ? @_source.id : nil) || 'new'
+          end
+
+          # converts an array of records to an array of liquid drops
+          def self.liquify(*records, &block)
+            i = -1
+            records =
+              records.inject [] do |all, r|
+                i+=1
+                attrs = (block && block.arity == 1) ? [r] : [r, i]
+                all << (block ? block.call(*attrs) : r.to_liquid)
+                all
+              end
+            records.compact!
+            records
+          end
+
+          protected
+
+          def liquify(*records, &block)
+            self.class.liquify(*records, &block)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Locomotive
+  module Builder
+    module Liquid
+      module Drops
+        class ContentEntry < Base
+
+          delegate :seo_title, :meta_keywords, :meta_description, :to => '_source'
+
+          def _label
+            @_label ||= self._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 self._source.nil?
+
+            if not @@forbidden_attributes.include?(meth.to_s)
+              self._source.send(meth)
+            else
+              nil
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+module Locomotive
+  module Builder
+    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
+
+          def initialize(content_type)
+            @content_type = content_type
+            @collection = nil
+          end
+
+          def first
+            self.collection.first
+          end
+
+          def last
+            self.collection.last
+          end
+
+          def size
+            self.collection.size
+          end
+
+          alias :length :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?
+
+            if @context['with_scope'].blank?
+              @collection = @content_type.entries
+            else
+              @collection = []
+
+              conditions = @context['with_scope'].clone.delete_if { |k, _| %w(order_by per_page page).include?(k) }
+
+              @content_type.entries.each do |content|
+                accepted = (conditions.map do |key, value|
+                  case value
+                  when TrueClass, FalseClass, String then content.send(key) == value
+                  else
+                    true
+                  end
+                end).all? # all conditions works ?
+
+                @collection << content if accepted
+              end
+            end
+
+            @collection
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

@@ -0,0 +1,98 @@
+module Locomotive
+  module Builder
+    module Liquid
+      module Filters
+        module Date
+
+          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
+
+          def distance_of_time_in_words(input, *args)
+            return '' if input.blank?
+
+            from_time = input
+            to_time   = args[0] || Time.now
+
+            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
+
+        end
+
+        ::Liquid::Template.register_filter(Date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+module Locomotive
+  module Builder
+    module Liquid
+      module Filters
+        module Html
+
+          # Write the link to a stylesheet resource
+          # input: url of the css file
+          def stylesheet_tag(input, media = 'screen')
+            return '' if input.nil?
+
+            input = "/stylesheets/#{input}" unless input =~ /^(\/|http:)/
+
+            input = "#{input}.css" unless input.ends_with?('.css')
+
+            %{<link href="#{input}" media="#{media}" rel="stylesheet" type="text/css" />}
+          end
+
+          # Write the link to javascript resource
+          # input: url of the javascript file
+          def javascript_tag(input)
+            return '' if input.nil?
+
+            input = "/javascripts/#{input}" unless input =~ /^(\/|http:)/
+
+            input = "#{input}.js" unless input.ends_with?('.js')
+
+             %{<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))
+
+            input = "/images/#{input}" unless input =~ /^(\/|http:)/
+
+            "<img src=\"#{File.join('/', 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/builder/liquid/filters/misc.rb

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

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

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

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

@@ -0,0 +1,50 @@
+require 'RedCloth'
+
+module Locomotive
+  module Builder
+    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 textile(input)
+            ::RedCloth.new(input).to_html
+          end
+
+        end
+
+        ::Liquid::Template.register_filter(Text)
+
+      end
+    end
+  end
+end