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

data/lib/locomotive/steam/repositories.rb

@@ -0,0 +1,51 @@
+require_relative_all 'repositories'
+
+module Locomotive
+  module Steam
+
+    class Repositories < Struct.new(:current_site, :locale, :configuration)
+
+      include Morphine
+
+      register :adapter do
+        build_adapter(configuration.adapter)
+      end
+
+      register :site do
+        SiteRepository.new(adapter, nil, locale)
+      end
+
+      register :page do
+        PageRepository.new(adapter, current_site, locale)
+      end
+
+      register :snippet do
+        SnippetRepository.new(adapter, current_site, locale)
+      end
+
+      register :content_type do
+        ContentTypeRepository.new(adapter, current_site, locale)
+      end
+
+      register :content_entry do
+        ContentEntryRepository.new(adapter, current_site, locale, content_type)
+      end
+
+      register :theme_asset do
+        ThemeAssetRepository.new(adapter, current_site, locale)
+      end
+
+      register :translation do
+        TranslationRepository.new(adapter, current_site, locale)
+      end
+
+      def build_adapter(options)
+        name = ((options || {})[:name] || :filesystem).to_s
+        require_relative "adapters/#{name}"
+        klass = "Locomotive::Steam::#{name.camelize}Adapter".constantize
+        klass.new(options)
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/repositories/content_entry_repository.rb

