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

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

@@ -0,0 +1,145 @@
+module Locomotive
+  module Steam
+    module Adapters
+      module Filesystem
+        module YAMLLoaders
+
+          class Page
+
+            include Adapters::Filesystem::YAMLLoader
+
+            def load(scope)
+              super
+              load_tree
+            end
+
+            private
+
+            def path
+              @path ||= File.join(site_path, 'app', 'views', 'pages')
+            end
+
+            def load_tree
+              {}.tap do |hash|
+                each_file do |filepath, relative_path, fullpath, locale|
+
+                  if leaf = hash[fullpath]
+                    update(leaf, filepath, fullpath, locale)
+                  else
+                    leaf = build(filepath, fullpath, locale)
+                  end
+
+                  hash[fullpath] = leaf
+                end
+              end.values
+            end
+
+            def build(filepath, fullpath, locale)
+              slug        = fullpath.split('/').last
+              attributes  = get_attributes(filepath, fullpath)
+
+              {
+                title:              { locale => attributes.delete(:title) || (default_locale == locale ? slug.humanize : nil) },
+                slug:               { locale => attributes.delete(:slug) || slug },
+                template_path:      { locale => template_path(filepath, attributes, locale) },
+                redirect_url:       { locale => attributes.delete(:redirect_url) },
+                editable_elements:  build_editable_elements(attributes.delete(:editable_elements), locale),
+                _fullpath:          fullpath
+              }.merge(attributes)
+            end
+
+            def update(leaf, filepath, fullpath, locale)
+              slug        = fullpath.split('/').last
+              attributes  = get_attributes(filepath, fullpath)
+
+              leaf[:title][locale]              = attributes.delete(:title) || slug.humanize
+              leaf[:slug][locale]               = attributes.delete(:slug) || slug
+              leaf[:template_path][locale]      = template_path(filepath, attributes, locale)
+              leaf[:redirect_url][locale]       = attributes.delete(:redirect_url)
+
+              update_editable_elements(leaf, attributes.delete(:editable_elements), locale)
+
+              leaf.merge!(attributes)
+            end
+
+            def get_attributes(filepath, fullpath)
+              _load(filepath, true) do |attributes, template|
+                # make sure index/404 are the slugs of the index/404 pages
+                attributes.delete(:slug) if %w(index 404).include?(fullpath)
+
+                # trick to use the template of the default locale (if available)
+                attributes[:template_path] = false if template.blank?
+              end
+            end
+
+            def each_file(&block)
+              Dir.glob(File.join(path, '**', '*')).each do |filepath|
+                next unless is_liquid_file?(filepath)
+
+                relative_path = get_relative_path(filepath)
+
+                fullpath, extension_or_locale = relative_path.split('.')[0..1]
+
+                locale = template_extensions.include?(extension_or_locale) ? default_locale : extension_or_locale
+
+                yield(filepath, relative_path, fullpath, locale.to_sym)
+              end
+            end
+
+            def is_liquid_file?(filepath)
+              filepath =~ /\.(#{template_extensions.join('|')})$/
+            end
+
+            def template_path(filepath, attributes, locale)
+              if attributes.delete(:template_path) == false && locale != default_locale
+                false
+              else
+                filepath
+              end
+            end
+
+            def get_relative_path(filepath)
+              filepath.gsub(path, '').gsub(/^\//, '')
+            end
+
+            def build_editable_elements(list, locale)
+              return [] if list.blank?
+
+              list.map do |name, content|
+                build_editable_element(name, content, locale)
+              end
+            end
+
+            def update_editable_elements(leaf, list, locale)
+              return if list.blank?
+
+              list.each do |name, content|
+                if el = find_editable_element(leaf, name)
+                  el[:content][locale] = content
+                else
+                  leaf[:editable_elements] << build_editable_element(name, content, locale)
+                end
+              end
+            end
+
+            def find_editable_element(leaf, name)
+              leaf[:editable_elements].find do |el|
+                [el[:block], el[:slug]].join('/') == name.to_s
+              end
+            end
+
+            def build_editable_element(name, content, locale)
+              segments    = name.to_s.split('/')
+              block, slug = segments[0..-2].join('/'), segments.last
+              block       = nil if block.blank?
+
+              { block: block, slug: slug, content: { locale => content } }
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Locomotive
+  module Steam
+    module Adapters
+      module Filesystem
+        module YAMLLoaders
+
+          class Site
+
+            include Adapters::Filesystem::YAMLLoader
+
+            def load(scope)
+              attributes = _load(File.join(site_path, 'config', 'site.yml'))
+
+              (attributes[:domains] ||= []) << 'localhost'
+
+              [attributes]
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Locomotive
+  module Steam
+    module Adapters
+      module Filesystem
+        module YAMLLoaders
+
+          class Snippet
+
+            include Adapters::Filesystem::YAMLLoader
+
+            def load(scope)
+              super
+              load_list
+            end
+
+            private
+
+            def load_list
+              {}.tap do |hash|
+                each_file do |filepath, slug, locale|
+                  _locale = locale || default_locale
+
+                  if element = hash[slug]
+                    update(element, filepath, _locale)
+                  else
+                    element = build(filepath, slug, _locale)
+                  end
+
+                  hash[slug] = element
+                end
+              end.values
+            end
+
+            def build(filepath, slug, locale)
+              {
+                name:           slug.humanize,
+                slug:           slug,
+                template_path:  { locale => filepath }
+              }
+            end
+
+            def update(element, filepath, locale)
+              element[:template_path][locale] = filepath
+            end
+
+            def each_file(&block)
+              Dir.glob(File.join(path, "*.{#{template_extensions.join(',')}}")).each do |filepath|
+
+                slug, locale = File.basename(filepath).split('.')[0..1]
+                locale = default_locale if template_extensions.include?(locale)
+
+                yield(filepath, slug.permalink, locale.to_sym)
+              end
+            end
+
+            def path
+              @path ||= File.join(site_path, 'app', 'views', 'snippets')
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Locomotive
+  module Steam
+    module Adapters
+      module Filesystem
+        module YAMLLoaders
+
+          class ThemeAsset
+
+            include Adapters::Filesystem::YAMLLoader
+
+            def load(scope)
+              []
+            end
+
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,72 @@
+module Locomotive
+  module Steam
+    module Adapters
+      module Filesystem
+        module YAMLLoaders
+
+          class Translation
+
+            include Adapters::Filesystem::YAMLLoader
+
+            def load(scope)
+              super
+              load_array
+            end
+
+            private
+
+            def load_array
+              [].tap do |array|
+                _load(path).each do |key, values|
+                  array << { key: key.to_s, values: HashConverter.to_string(values) }
+                end
+              end
+            end
+
+            def path
+              File.join(site_path, 'config', 'translations.yml')
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end
+
+# module Locomotive
+#   module Steam
+#     module Repositories
+#       module Filesystem
+#         module YAMLLoaders
+
+#           class Translation < Struct.new(:root_path, :cache)
+
+#             include YAMLLoaders::Concerns::Common
+
+#             def list_of_attributes
+#               cache.fetch('config/translations') { load_array }
+#             end
+
+#             private
+
+#             def load_array
+#               [].tap do |array|
+#                 load(path).each do |key, values|
+#                   array << { key: key.to_s, values: HashConverter.to_string(values) }
+#                 end
+#               end
+#             end
+
+#             def path
+#               File.join(root_path, 'config', 'translations.yml')
+#             end
+
+#           end
+
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/locomotive/steam/adapters/memory.rb

@@ -0,0 +1,55 @@
+require_relative 'concerns/key'
+require_relative 'memory/order'
+require_relative 'memory/condition'
+require_relative 'memory/query'
+require_relative 'memory/dataset'
+
+module Locomotive::Steam
+
+  class MemoryAdapter < Struct.new(:collection)
+
+    include Locomotive::Steam::Adapters::Concerns::Key
+
+    def all(mapper, scope)
+      memoized_dataset(mapper, scope)
+    end
+
+    def query(mapper, scope, &block)
+      _query(mapper, scope, &block)
+    end
+
+    def find(mapper, scope, id)
+      _query(mapper, scope) { where(_id: id) }.first
+    end
+
+    def base_url(mapper, scope, entity = nil)
+      ''
+    end
+
+    private
+
+    def _query(mapper, scope, &block)
+      Locomotive::Steam::Adapters::Memory::Query.new(all(mapper, scope), scope.locale, &block)
+    end
+
+    def memoized_dataset(mapper, scope)
+      return @dataset if @dataset
+      dataset(mapper, scope)
+    end
+
+    def dataset(mapper, scope)
+      Locomotive::Steam::Adapters::Memory::Dataset.new(mapper.name).tap do |dataset|
+        collection.each do |attributes|
+          # Note: very important to not manipulate the original attributes
+          # since the attributes might be modified further by the to_entity method
+          entity = mapper.to_entity(attributes.dup)
+          dataset.insert(entity)
+        end
+      end
+    end
+
+  end
+
+end
+
+

data/lib/locomotive/steam/adapters/memory/condition.rb

@@ -0,0 +1,103 @@
+module Locomotive::Steam
+  module Adapters
+    module Memory
+
+      class Condition
+
+        class UnsupportedOperator < StandardError; end
+
+        OPERATORS = %i(== eq ne neq matches gt gte lt lte size all in nin).freeze
+
+        attr_reader :field, :operator, :value
+
+        def initialize(operator_and_field, value, locale)
+          @locale = locale.try(:to_sym)
+          @operator_and_field, @value = operator_and_field, value
+          @operator, @field = :==, operator_and_field
+
+          decode_operator_and_field!
+        end
+
+        def matches?(entry)
+          entry_value = entry_value(entry)
+
+          adapt_operator!(entry_value)
+          case @operator
+          when :==        then entry_value == @value
+          when :eq        then entry_value == @value
+          when :ne        then entry_value != @value
+          when :neq       then entry_value != @value
+          when :matches   then @value =~ entry_value
+          when :gt        then entry_value > @value
+          when :gte       then entry_value >= @value
+          when :lt        then entry_value < @value
+          when :lte       then entry_value <= @value
+          when :size      then entry_value.size == @value
+          when :all       then array_contains?([*@value], entry_value)
+          when :in, :nin  then value_is_in_entry_value?(entry_value)
+          else
+            raise UnknownConditionInScope.new("#{@operator} is unknown or not implemented.")
+          end
+        end
+
+        def inspect
+          "#{field}.#{operator} #{value}"
+        end
+
+        protected
+
+        def entry_value(entry)
+          value = entry.send(@field)
+
+          if value.respond_to?(:translations)
+            value[@locale]
+          else
+            value
+          end
+        end
+
+        def decode_operator_and_field!
+          if match = @operator_and_field.match(/^(?<field>[a-z0-9_-]+)\.(?<operator>.*)$/)
+            @field    = match[:field].to_sym
+            @operator = match[:operator].to_sym
+            check_operator!
+          end
+
+          @operator = :matches if @value.is_a?(Regexp)
+        end
+
+        def adapt_operator!(value)
+          case value
+          when Array
+            @operator = :in if @operator == :==
+          end
+        end
+
+        def value_is_in_entry_value?(value)
+          _matches = if value.is_a?(Array)
+            array_contains?([*value], [*@value])
+          else
+            [*@value].include?(value)
+          end
+          @operator == :in ? _matches : !_matches
+        end
+
+        private
+
+        def check_operator!
+          raise UnsupportedOperator.new unless OPERATORS.include?(@operator)
+        end
+
+        def array_contains?(source, target)
+          if target.size == 0
+            source.size == 0
+          else
+            source & target == target
+          end
+        end
+
+      end
+
+    end
+  end
+end