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

data/lib/locomotive/steam/adapters/filesystem/sanitizers/content_type.rb

@@ -0,0 +1,21 @@
+module Locomotive::Steam
+  module Adapters
+    module Filesystem
+      module Sanitizers
+
+        class ContentType
+
+          include Adapters::Filesystem::Sanitizer
+
+          def apply_to_entity(entity)
+            super
+
+            entity[:slug] = entity[:slug].to_s
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/adapters/filesystem/sanitizers/page.rb

@@ -0,0 +1,160 @@
+module Locomotive::Steam
+  module Adapters
+    module Filesystem
+      module Sanitizers
+
+        class Page
+
+          include Adapters::Filesystem::Sanitizer
+
+          def setup(scope)
+            super.tap do
+              @ids, @parent_ids = {}, {}
+              @content_types    = {}
+              @localized = locales.inject({}) { |m, l| m[l] = {}; m }
+            end
+          end
+
+          def apply_to_entity(entity)
+            super
+
+            record_id(entity) # required to get the parent_id
+
+            locales.each do |locale|
+              set_default_redirect_type(entity, locale)
+              modify_if_templatized(entity, locale)
+            end
+          end
+
+          def apply_to_dataset(dataset)
+            sorted_collection(dataset.records.values).each do |page|
+              locales.each do |locale|
+                # the following method needs to be called first
+                set_fullpath_for(page, locale)
+
+                set_parent_id(page)
+                use_default_locale_template_path(page, locale)
+              end
+
+              modify_if_nested_templatized(page)
+            end
+          end
+
+          # when this is called, the @ids hash has been populated completely
+          def set_parent_id(page)
+            return if page.not_found?
+
+            parent_key = parent_fullpath(page)
+
+            page[:parent_ids] = @parent_ids[parent_key] || []
+            page[:parent_id]  = @ids[parent_key]
+
+            @parent_ids[page._fullpath] = page.parent_ids + [page._id]
+          end
+
+          # If the page does not have a template in a locale
+          # then use the template of the default locale
+          #
+          def use_default_locale_template_path(page, locale)
+            paths = page.template_path
+
+            if paths[locale] == false
+              paths[locale] = paths[default_locale]
+            end
+          end
+
+          def set_default_redirect_type(page, locale)
+            if page.redirect_url[locale]
+              page.attributes[:redirect_type] ||= 301
+            end
+          end
+
+          def modify_if_nested_templatized(page)
+            if content_type = fetch_content_type(parent_fullpath(page))
+              # not a templatized page but it becomes one because
+              # its parent is one of them
+              _modify_if_templatized(page, content_type)
+            end
+          end
+
+          def set_fullpath_for(page, locale)
+            page._fullpath ||= page.attributes.delete(:_fullpath)
+
+            slug = fullpath = page.slug[locale].try(page.templatized? ? :to_s : :dasherize)
+
+            return if slug.blank?
+
+            if page.depth > 1
+              base = parent_fullpath(page)
+              fullpath = (fetch_localized_fullpath(base, locale) || base) + '/' + slug
+            end
+
+            set_localized_fullpath(page._fullpath, fullpath, locale)
+            page[:fullpath][locale] = fullpath
+          end
+
+          def depth(page)
+            return page.depth if page.depth
+
+            page.depth = page[:_fullpath].split('/').size
+
+            if page.depth == 1 && system_pages?(page)
+              page.depth = 0
+            end
+
+            page.depth
+          end
+
+          def system_pages?(page)
+            %w(index 404).include?(page.slug.values.compact.first)
+          end
+
+          def sorted_collection(collection)
+            collection.sort_by { |page| depth(page) }
+          end
+
+          def parent_fullpath(page)
+            return nil if page._fullpath == 'index'
+            path = page._fullpath.split('/')[0..-2].join('/')
+            path.blank? ? 'index' : path
+          end
+
+          def fetch_content_type(fullpath)
+            @content_types[fullpath]
+          end
+
+          def set_content_type(fullpath, value)
+            @content_types[fullpath] = value
+          end
+
+          def fetch_localized_fullpath(fullpath, locale)
+            @localized[locale][fullpath]
+          end
+
+          def set_localized_fullpath(fullpath, value, locale)
+            @localized[locale][fullpath] = value
+          end
+
+          def record_id(entity)
+            @ids[entity[:_fullpath]] = entity._id
+          end
+
+          def modify_if_templatized(page, locale)
+            if content_type = page[:content_type]
+              _modify_if_templatized(page, content_type)
+              page[:slug][locale] = Locomotive::Steam::WILDCARD
+              set_content_type(page[:_fullpath], content_type)
+            end
+          end
+
+          def _modify_if_templatized(page, content_type)
+            page[:templatized]        = true
+            page[:target_klass_name]  = "Locomotive::ContentEntry#{content_type}"
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/adapters/filesystem/sanitizers/simple.rb

