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

data/example/server.rb

@@ -1,31 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'bundler/setup'
-
-Bundler.require
-
-require 'thin'
-# require 'common'
-require 'locomotive/common'
-
-require_relative '../lib/locomotive/steam'
-require_relative '../lib/locomotive/steam/server'
-require_relative '../lib/locomotive/steam/initializers'
-
-path = ENV['SITE_PATH'] || File.join(File.expand_path(File.dirname(__FILE__)), '../spec/fixtures/default')
-
-# reader = Locomotive::Mounter::Reader::FileSystem.instance
-# reader.run!(path: path)
-
-datastore = Locomotive::Steam::FileSystemDatastore.new(path: path)
-
-app = Locomotive::Steam::Server.new(datastore, {
-  serve_assets: true
-})
-
-server  = Thin::Server.new('localhost', '3333', app)
-server.threaded = true
-
-Locomotive::Common::Logger.info 'Server started...'
-server.start

data/lib/locomotive/steam/decorators.rb

@@ -1 +0,0 @@
-require_relative 'decorators/page_decorator'

data/lib/locomotive/steam/decorators/page_decorator.rb

@@ -1,50 +0,0 @@
-module Locomotive
-  module Steam
-    module Decorators
-      class PageDecorator < SimpleDelegator
-
-        # Return the fullpath dasherized and with the "*" character
-        # for the slug of templatized page.
-        #
-        # @return [ hash ] The safe full paths
-        #
-
-        def safe_fullpath
-          if index_or_404?
-            slug[current_locale]
-          else
-            base  = parent.safe_fullpath
-            _slug = if templatized? && !templatized_from_parent
-              '*'
-            else
-              slug[current_locale]
-            end
-            (base == 'index' ? _slug : File.join(base, _slug)).dasherize
-          end
-        end
-
-        def parent
-          Locomotive::Steam::Decorators::PageDecorator.new(
-            Locomotive::Decorators::I18nDecorator.new(
-              __getobj__.parent, current_locale
-            )
-          )
-        end
-
-        # Return the Liquid template based on the raw_template property
-        # of the page. If the template is HAML or SLIM, then a pre-rendering to Liquid is done.
-        #
-        # @return [ String ] The liquid template or nil if not template has been provided
-        #
-        def source(locale)
-          @source ||= self.template[locale].source
-        end
-
-        def to_liquid
-          ::Locomotive::Steam::Liquid::Drops::Page.new(self)
-        end
-
-      end
-    end
-  end
-end

data/lib/locomotive/steam/exceptions.rb

@@ -1,62 +0,0 @@
-module Locomotive
-  module Steam
-
-    class DefaultException < ::Exception
-
-      def initialize(message = nil, parent_exception = nil)
-        self.log_backtrace(parent_exception) if parent_exception
-
-        super(message)
-      end
-
-      protected
-
-      def log_backtrace(parent_exception)
-        full_error_message = "#{parent_exception.message}\n\t"
-        full_error_message += parent_exception.backtrace.join("\n\t")
-        full_error_message += "\n\n"
-        Locomotive::Common::Logger.fatal full_error_message
-      end
-
-    end
-
-    class RendererException < DefaultException
-
-      attr_accessor :name, :template, :liquid_context
-
-      def initialize(exception, name, template, liquid_context)
-        self.name, self.template, self.liquid_context = name, template, liquid_context
-
-        self.log_page_into_backtrace(exception)
-
-        super(exception.message)
-
-        self.set_backtrace(exception.backtrace)
-      end
-
-      def log_page_into_backtrace(exception)
-        line = self.template.line_offset
-        line += (exception.respond_to?(:line) ? exception.line || 0 : 0) + 1
-
-        message = "#{self.template.filepath}:#{line}:in `#{self.name}'"
-
-        Locomotive::Common::Logger.fatal "[ERROR] #{exception.message} - #{message}\n".red
-
-        exception.backtrace.unshift message
-      end
-
-    end
-
-    class MounterException < DefaultException
-    end
-
-    class GeneratorException < DefaultException
-
-      def log_backtrace(parent_exception)
-        # Logger not initialized at this step
-      end
-
-    end
-
-  end
-end

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

