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

data/lib/locomotive/steam/middlewares/sitemap.rb

@@ -0,0 +1,94 @@
+module Locomotive::Steam
+  module Middlewares
+
+    class Sitemap < ThreadSafe
+
+      include Helpers
+
+      def _call
+        if env['PATH_INFO'] == '/sitemap.xml'
+          render_response(build_xml, 200, 'text/plain')
+        end
+      end
+
+      private
+
+      def build_xml
+        <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>#{base_url}</loc>
+    <priority>1.0</priority>
+  </url>
+#{build_pages_to_xml}
+</urlset>
+        EOF
+      end
+
+      def build_pages_to_xml
+        repositories.page.published.map do |page|
+          next if page.index? || page.not_found?
+
+          build_page_xml(page)
+        end.flatten.join.strip
+      end
+
+      def build_page_xml(page)
+        _page = Locomotive::Steam::Decorators::I18nDecorator.new(page)
+
+        site.locales.map do |locale|
+          _page.__locale__ = locale
+
+          next if _page.title.blank? # should be translated
+
+          if _page.templatized?
+            build_templatized_page_xml(_page, locale)
+          else
+            page_to_xml(_page, locale)
+          end
+        end
+      end
+
+      def build_templatized_page_xml(page, locale)
+        content_type = repositories.content_type.find(page.content_type_id)
+
+        repositories.content_entry.with(content_type).all.map do |entry|
+          _entry = Locomotive::Steam::Decorators::I18nDecorator.new(entry, locale)
+
+          next if _entry._label.blank? # should be translated
+
+          page.content_entry = _entry
+
+          page_to_xml(page, locale)
+        end
+      end
+
+      def page_to_xml(page, locale)
+        last_modification = (page.content_entry || page).updated_at.to_date
+
+        <<-EOF
+  <url>
+    <loc>#{base_url}#{url_for(page, locale)}</loc>
+    <lastmod>#{last_modification.to_s('%Y-%m-%d')}</lastmod>
+    <priority>0.9</priority>
+  </url>
+        EOF
+      end
+
+      def repositories
+        services.repositories
+      end
+
+      def url_for(page, locale = nil)
+        services.url_builder.url_for(page, locale)
+      end
+
+      def base_url
+        "#{request.scheme}://#{request.host_with_port}"
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/middlewares/stack_proxy.rb

@@ -0,0 +1,46 @@
+module Locomotive::Steam::Middlewares
+
+  class StackProxy
+
+    attr_reader :list, :operations
+
+    def initialize(&block)
+      @list = []
+      instance_eval(&block) if block_given?
+    end
+
+    def use(*args, &block)
+      @list << [args, block]
+    end
+
+    def insert_before(index, *args, &block)
+      @list.insert(index_of(index), [args, block])
+    end
+
+    def insert_after(index, *args, &block)
+      @list.insert(index_of(index) + 1, [args, block])
+    end
+
+    def delete(index)
+      @list.delete_at(index_of(index))
+    end
+
+    alias :insert :insert_before
+
+    def inject(builder)
+      @list.each do |args|
+        builder.use(*(args[0]), &args[1])
+      end
+    end
+
+    def index_of(index)
+      if index.is_a?(Integer)
+        index
+      else
+        @list.index { |args| args[0][0] == index }
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/steam/middlewares/templatized_page.rb

@@ -1,32 +1,58 @@
 module Locomotive::Steam
   module Middlewares
 
-    class TemplatizedPage < Base
+    class TemplatizedPage < ThreadSafe
 
-      def _call(env)
-        super
+      include Helpers
 
-        if self.page && self.page.templatized?
-          self.set_content_entry!(env)
+      def _call
+        if page && page.templatized?
+          set_content_entry!
         end
-
-        app.call(env)
       end
 
       protected
 