@@ -0,0 +1,183 @@
+module Locomotive
+  module Steam
+
+    class ContentEntryRepository
+
+      include Models::Repository
+
+      attr_accessor :content_type_repository, :content_type
+
+      def initialize(adapter, site = nil, locale = nil, content_type_repository = nil)
+        @adapter  = adapter
+        @scope    = Locomotive::Steam::Models::Scope.new(site, locale)
+        @content_type_repository = content_type_repository
+        @local_conditions = {}
+        @memoized_mappers = {}
+      end
+
+      # Entity mapping
+      mapping :content_entries, entity: ContentEntry do
+        localized_attributes :_slug, :seo_title, :meta_description, :meta_keywords
+
+        default_attribute :content_type, -> (repository) { repository.content_type }
+      end
+
+      # this is the starting point of all the next methods
+      def with(type)
+        self.content_type = type # used for creating the scope
+        self.scope.context[:content_type] = type
+
+        @local_conditions[:content_type_id] = type.try(:_id)
+
+        self # chainable
+      end
+
+      def all(conditions = {}, &block)
+        conditions, order_by = conditions_without_order_by(conditions)
+
+        # priority:
+        # 1/ order_by passed in the conditions parameter
+        # 2/ the default order (_position) defined in the content type
+        order_by ||= content_type.order_by
+
+        query {
+          (block_given? ? instance_eval(&block) : where).
+            where(conditions).
+              order_by(order_by)
+        }.all
+      end
+
+      def count(conditions = {})
+        conditions, _ = conditions_without_order_by(conditions)
+        super() { where(conditions) }
+      end
+
+      def find(id)
+        conditions, _ = conditions_without_order_by(_id: id)
+        first { where(conditions) }
+      end
+
+      def exists?(conditions = {})
+        conditions, _ = conditions_without_order_by(conditions)
+        query { where(conditions) }.all.size > 0
+      end
+
+      def by_slug(slug)
+        conditions, _ = conditions_without_order_by(_slug: slug)
+        first { where(conditions) }
+      end
+
+      def value_for(entry, name, conditions = {})
+        return nil if entry.nil?
+
+        if field = content_type.fields_by_name[name]
+          value = entry.send(name)
+
+          if %i(has_many many_to_many).include?(field.type)
+            # a safe copy of the proxy repository is needed here
+            value = value.dup
+            # like this, we do not modify the original local conditions
+            value.local_conditions.merge!(conditions) if conditions
+          end
+
+          value
+        end
+      end
+
+      def next(entry)
+        next_or_previous(entry, 'gt', 'lt')
+      end
+
+      def previous(entry)
+        next_or_previous(entry, 'lt', 'gt')
+      end
+
+      def group_by_select_option(name)
+        return {} if name.nil? || content_type.nil? || content_type.fields_by_name[name].type != :select
+
+        # a big one request to get them grouped by the field
+        _groups = all.group_by { |entry| i18n_value_of(entry, name) }
+
+        groups_to_array(name, _groups).tap do |groups|
+          # entries with a not existing select_option value?
+          unless _groups.blank?
+            groups << { name: nil, entries: _groups.values.flatten }
+          end
+        end
+      end
+
+      def to_liquid
+        Locomotive::Steam::Liquid::Drops::ContentEntryCollection.new(content_type, self)
+      end
+
+      private
+
+      def mapper
+        key = self.content_type._id.to_s
+
+        return @memoized_mappers[key] if @memoized_mappers[key]
+
+        @memoized_mappers[key] = super(false).tap do |mapper|
+          add_localized_fields_to_mapper(mapper)
+          add_associations_to_mapper(mapper)
+        end
+      end
+
+      def conditions_without_order_by(conditions = {})
+        _conditions = prepare_conditions(conditions)
+        order_by = _conditions.delete(:order_by) || _conditions.delete('order_by')
+        [_conditions, order_by]
+      end
+
+      def prepare_conditions(*conditions)
+        super({ _visible: true }, conditions)
+      end
+
+      def add_localized_fields_to_mapper(mapper)
+        unless self.content_type.localized_names.blank?
+          mapper.localized_attributes(*self.content_type.localized_names)
+        end
+      end
+
+      def add_associations_to_mapper(mapper)
+        self.content_type.associations.each do |field|
+          mapper.association(field.type, field.name, self.class, field.association_options, &method(:prepare_repository_for_association))
+        end
+      end
+
+      # This code is executed once when the association proxy object receives a call to any method
+      def prepare_repository_for_association(repository, options)
+        # load the target content type
+        _content_type = content_type_repository.find(options[:target_id])
+
+        # the target repository uses this content type for all the other inner calls
+        repository.with(_content_type)
+
+        # the content type repository is also need by the target repository
+        repository.content_type_repository = content_type_repository
+      end
+
+      def next_or_previous(entry, asc_op, desc_op)
+        return nil if entry.nil?
+
+        with(entry.content_type)
+
+        name, direction = self.content_type.order_by.first
+        op = direction == 'asc' ? asc_op : desc_op
+
+        conditions = prepare_conditions({ k(name, op) => i18n_value_of(entry, name) })
+
+        first { where(conditions) }
+      end
+
+      def groups_to_array(name, groups)
+        content_type_repository.select_options(content_type, name).map do |option|
+          option_name = i18n_value_of(option, :name)
+          { name: option_name, entries: groups.delete(option_name) || [] }
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/repositories/content_type_field_repository.rb

@@ -0,0 +1,50 @@
+module Locomotive
+  module Steam
+
+    class ContentTypeFieldRepository
+
+      include Models::Repository
+
+      attr_accessor :content_type
+
+      # Entity mapping
+      mapping :content_type_fields, entity: ContentTypeField do
+        default_attribute :content_type, -> (repository) { repository.content_type }
+
+        embedded_association :select_options, ContentTypeFieldSelectOptionRepository
+      end
+
+      def selects
+        query { where(type: :select) }.all
+      end
+
+      def associations
+        query { where(k(:type, :in) => %i(belongs_to has_many many_to_many)) }.all
+      end
+
+      def unique
+        query { where(unique: true) }.all.inject({}) do |memo, field|
+          memo[field.name] = field
+          memo
+        end
+      end
+
+      def required
+        query { where(required: true) }.all
+      end
+
+      def localized_names
+        query { where(localized: true) }.all.map(&:name)
+      end
+
+      def select_options(name)
+        if field = first { where(name: name, type: :select) }
+          field.select_options.all
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/repositories/content_type_field_select_option_repository.rb

