locomotivecms_builder 1.0.0.alpha1

data/lib/locomotive/builder/liquid/tags/nav.rb

@@ -0,0 +1,167 @@
+module Locomotive
+  module Builder
+    module Liquid
+      module Tags
+        # Display the children pages of the site, current page or the parent page. If not precised, nav is applied on the current page.
+        # The html output is based on the ul/li tags.
+        #
+        # Usage:
+        #
+        # {% nav site %} => <ul class="nav"><li class="on"><a href="/features">Features</a></li></ul>
+        #
+        # {% nav site, no_wrapper: true, exclude: 'contact|about', id: 'main-nav', class: 'nav', active_class: 'on' }
+        #
+        class Nav < ::Liquid::Tag
+
+          Syntax = /(#{::Liquid::Expression}+)?/
+
+          attr_accessor :current_page, :mounting_point
+
+          def initialize(tag_name, markup, tokens, context)
+            if markup =~ Syntax
+              @source = ($1 || 'page').gsub(/"|'/, '')
+              @options = { :id => 'nav', :class => '', :active_class => 'on', :bootstrap => false }
+              markup.scan(::Liquid::TagAttributes) { |key, value| @options[key.to_sym] = value.gsub(/"|'/, '') }
+
+              @options[:exclude] = Regexp.new(@options[:exclude]) if @options[:exclude]
+
+              if @options[:snippet]
+                if template = self.parse_snippet_template(context, @options[:snippet])
+                  @options[:liquid_render] = template
+                end
+              end
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'nav' - Valid syntax: nav <site|parent|page|<path to a page>> <options>")
+            end
+
+            super
+          end
+
+          def render(context)
+            self.set_accessors_from_context(context)
+
+            children_output = []
+
+            entries = self.fetch_entries
+
+            entries.each_with_index do |p, index|
+              css = []
+              css << 'first' if index == 0
+              css << 'last' if index == entries.size - 1
+
+              children_output << render_entry_link(p, css.join(' '), 1)
+            end
+
+            output = children_output.join("\n")
+
+            if @options[:no_wrapper] != 'true'
+              output = %{<ul id="#{@options[:id]}" class="#{@options[:class]}">\n#{output}</ul>}
+            end
+
+            output
+          end
+
+          protected
+
+          def set_accessors_from_context(context)
+            self.current_page   = context.registers[:page]
+            self.mounting_point = context.registers[:mounting_point]
+          end
+
+          def parse_snippet_template(context, template_name)
+            source = if template_name.include?('{')
+              template_name
+            else
+              context[:mounting_point].snippets[template_name].try(:source)
+            end
+
+            source ? ::Liquid::Template.parse(source) : nil
+          end
+
+          def fetch_entries
+            children = (case @source
+            when 'site'     then self.mounting_point.pages['index']
+            when 'parent'   then self.current_page.parent || self.current_page
+            when 'page'     then self.current_page
+            else
+              self.mounting_point.pages[@source]
+            end).children.clone
+
+            children.delete_if { |p| !include_page?(p) }
+          end
+
+          # Determines whether or not a page should be a part of the menu
+          def include_page?(page)
+            if !page.listed? || page.templatized? || !page.published?
+              false
+            elsif @options[:exclude]
+              (page.fullpath =~ @options[:exclude]).nil?
+            else
+              true
+            end
+          end
+
+          # Returns a list element, a link to the page and its children
+          def render_entry_link(page, css, depth)
+            selected = self.current_page.fullpath =~ /^#{page.fullpath}/ ? " #{@options[:active_class]}" : ''
+
+            icon = @options[:icon] ? '<span></span>' : ''
+
+            title = @options[:liquid_render] ? @options[:liquid_render].render('page' => page) : page.title
+
+            label = %{#{icon if @options[:icon] != 'after' }#{title}#{icon if @options[:icon] == 'after' }}
+
+            dropdow = ""
+            link_options = ""
+            href = ::I18n.locale.to_s == self.mounting_point.default_locale.to_s ? "/#{page.fullpath}" : "/#{::I18n.locale}/#{page.fullpath}"
+            caret = ""
+
+            if render_children_for_page?(page, depth) && bootstrap?
+              dropdow = "dropdown"
+              link_options = %{class="dropdown-toggle" data-toggle="dropdown"}
+              href = "#"
+              caret = %{<b class="caret"></b>}
+            end
+
+            output  = %{<li id="#{page.slug.to_s.dasherize}-link" class="link#{selected} #{css} #{dropdow}">}
+            output << %{<a href="#{href}" #{link_options}>#{label} #{caret}</a>}
+            output << render_entry_children(page, depth.succ) if (depth.succ <= @options[:depth].to_i)
+            output << %{</li>}
+
+            output.strip
+          end
+
+          def render_children_for_page?(page, depth)
+            depth.succ <= @options[:depth].to_i && page.children.reject { |c| !include_page?(c) }.any?
+          end
+
+          # Recursively creates a nested unordered list for the depth specified
+          def render_entry_children(page, depth)
+            output = %{}
+
+            children = page.children.reject { |c| !include_page?(c) }
+            if children.present?
+              output = %{<ul id="#{@options[:id]}-#{page.slug.to_s.dasherize}" class="#{bootstrap? ? "dropdown-menu" : ""}">}
+              children.each do |c, page|
+                css = []
+                css << 'first' if children.first == c
+                css << 'last'  if children.last  == c
+
+                output << render_entry_link(c, css.join(' '),depth)
+              end
+              output << %{</ul>}
+            end
+
+            output
+          end
+
+          def bootstrap?
+            @options[:bootstrap] == 'true' || @options[:bootstrap] == true
+          end
+
+          ::Liquid::Template.register_tag('nav', Nav)
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/builder/liquid/tags/paginate.rb

@@ -0,0 +1,105 @@
+module Locomotive
+  module Builder
+    module Liquid
+        module Tags
+
+        # Paginate a collection
+        #
+        # Usage:
+        #
+        # {% paginate contents.projects by 5 %}
+        #   {% for project in paginate.collection %}
+        #     {{ project.name }}
+        #   {% endfor %}
+        #  {% endpaginate %}
+        #
+
+        class Paginate < ::Liquid::Block
+
+          Syntax = /(#{::Liquid::Expression}+)\s+by\s+([0-9]+)/
+
+          def initialize(tag_name, markup, tokens, context)
+            if markup =~ Syntax
+              @collection_name = $1
+              @per_page = $2.to_i
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'paginate' - Valid syntax: paginate <collection> by <number>")
+            end
+
+            super
+          end
+
+          def render(context)
+            context.stack do
+              collection = context[@collection_name]
+
+              raise ::Liquid::ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection.nil?
+
+              pagination = collection.send(:paginate, {
+                :page       => context['current_page'],
+                :per_page   => @per_page }).stringify_keys!
+
+              page_count, current_page = pagination['total_pages'], pagination['current_page']
+
+              path = sanitize_path(context['fullpath'])
+
+              pagination['previous'] = link(I18n.t('pagination.previous'), current_page - 1, path) if pagination['previous_page']
+              pagination['next'] = link(I18n.t('pagination.next'), current_page + 1, path) if pagination['next_page']
+              pagination['parts'] = []
+
+              hellip_break = false
+
+              if page_count > 1
+                1.upto(page_count) do |page|
+                  if current_page == page
+                    pagination['parts'] << no_link(page)
+                  elsif page == 1
+                    pagination['parts'] << link(page, page, path)
+                  elsif page == page_count - 1
+                    pagination['parts'] << link(page, page, path)
+                  elsif page <= current_page - window_size or page >= current_page + window_size
+                    next if hellip_break
+                    pagination['parts'] << no_link('&hellip;')
+                    hellip_break = true
+                    next
+                  else
+                    pagination['parts'] << link(page, page, path)
+                  end
+
+                  hellip_break = false
+                end
+              end
+
+              context['paginate'] = pagination
+
+              render_all(@nodelist, context)
+            end
+          end
+
+          private
+
+          def sanitize_path(path)
+            _path = path.gsub(/page=[0-9]+&?/, '').gsub(/_pjax=true&?/, '')
+            _path = _path.slice(0..-2) if _path.last == '?' || _path.last == '&'
+            _path
+          end
+
+          def window_size
+            3
+          end
+
+          def no_link(title)
+            { 'title' => title, 'is_link' => false, 'hellip_break' => title == '&hellip;' }
+          end
+
+          def link(title, page, path)
+            _path = %(#{path}#{path.include?('?') ? '&' : '?'}page=#{page})
+            { 'title' => title, 'url' => _path, 'is_link' => true }
+          end
+        end
+
+        ::Liquid::Template.register_tag('paginate', Paginate)
+      end
+    end
+  end
+end

data/lib/locomotive/builder/liquid/tags/seo.rb

@@ -0,0 +1,74 @@
+module Locomotive
+  module Builder
+    module Liquid
+      module Tags
+        module SEO
+
+          class Base < ::Liquid::Tag
+
+            def render(context)
+              %{
+                #{self.render_title(context)}
+                #{self.render_metadata(context)}
+              }
+            end
+
+            protected
+
+            def render_title(context)
+              title = self.value_for(:seo_title, context)
+              title = context.registers[:site].name if title.blank?
+
+              %{
+                <title>#{title}</title>
+              }
+            end
+
+            def render_metadata(context)
+              %{
+                <meta name="description" content="#{self.value_for(:meta_description, context)}" />
+                <meta name="keywords" content="#{self.value_for(:meta_keywords, context)}" />
+              }
+            end
+
+            # Removes whitespace and quote characters from the input
+            def sanitized_string(string)
+              string ? string.strip.gsub(/"/, '') : ''
+            end
+
+            def value_for(attribute, context)
+              object = self.metadata_object(context)
+              value = object.try(attribute.to_sym).blank? ? context.registers[:site].send(attribute.to_sym) : object.send(attribute.to_sym)
+              self.sanitized_string(value)
+            end
+
+            def metadata_object(context)
+              context['content_instance'] || context['page']
+            end
+          end
+
+          class Title < Base
+
+            def render(context)
+              self.render_title(context)
+            end
+
+          end
+
+          class Metadata < Base
+
+            def render(context)
+              self.render_metadata(context)
+            end
+
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('seo', SEO::Base)
+        ::Liquid::Template.register_tag('seo_title', SEO::Title)
+        ::Liquid::Template.register_tag('seo_metadata', SEO::Metadata)
+      end
+    end
+  end
+end

data/lib/locomotive/builder/liquid/tags/snippet.rb

@@ -0,0 +1,42 @@
+module Locomotive
+  module Builder
+    module Liquid
+      module Tags
+
+        class Snippet < ::Liquid::Include
+
+          def render(context)
+            name = @template_name.gsub(/[\"\']/, '')
+
+            source = context.registers[:mounting_point].snippets[name].try(:source)
+
+            partial = ::Liquid::Template.parse(source)
+
+            variable = context[@variable_name || @template_name[1..-2]]
+
+            context.stack do
+              @attributes.each do |key, value|
+                context[key] = context[value]
+              end
+
+              output = (if variable.is_a?(Array)
+                variable.collect do |variable|
+                  context[@template_name[1..-2]] = variable
+                  partial.render(context)
+                end
+              else
+                context[@template_name[1..-2]] = variable
+                partial.render(context)
+              end)
+
+              output
+            end
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('include', Snippet)
+      end
+    end
+  end
+end

data/lib/locomotive/builder/liquid/tags/with_scope.rb

@@ -0,0 +1,43 @@
+module Locomotive
+  module Builder
+    module Liquid
+      module Tags
+        class WithScope < ::Liquid::Block
+
+          def initialize(tag_name, markup, tokens, context)
+            @options = {}
+
+            markup.scan(::Liquid::TagAttributes) do |key, value|
+              @options[key] = value
+            end
+
+            super
+          end
+
+          def render(context)
+            context.stack do
+              context['with_scope'] = decode(@options, context)
+              render_all(@nodelist, context)
+            end
+          end
+
+          private
+
+          def decode(attributes, context)
+            attributes.each_pair do |key, value|
+              attributes[key] = (case value
+              when /^true|false$/i then value == 'true'
+              when /^[0-9]+$/ then value.to_i
+              when /^["|'](.+)["|']$/ then $1.gsub(/^["|']/, '').gsub(/["|']$/, '')
+              else
+                context[value] || value
+              end)
+            end
+          end
+        end
+
+        ::Liquid::Template.register_tag('with_scope', WithScope)
+      end
+    end
+  end
+end

data/lib/locomotive/builder/liquid.rb

@@ -0,0 +1,19 @@
+require "locomotive/mounter"
+require 'liquid'
+require 'locomotive/builder/liquid/drops/base'
+
+%w{. drops tags filters}.each do |dir|
+  Dir[File.join(File.dirname(__FILE__), 'liquid', dir, '*.rb')].each { |lib| require lib }
+end
+
+
+# add to_liquid methods to main models from the mounter
+%w{site page content_entry}.each do |name|
+  klass = "Locomotive::Mounter::Models::#{name.classify}".constantize
+
+  klass.class_eval <<-EOV
+    def to_liquid
+      ::Locomotive::Builder::Liquid::Drops::#{name.classify}.new(self)
+    end
+  EOV
+end

data/lib/locomotive/builder/listen.rb

@@ -0,0 +1,48 @@
+require 'listen'
+
+module Locomotive::Builder
+  class Listen
+
+    attr_accessor :reader
+
+    def self.instance
+      @@instance = new
+    end
+
+    def start(reader)
+      self.reader = reader
+
+      self.definitions.each do |definition|
+        self.apply(definition)
+      end
+    end
+
+    def definitions
+      [
+        ['config', /\.yml/, [:site, :content_types, :pages, :snippets, :content_entries, :translations]],
+        ['app/views', /\.liquid/, [:pages, :snippets]],
+        ['app/content_types', /\.yml/, [:content_types, :content_entries]],
+        ['data', /\.yml/, :content_entries]
+      ]
+    end
+
+    protected
+
+    def apply(definition)
+      reloader = Proc.new do |modified, added, removed|
+        reader.reload(definition.last)
+      end
+
+      filter  = definition[1]
+      path    = File.join(self.reader.mounting_point.path, definition.first)
+      path    = File.expand_path(path)
+
+      listener = ::Listen.to(path).filter(filter).change(&reloader)
+
+      # non blocking listener
+      listener.start(false)
+    end
+
+  end
+
+end

data/lib/locomotive/builder/misc/core_ext.rb

@@ -0,0 +1,29 @@
+unless Hash.instance_methods.include?(:underscore_keys)
+  class Hash
+
+    def underscore_keys
+      new_hash = {}
+
+      self.each_pair do |key, value|
+        if value.respond_to?(:collect!) # Array
+          value.collect do |item|
+            if item.respond_to?(:each_pair) # Hash item within
+              item.underscore_keys
+            else
+              item
+            end
+          end
+        elsif value.respond_to?(:each_pair) # Hash
+          value = value.underscore_keys
+        end
+
+        new_key = key.is_a?(String) ? key.underscore : key # only String keys
+
+        new_hash[new_key] = value
+      end
+
+      self.replace(new_hash)
+    end
+
+  end
+end

data/lib/locomotive/builder/misc/dragonfly.rb

@@ -0,0 +1,82 @@
+module Locomotive
+  module Builder
+    class Dragonfly
+
+      attr_accessor :path, :enabled
+
+      def enabled?
+        !!self.enabled
+      end
+
+      def resize_url(source, resize_string)
+        _source = (case source
+        when String then source
+        when Hash   then source['url'] || source[:url]
+        else
+          source.try(:url)
+        end)
+
+        if _source.blank?
+          LocomotiveEditor::Logger.error "Unable to resize on the fly: #{source.inspect}"
+          return
+        end
+
+        return _source unless self.enabled?
+
+        if _source =~ /^http/
+          file = self.class.app.fetch_url(_source)
+        else
+          file = self.class.app.fetch_file(File.join(self.path, 'public', _source))
+        end
+
+        file.process(:thumb, resize_string).url
+      end
+
+      def self.app
+        ::Dragonfly[:images]
+      end
+
+
+      def self.instance
+        @@instance ||= new
+      end
+
+      def self.setup!(path)
+        self.instance.path    = path
+        self.instance.enabled = false
+
+        begin
+          require 'rack/cache'
+          require 'RMagick'
+          require 'dragonfly'
+
+          ## initialize Dragonfly ##
+          app = ::Dragonfly[:images].configure_with(:imagemagick)
+
+          ## configure it ##
+          ::Dragonfly[:images].configure do |c|
+            convert = `which convert`.strip.presence || '/usr/local/bin/convert'
+            c.convert_command  = convert
+            c.identify_command = convert
+
+            c.allow_fetch_url  = true
+            c.allow_fetch_file = true
+
+            c.url_format = '/images/dynamic/:job/:basename.:format'
+          end
+
+          puts 'Dragonfly enabled'
+
+          self.instance.enabled = true
+        rescue Exception => e
+          puts %{
+  \tIf you want to take full benefits of all the features in the LocomotiveEditor, we recommend you to install ImageMagick and RMagick.
+  \tCheck out the documentation here: http://doc.locomotivecms.com/editor/installation.}
+
+          puts 'Dragonfly disabled'
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/builder/misc/httparty.rb

@@ -0,0 +1,47 @@
+require 'uri'
+
+module Locomotive
+  module Builder
+    module Httparty
+      class Webservice
+
+        include ::HTTParty
+
+        def self.consume(url, options = {})
+          url = ::HTTParty.normalize_base_uri(url)
+
+          uri = URI.parse(url)
+          options[:base_uri] = "#{uri.scheme}://#{uri.host}"
+          options[:base_uri] += ":#{uri.port}" if uri.port != 80
+          path = uri.request_uri
+
+          options.delete(:format) if options[:format] == 'default'
+
+          username, password = options.delete(:username), options.delete(:password)
+          options[:basic_auth] = { username: username, password: password } if username
+
+          path ||= '/'
+
+          # puts "[WebService] consuming #{path}, #{options.inspect}"
+
+          response = self.get(path, options)
+
+          if response.code == 200
+            _response = response.parsed_response
+            if _response.respond_to?(:underscore_keys)
+              _response.underscore_keys
+            else
+              _response.collect(&:underscore_keys)
+            end
+          else
+            # TODO: handle errors
+            puts "[Locomotive][Builder][Error] consuming #{path}, #{options.inspect}, response = #{response.inspect}"
+            nil
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/builder/misc/i18n.rb

@@ -0,0 +1,2 @@
+I18n.load_path = Dir[File.join(File.dirname(__FILE__), "/../../../../locales/*.yml")]
+I18n.backend.reload!

data/lib/locomotive/builder/misc/will_paginate.rb

@@ -0,0 +1,16 @@
+require 'will_paginate'
+require 'will_paginate/collection'
+
+Array.class_eval do
+  def paginate(options = {})
+    raise ArgumentError, "parameter hash expected (got #{options.inspect})" unless Hash === options
+
+    WillPaginate::Collection.create(
+        options[:page] || 1,
+        options[:per_page] || 30,
+        options[:total_entries] || self.length
+    ) { |pager|
+      pager.replace self[pager.offset, pager.per_page].to_a
+    }
+  end
+end

data/lib/locomotive/builder/misc.rb

@@ -0,0 +1,5 @@
+require 'locomotive/builder/misc/core_ext.rb'
+require 'locomotive/builder/misc/will_paginate.rb'
+require 'locomotive/builder/misc/httparty.rb'
+require 'locomotive/builder/misc/dragonfly.rb'
+require 'locomotive/builder/misc/i18n.rb'