@@ -1,149 +0,0 @@
-module Locomotive
-  module Steam
-    module Liquid
-      module Scopeable
-
-        def apply_scope(entries)
-          if @context['with_scope'].blank?
-            entries
-          else
-            # extract the conditions
-            _conditions = @context['with_scope'].clone.delete_if { |k, _| %w(order_by per_page page).include?(k) }
-
-            # build the chains of conditions
-            conditions = _conditions.map { |name, value| Condition.new(name, value) }
-
-            Locomotive::Common::Logger.info "[with_scope] conditions: #{conditions.map(&:to_s).join(', ')}"
-
-            # get only the entries matching ALL the conditions
-            _entries = entries.find_all do |content|
-              accepted = true
-
-              conditions.each do |_condition|
-                unless _condition.matches?(content)
-                  accepted = false
-                  break # no to go further
-                end
-              end
-
-              accepted
-            end
-
-            self._apply_scope_order(_entries, @context['with_scope']['order_by'])
-          end
-        end
-
-        def _apply_scope_order(entries, order_by)
-          return entries if order_by.blank?
-
-          name, direction = order_by.split.map(&:to_sym)
-
-          Locomotive::Common::Logger.info "[with_scope] order_by #{name} #{direction || 'asc'}"
-
-          if direction == :asc || direction.nil?
-            entries.sort { |a, b| a.send(name) <=> b.send(name) }
-          else
-            entries.sort { |a, b| b.send(name) <=> a.send(name) }
-          end
-        end
-
-        class Condition
-
-          OPERATORS = %w(all gt gte in lt lte ne nin size)
-
-          attr_accessor :name, :operator, :right_operand
-
-          def initialize(name, value)
-            self.name, self.right_operand = name, value
-
-            self.process_right_operand
-
-            # default value
-            self.operator = :==
-
-            self.decode_operator_based_on_name
-          end
-
-          def matches?(entry)
-            value = self.get_value(entry)
-
-            self.decode_operator_based_on_value(value)
-
-            case self.operator
-            when :==      then value == self.right_operand
-            when :ne      then value != self.right_operand
-            when :matches then self.right_operand =~ value
-            when :gt      then value > self.right_operand
-            when :gte     then value >= self.right_operand
-            when :lt      then value < self.right_operand
-            when :lte     then value <= self.right_operand
-            when :size    then value.size == self.right_operand
-            when :all     then [*self.right_operand].contains?(value)
-            when :in, :nin
-              _matches = if value.is_a?(Array)
-                [*value].contains?([*self.right_operand])
-              else
-                [*self.right_operand].include?(value)
-              end
-              self.operator == :in ? _matches : !_matches
-            else
-              raise UnknownConditionInScope.new("#{self.operator} is unknown or not implemented.")
-            end
-          end
-
-          def to_s
-            "#{name} #{operator} #{self.right_operand.to_s}"
-          end
-
-          protected
-
-          def get_value(entry)
-            value = entry.send(self.name)
-
-            if value.respond_to?(:_slug)
-              # belongs_to
-              value._slug
-            elsif value.respond_to?(:map)
-              # many_to_many or tags ?
-              value.map { |v| v.respond_to?(:_slug) ? v._slug : v }
-            else
-              value
-            end
-          end
-
-          def process_right_operand
-            if self.right_operand.respond_to?(:_slug)
-              # belongs_to
-              self.right_operand = self.right_operand._slug
-            elsif self.right_operand.respond_to?(:map) && self.right_operand.first.respond_to?(:_slug)
-              # many_to_many
-              self.right_operand = self.right_operand.map do |entry|
-                entry.try(&:_slug)
-              end
-            end
-          end
-
-          def decode_operator_based_on_name
-            if name =~ /^([a-z0-9_-]+)\.(#{OPERATORS.join('|')})$/
-              self.name     = $1.to_sym
-              self.operator = $2.to_sym
-            end
-
-            if self.right_operand.is_a?(Regexp)
-              self.operator = :matches
-            end
-          end
-
-          def decode_operator_based_on_value(value)
-            case value
-            when Array
-              self.operator = :in if self.operator == :==
-            end
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/lib/locomotive/steam/liquid/tags/editable/long_text.rb

@@ -1,15 +0,0 @@
-module Locomotive
-  module Steam
-    module Liquid
-      module Tags
-        module Editable
-          class LongText < ShortText
-
-          end
-
-          ::Liquid::Template.register_tag('editable_long_text', LongText)
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/steam/liquid/tags/editable/short_text.rb

@@ -1,20 +0,0 @@
-module Locomotive
-  module Steam
-    module Liquid
-      module Tags
-        module Editable
-          class ShortText < Base
-
-            def render(context)
-              Locomotive::Common::Logger.warn "  [#{self.current_block_name(context)}/#{@slug}] The editable_{short|long}_text tags are deprecated. Use editable_text instead.".colorize(:orange)
-              super(context)
-            end
-
-          end
-
-          ::Liquid::Template.register_tag('editable_short_text', ShortText)
-        end
-      end
-    end
-  end
-end

data/lib/locomotive/steam/liquid/tags/path_helper.rb

@@ -1,98 +0,0 @@
-module Locomotive
-  module Steam
-    module Liquid
-      module Tags
-
-        module PathHelper
-
-          def render_path(context, &block)
-            site  = context.registers[:site]
-
-            if page = self.retrieve_page_from_handle(context)
-              path = self.public_page_fullpath(context, page)
-
-              if block_given?
-                block.call page, path
-              else
-                path
-              end
-            else
-              raise Liquid::PageNotTranslated.new(%{[link_to] Unable to find a page for the #{@handle}. Wrong handle or missing template for your content.})
-            end
-          end
-
-          protected
-
-          def retrieve_page_from_handle(context)
-            mounting_point = context.registers[:mounting_point]
-
-            context.scopes.reverse_each do |scope|
-              handle = scope[@handle] || @handle
-
-              page = case handle
-              when Locomotive::Mounter::Models::Page          then handle
-              when Liquid::Drops::Page                        then handle.instance_variable_get(:@_source)
-              when String                                     then fetch_page(mounting_point, handle)
-              when Liquid::Drops::ContentEntry                then fetch_page(mounting_point, handle.instance_variable_get(:@_source), true)
-              when Locomotive::Mounter::Models::ContentEntry  then fetch_page(mounting_point, handle, true)
-              else
-                nil
-              end
-
-              return page unless page.nil?
-            end
-
-            nil
-          end
-
-          def fetch_page(mounting_point, handle, templatized = false)
-            ::Locomotive::Mounter.with_locale(@_options['locale']) do
-              if templatized
-                page = mounting_point.pages.values.find do |_page|
-                  _page.templatized? &&
-                  !_page.templatized_from_parent &&
-                  _page.content_type.slug == handle.content_type.slug &&
-                  (@_options['with'].nil? || _page.handle == @_options['with'])
-                end
-
-                page.content_entry = handle if page
-
-                page
-              else
-                mounting_point.pages.values.find { |_page| _page.handle == handle }
-              end
-            end
-          end
-
-          def public_page_fullpath(context, page)
-            mounting_point  = context.registers[:mounting_point]
-            locale          = @_options['locale'] || ::I18n.locale
-
-            if !page.translated_in?(locale)
-              title = page.title_translations.values.compact.first
-              raise Liquid::PageNotTranslated.new(%{the "#{title}" page is not translated in #{locale.upcase}})
-            end
-
-            fullpath = ::Locomotive::Mounter.with_locale(locale) do
-              page.fullpath.clone
-            end
-
-            fullpath = "#{locale}/#{fullpath}" if locale.to_s != mounting_point.default_locale.to_s
-
-            if page.templatized?
-              if page.content_entry._slug.nil?
-                title = %{#{page.content_entry.content_type.name.singularize} "#{page.content_entry.send(page.content_entry.content_type.label_field_name)}"}
-                raise Liquid::ContentEntryNotTranslated.new(%{the #{title} slug is not translated in #{locale.upcase}})
-              end
-              fullpath.gsub!(/(content[_-]type[_-]template|template)/, page.content_entry._slug)
-            end
-
-            File.join('/', fullpath)
-          end
-
-        end
-      end
-
-    end
-  end
-end

data/lib/locomotive/steam/loaders/yml/pages_loader.rb

@@ -1,193 +0,0 @@
-module Locomotive
-  module Steam
-    module Loader
-      module Yml
-        class PagesLoader
-          def initialize(path, mapper)
-            @root_path  = path
-            @path = File.join(path, 'app', 'views', 'pages')
-            @mapper = mapper
-          end
-
-
-          # Build the tree of pages based on the filesystem structure
-          #
-          # @return [ Hash ] The pages organized as a Hash (using the fullpath as the key)
-          #
-          def load!
-            entity_class = @mapper.collection(:pages).entity
-            repository = @mapper.collection(:pages).repository
-            all.each do |record|
-              page = entity_class.new(record)
-              repository.create page
-            end
-          end
-
-          protected
-
-          def build_relationships(parent, list)
-            # do not use an empty template for other locales than the default one
-            parent.set_default_template_for_each_locale(self.default_locale)
-
-            list.dup.each do |page|
-              next unless self.is_subpage_of?(page.fullpath, parent.fullpath)
-
-              # attach the page to the parent (order by position), also set the parent
-              parent.add_child(page)
-
-              # localize the fullpath in all the locales
-              page.localize_fullpath
-
-              # remove the page from the list
-              list.delete(page)
-
-              # go under
-              self.build_relationships(page, list)
-            end
-          end
-
-          # Record pages found in file system
-          def all
-            [].tap do |page_records|
-              position, last_dirname = nil, nil
-              tree.each do |pagename, localizations|
-                filepath = localizations.delete(:default)
-                #next unless File.directory?(filepath) || filepath =~ /\.(#{Locomotive::Steam::TEMPLATE_EXTENSIONS.join('|')})$/
-                if last_dirname != File.dirname(filepath)
-                  position, last_dirname = 100, File.dirname(filepath)
-                end
-                page = page_attributes(filepath, localizations)
-                page[:position] = position
-
-                page_records << page
-                position += 1
-              end
-            end
-          end
-
-          def tree
-           Locomotive::Steam::Utils::LocalizedTree
-              .new(all_files, Locomotive::Steam::TEMPLATE_EXTENSIONS)
-              .to_hash
-          end
-
-          def all_files
-            Dir.glob(File.join(root_dir, '**/*')).sort
-          end
-
-          def page_attributes(filepath, localizations)
-            {}.tap do |attributes|
-              add_base_attributes(attributes, filepath)
-              add_localized_attributes(attributes, filepath, :en)
-              localizations.each { |locale, locale_file| add_localized_attributes(attributes, locale_file, locale) }
-            end
-          end
-
-          def add_base_attributes(attributes, filepath)
-            attributes.merge! _base_attributes(filepath)
-          end
-
-          def add_localized_attributes(attributes, filepath, locale)
-            attributes.deep_merge! _localized_attributes(filepath, locale)
-          end
-
-          def _localized_attributes(filepath, locale)
-            fetch_raw_attrs(filepath).dup.select do |key, value|
-              %i{title slug fullpath redirect_url template
-              seo_title meta_keywords meta_description editable_elements}
-              .include? key
-
-            end.map { |key, item| {key => { "#{locale}".to_sym => item }} }.reduce(:merge)
-          end
-
-          def _base_attributes(filepath)
-            fetch_raw_attrs(filepath).dup.select do |key, value|
-              %i{content_type redirect_type handle listed searchable
-              templatized content_type published cache_strategy response_type
-              position}
-              .include? key
-            end
-          end
-
-          def fetch_raw_attrs(filepath)
-            raw_attrs[filepath]
-          end
-
-          def raw_attrs
-            @raw_attrs ||= Hash.new do |hsh, filepath|
-              attributes = {}
-              fullpath = self.filepath_to_fullpath(filepath)
-              attributes[:title]    = File.basename(fullpath).humanize
-              attributes[:fullpath] = fullpath
-              attributes[:template] = OpenStruct.new(raw_source: '') if File.directory?(filepath)
-              attributes.merge!(get_attributes_from_header(filepath)) unless File.directory?(filepath)
-              if content_type_slug = attributes.delete('content_type')
-                attributes[:templatized]   = true
-                attributes[:content_type]  = Locomotive::Models[:content_types][content_type_slug]
-              end
-              hsh[filepath] = attributes
-            end
-          end
-          # Set attributes of a page from the information
-          # stored in the header of the template (YAML matters).
-          # It also stores the template.
-          #
-          # @param [ Object ] page The page
-          # @param [ String ] filepath The path of the template
-          #
-          def get_attributes_from_header(filepath)
-            {}.tap do |attributes|
-              template = Locomotive::Steam::Utils::YAMLFrontMattersTemplate.new(filepath)
-              attributes[:template] = template
-              if template.attributes
-                attributes.merge! template.attributes.symbolize_keys
-              end
-            end
-          end
-
-          # Return the directory where all the templates of
-          # pages are stored in the filesystem.
-          #
-          # @return [ String ] The root directory
-          #
-          def root_dir
-            @path
-          end
-
-          # Take the path to a file on the filesystem
-          # and return its matching value for a Page.
-          #
-          # @param [ String ] filepath The path to the file
-          #
-          # @return [ String ] The fullpath of the page
-          #
-          def filepath_to_fullpath(filepath)
-            fullpath = filepath.gsub(File.join(self.root_dir, '/'), '')
-
-            fullpath.gsub!(/^\.\//, '')
-
-            fullpath.split('.').first.dasherize
-          end
-
-          # Tell is a page described by its fullpath is a sub page of a parent page
-          # also described by its fullpath
-          #
-          # @param [ String ] fullpath The full path of the page to test
-          # @param [ String ] parent_fullpath The full path of the parent page
-          #
-          # @return [ Boolean] True if the page is a sub page of the parent one
-          #
-          def is_subpage_of?(fullpath, parent_fullpath)
-            return false if %w(index 404).include?(fullpath)
-
-            if parent_fullpath == 'index' && fullpath.split('/').size == 1
-              return true
-            end
-
-            File.dirname(fullpath.dasherize) == parent_fullpath.dasherize
-          end
-        end
-      end
-    end
-  end
-end