@@ -0,0 +1,15 @@
+module Locomotive::Steam
+  module Adapters
+    module Filesystem
+      module Sanitizers
+
+        class Simple
+
+          include Adapters::Filesystem::Sanitizer
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/adapters/filesystem/sanitizers/snippet.rb

@@ -0,0 +1,33 @@
+module Locomotive::Steam
+  module Adapters
+    module Filesystem
+      module Sanitizers
+
+        class Snippet
+
+          include Adapters::Filesystem::Sanitizer
+
+          def apply_to_entity(entity)
+            super
+
+            use_default_template_if_missing_locale(entity)
+          end
+
+          private
+
+          def use_default_template_if_missing_locale(entity)
+            # if there a missing template in one of the locales,
+            # then use the one from the default locale
+            default = entity.template_path[default_locale]
+            locales.each do |locale|
+              next if locale == default_locale
+              entity.template_path[locale] ||= default
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/adapters/filesystem/simple_cache_store.rb

@@ -0,0 +1,38 @@
+module Locomotive::Steam
+  module Adapters
+    module Filesystem
+
+      class SimpleCacheStore
+
+        @@store = {}
+
+        def fetch(name, options = nil, &block)
+          if block_given?
+            read(name) || write(name, yield)
+          else
+            read(name)
+          end
+        end
+
+        def read(name, options = nil)
+          @@store[name]
+        end
+
+        def write(name, value, options = nil)
+          @@store[name] = value
+        end
+
+        def clear
+          @@store.clear
+        end
+
+        #:nocov:
+        def _store
+          @@store
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/adapters/filesystem/yaml_loader.rb

@@ -0,0 +1,47 @@
+module Locomotive::Steam
+  module Adapters
+    module Filesystem
+
+      module YAMLLoader
+
+        attr_reader :site_path
+
+        def initialize(site_path)
+          @site_path = site_path
+        end
+
+        def load(scope = nil)
+          @scope = scope
+        end
+
+        def default_locale
+          @scope.default_locale
+        end
+
+        def _load(path, frontmatter = false, &block)
+          if File.exists?(path)
+            yaml      = File.open(path).read.force_encoding('utf-8')
+            template  = nil
+
+            if frontmatter && match = yaml.match(FRONTMATTER_REGEXP)
+              yaml, template = match[:yaml], match[:template]
+            end
+
+            HashConverter.to_sym(YAML.load(yaml)).tap do |attributes|
+              block.call(attributes, template) if block_given?
+            end
+          else
+            Locomotive::Common::Logger.error "No #{path} file found"
+            {}
+          end
+        end
+
+        def template_extensions
+          @extensions ||= %w(liquid haml)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/adapters/filesystem/yaml_loaders/content_entry.rb