-      def set_content_entry!(env)
-        %r(^#{self.page.safe_fullpath.gsub('*', '([^\/]+)')}$) =~ self.path
+      def set_content_entry!
+        # extract the slug of the content entry
+        %r(^#{page.fullpath.gsub(Locomotive::Steam::WILDCARD, '([^\/]+)')}$) =~ path
+
+        if entry = fetch_content_entry($1)
+          # the entry will be available in the template under different keys
+          ['content_entry', 'entry', entry.content_type.slug.singularize].each do |key|
+           liquid_assigns[key] = entry
+          end
+
+          env['steam.content_entry'] = page.content_entry = entry
 
-        permalink = $1
+          # log it
+          log "Found content entry: #{entry._label}"
+        else
+          redirect_to '/404', 302
+        end
+      end
 
-        if content_entry = self.page.content_type.find_entry(permalink)
-          env['steam.content_entry'] = content_entry
+      def fetch_content_entry(slug)
+        if type = content_type_repository.find(page.content_type_id)
+          decorate(content_entry_repository.with(type).by_slug(slug))
         else
-          env['steam.page'] = nil
+          nil
         end
       end
 
+      def decorate(entry)
+        return nil if entry.nil?
+        Locomotive::Steam::Decorators::I18nDecorator.new(entry, default_locale)
+      end
+
+      def content_type_repository
+        services.repositories.content_type
+      end
+
+      def content_entry_repository
+        services.repositories.content_entry
+      end
+
     end
   end
-end
+end

data/lib/locomotive/steam/middlewares/threadsafe.rb

@@ -0,0 +1,65 @@
+module Locomotive::Steam::Middlewares
+
+  class ThreadSafe < Struct.new(:app)
+
+    attr_accessor :env
+
+    def call(env)
+      threadsafed = dup
+      threadsafed.env = env
+
+      # time = Benchmark.realtime do
+      threadsafed._call # thread-safe purpose
+      # end
+
+      # puts "[Benchmark][#{self.class.name}] Time elapsed #{time*1000} milliseconds"
+
+      threadsafed.next
+    end
+
+    def next
+      # avoid to be called twice
+      @next_response || (@next_response = app.call(env))
+    end
+
+    #= Shortcuts =
+
+    def services
+      @services ||= env.fetch('steam.services')
+    end
+
+    def request
+      @request ||= env.fetch('steam.request')
+    end
+
+    def site
+      @site ||= env.fetch('steam.site')
+    end
+
+    def page
+      @page ||= env.fetch('steam.page')
+    end
+
+    def path
+      @path ||= env.fetch('steam.path')
+    end
+
+    def locale
+      @locale ||= env.fetch('steam.locale')
+    end
+
+    def liquid_assigns
+      @liquid_assigns ||= env.fetch('steam.liquid_assigns')
+    end
+
+    def default_locale
+      site.default_locale
+    end
+
+    def params
+      @params ||= self.request.params.with_indifferent_access
+    end
+
+  end
+
+end

data/lib/locomotive/steam/middlewares/timezone.rb

@@ -3,16 +3,20 @@ module Locomotive::Steam
 
     # Set the timezone according to the settings of the site
     #
-    class Timezone < Base
+    class Timezone < ThreadSafe
 
-      def _call(env)
-        super
+      include Helpers
 
-        Time.use_zone(site.try(:timezone) || 'UTC') do
-          app.call(env)
+      def _call
+        timezone = site.try(:timezone)
+
+        log "Timezone: #{timezone.name}"
+
+        Time.use_zone(timezone) do
+          self.next
         end
       end
 
     end
   end
-end
+end

data/lib/locomotive/steam/models.rb

@@ -0,0 +1,12 @@
+require_relative 'models/concerns/validation'
+require_relative 'models/i18n_field'
+require_relative 'models/associations/embedded'
+require_relative 'models/associations/referenced'
+require_relative 'models/associations/belongs_to'
+require_relative 'models/associations/has_many'
+require_relative 'models/associations/many_to_many'
+require_relative 'models/entity'
+require_relative 'models/mapper'
+require_relative 'models/scope'
+require_relative 'models/repository'
+require_relative 'models/pager'

data/lib/locomotive/steam/models/associations/belongs_to.rb

@@ -0,0 +1,18 @@
+module Locomotive::Steam
+  module Models
+
+    class BelongsToAssociation < ReferencedAssociation
+
+      def __load__
+        name      = @options[:association_name]
+        target_id = @entity[:"#{name}_id"]
+        target    = @repository.find(target_id)
+
+        # replace the proxy class by the real target entity
+        @entity[name] = target
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/models/associations/embedded.rb

@@ -0,0 +1,43 @@
+require 'locomotive/steam/adapters/memory'
+require 'morphine'
+
+module Locomotive::Steam
+  module Models
+
+    # Note: represents an embedded collection
+    class EmbeddedAssociation
+
+      include Morphine
+
+      register :adapter do
+        Locomotive::Steam::MemoryAdapter.new(nil)
+      end
+
+      # use the scope from the parent repository
+      # one of the benefits is that if we change the current locale
+      # of the parent repository, that will change the local repository
+      # as well.
+      def initialize(repository_klass, collection, scope, options = {})
+        adapter.collection = collection
+
+        @repository = repository_klass.new(adapter)
+        @repository.scope = scope
+
+        @options = options
+      end
+
+      # In order to keep track of the entity which owns
+      # the association.
+      def __attach__(entity)
+        name = @options[:mapper_name].to_s.singularize.to_sym
+        @repository.send(:"#{name}=", entity)
+      end
+
+      def method_missing(name, *args, &block)
+        @repository.send(name, *args, &block)
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/models/associations/has_many.rb

@@ -0,0 +1,22 @@
+module Locomotive::Steam
+  module Models
+
+    class HasManyAssociation < ReferencedAssociation
+
+      def __load__
+        key = :"#{@options[:inverse_of]}_id"
+
+        # all the further queries will be scoped by the "foreign_key"
+        @repository.local_conditions[key] = @entity._id
+
+        # use order_by from options as the default one for further queries
+        @repository.local_conditions[:order_by] = @options[:order_by] unless @options[:order_by].blank?
+
+        # all the further calls (method_missing) will be delegated to @repository
+        @repository
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/models/associations/many_to_many.rb

@@ -0,0 +1,22 @@
+module Locomotive::Steam
+  module Models
+
+    class ManyToManyAssociation < ReferencedAssociation
+
+      def __load__
+        source_key = :"#{@options[:association_name].to_s.singularize}_ids"
+        key = @repository.k(:_id, :in)
+
+        @repository.local_conditions[key] = @entity[source_key]
+
+        # use order_by from options as the default one for further queries
+        @repository.local_conditions[:order_by] = @options[:order_by] unless @options[:order_by].blank?
+
+        # all the further calls (method_missing) will be delegated to @repository
+        @repository
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/models/associations/referenced.rb

@@ -0,0 +1,48 @@
+module Locomotive::Steam
+  module Models
+
+    class ReferencedAssociation
+
+      attr_reader :repository
+
+      def initialize(repository_klass, scope, adapter, options = {}, &block)
+        # build a new instance of the target repository
+        @repository = repository_klass.new(adapter)
+
+        # Note: if we change the locale of the parent repository, that won't
+        # reflect in that repository
+        @repository.scope = scope.dup
+
+        # the block will executed when a method of the target will be called
+        @block = block_given? ? block : nil
+
+        @options = options
+      end
+
+      def __attach__(entity)
+        @entity = entity
+      end
+
+      def __load__
+        # needs implementation
+      end
+
+      def __call_block_once__
+        # setup the repository if custom configuration from the
+        # repository for instance.
+        if @block
+          @block.call(@repository, @options)
+          @block = nil # trick to call it only once
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        __call_block_once__
+
+        __load__.try(:send, name, *args, &block)
+      end
+
+    end
+
+  end
+end