@@ -0,0 +1,23 @@
+module Locomotive
+  module Steam
+
+    class ContentTypeFieldSelectOptionRepository
+
+      include Models::Repository
+
+      attr_accessor :content_type_field
+
+      # Entity mapping
+      mapping :content_type_field_select_options, entity: ContentTypeField::SelectOption do
+        default_attribute :field, -> (repository) { repository.content_type_field }
+
+        localized_attributes :name
+      end
+
+      def all
+        query { order_by(position: :asc) }.all
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/repositories/content_type_repository.rb

@@ -0,0 +1,38 @@
+module Locomotive
+  module Steam
+
+    class ContentTypeRepository
+
+      include Models::Repository
+
+      # Entity mapping
+      mapping :content_types, entity: ContentType do
+        embedded_association :entries_custom_fields, ContentTypeFieldRepository
+      end
+
+      def by_slug(slug_or_content_type)
+        if slug_or_content_type.is_a?(String)
+          query { where(slug: slug_or_content_type) }.first
+        else
+          slug_or_content_type
+        end
+      end
+
+      def look_for_unique_fields(content_type)
+        return nil if content_type.nil?
+        content_type.fields.unique
+      end
+
+      def fields_for(content_type)
+        return nil if content_type.nil?
+        content_type.fields
+      end
+
+      def select_options(content_type, name)
+        return nil if content_type.nil? || name.nil?
+        content_type.fields.select_options(name.to_s)
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/repositories/editable_element_repository.rb

@@ -0,0 +1,20 @@
+module Locomotive
+  module Steam
+
+    class EditableElementRepository
+
+      include Models::Repository
+
+      attr_accessor :page
+
+      # Entity mapping
+      mapping :editable_elements, entity: EditableElement do
+        localized_attributes :content, :source, :default_content, :default_source_url
+
+        default_attribute :page, -> (repository) { repository.page }
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/repositories/page_repository.rb

@@ -0,0 +1,86 @@
+module Locomotive
+  module Steam
+
+    class PageRepository
+
+      include Models::Repository
+
+      # Entity mapping
+      mapping :pages, entity: Page do
+        localized_attributes :title, :slug, :permalink, :source, :raw_template, :template_path, :redirect_url, :fullpath, :seo_title, :meta_description, :meta_keywords
+
+        embedded_association :editable_elements, EditableElementRepository
+      end
+
+      def all(conditions = {})
+        query do
+          where(conditions || {}).
+            order_by(depth: :asc, position: :asc)
+        end.all
+      end
+
+      def published
+        query do
+          where(published: true).
+            order_by(depth: :asc, position: :asc)
+        end.all
+      end
+
+      def by_handle(handle)
+        first { where(handle: handle) }
+      end
+
+      def by_fullpath(path)
+        first { where(fullpath: path) }
+      end
+
+      def matching_fullpath(list)
+        all(k(:fullpath, :in) => list)
+      end
+
+      def template_for(entry, handle = nil)
+        conditions = { templatized: true, target_klass_name: entry.try(:_class_name) }
+
+        conditions[:handle] = handle if handle
+
+        all(conditions).first.tap do |page|
+          page.content_entry = entry if page
+        end
+      end
+
+      def root
+        first { where(fullpath: 'index') }
+      end
+
+      def parent_of(page)
+        return nil if page.nil? || page.index?
+        first { where(_id: page.parent_id) }
+      end
+
+      # Note: Ancestors and self
+      def ancestors_of(page)
+        return [] if page.nil?
+        all(k(:_id, :in) => page.parent_ids + [page._id])
+      end
+
+      def children_of(page)
+        return [] if page.nil?
+        all(parent_id: page._id)
+      end
+
+      def editable_elements_of(page)
+        return nil if page.nil?
+        page.editable_elements
+      end
+
+      def editable_element_for(page, block, slug)
+        return nil if page.nil?
+        page.editable_elements.first do
+          where(block: block, slug: slug)
+        end
+      end
+
+    end
+
+  end
+end