@@ -0,0 +1,87 @@
+module Locomotive
+  module Steam
+    module Adapters
+      module Filesystem
+        module YAMLLoaders
+
+          class ContentEntry
+
+            include Adapters::Filesystem::YAMLLoader
+
+            def load(scope)
+              super
+              load_list
+            end
+
+            private
+
+            def load_list
+              [].tap do |list|
+                each(content_type_slug) do |label, attributes, position|
+                  _attributes = { _position: position, _label: label.to_s }.merge(attributes)
+
+                  modify_for_selects(_attributes)
+                  modify_for_associations(_attributes)
+
+                  list << _attributes
+                end
+              end
+            end
+
+            def modify_for_selects(attributes)
+              content_type.selects.each do |field|
+                attributes[:"#{field.name}_id"] = attributes.delete(field.name.to_sym)
+              end
+            end
+
+            def modify_for_associations(attributes)
+              content_type.associations.each do |field|
+                case field.type
+                when :belongs_to
+                  modify_belongs_to_association(field, attributes)
+                when :many_to_many
+                  modify_many_to_many_association(field, attributes)
+                end
+              end
+            end
+
+            def modify_belongs_to_association(field, attributes)
+              # <name>_id
+              attributes[:"#{field.name}_id"] = attributes.delete(field.name.to_sym)
+
+              # _position_in_<name>
+              attributes[:"position_in_#{field.name}"] = attributes[:_position]
+            end
+
+            def modify_many_to_many_association(field, attributes)
+              attributes[:"#{field.name.to_s.singularize}_ids"] = attributes.delete(field.name.to_sym)
+            end
+
+            def each(slug, &block)
+              position = 0
+              _load(File.join(path, "#{slug}.yml")).each do |element|
+                label, attributes = element.keys.first, element.values.first
+                yield(label, attributes, position)
+                position += 1
+              end
+            end
+
+            def path
+              File.join(site_path, 'data')
+            end
+
+            def content_type
+              @scope.context[:content_type]
+            end
+
+            def content_type_slug
+              content_type.slug
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/steam/adapters/filesystem/yaml_loaders/content_type.rb

@@ -0,0 +1,96 @@
+module Locomotive
+  module Steam
+    module Adapters
+      module Filesystem
+        module YAMLLoaders
+
+          class ContentType
+
+            include Adapters::Filesystem::YAMLLoader
+
+            def load(scope)
+              super
+              load_list
+            end
+
+            private
+
+            def load_list
+              [].tap do |array|
+                each_file do |filepath, slug|
+                  attributes = _load(filepath)
+                  attributes[:entries_custom_fields] = build_fields(attributes.delete(:fields))
+                  array << { _id: slug.to_s, slug: slug }.merge(attributes)
+                end
+              end
+            end
+
+            def build_fields(list)
+              list.map do |attributes|
+                build_field(attributes.keys.first, attributes.values.first)
+              end
+            end
+
+            def build_field(name, attributes)
+              attributes.tap do |attributes|
+                attributes[:name] = name.to_s
+                attributes[:type] = attributes[:type].try(:to_s)
+
+                if attributes[:label].blank?
+                  attributes[:label] = name.to_s.humanize
+                end
+
+                if select_options = attributes.delete(:select_options)
+                  attributes[:select_options] = build_select_options(select_options)
+                end
+              end
+            end
+
+            def build_select_options(options)
+              if options.is_a?(Hash)
+                build_select_options_from_hash(options)
+              else
+                build_select_options_from_array(options)
+              end
+            end
+
+            def build_select_options_from_hash(options)
+              [].tap do |list|
+                options.each do |locale, values|
+                  values.each_with_index do |name, position|
+                    if (option = list.at(position)).nil?
+                      list << { _id: name, name: { locale => name }, position: position }
+                    else
+                      option[name][locale] = name
+                    end
+                  end
+                end
+              end
+            end
+
+            def build_select_options_from_array(options)
+              [].tap do |list|
+                options.each_with_index do |name, position|
+                  list << { _id: name, name: name, position: position }
+                end
+              end
+            end
+
+            def each_file(&block)
+              Dir.glob(File.join(path, "*.yml")).each do |filepath|
+                slug = File.basename(filepath, '.yml')
+                yield(filepath, slug)
+              end
+            end
+
+            def path
+              File.join(site_path, 'app', 'content_types')
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end