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

data/Rakefile

@@ -5,8 +5,34 @@ require 'bundler/gem_tasks'
 require 'rake'
 require 'rspec'
 
+# === Gems install tasks ===
+Bundler::GemHelper.install_tasks
+
+# require 'coveralls/rake/task'
+# Coveralls::RakeTask.new
+
 require_relative 'lib/locomotive/steam'
 
+namespace :mongodb do
+  namespace :test do
+    desc 'Seed the MongoDB database with the dump of the Sample website'
+    task :seed do
+      path = File.join(File.expand_path(File.dirname(__FILE__)), 'spec', 'fixtures', 'mongodb')
+      `mongo steam_test --eval "db.dropDatabase()"`
+      `mongorestore -d steam_test #{path}`
+    end
+  end
+end
+
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new('spec')
-task default: :spec
+
+RSpec::Core::RakeTask.new('spec:integration') do |spec|
+  spec.pattern = 'spec/integration/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('spec:unit') do |spec|
+  spec.pattern = 'spec/unit/**/*_spec.rb'
+end
+
+task default: ['mongodb:test:seed', :spec]

data/bin/steam.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+Bundler.require
+
+require 'thin'
+require 'optparse'
+
+server_options = { address: 'localhost', port: 8080 }
+
+options = {
+  adapter:  {
+    name:   :filesystem,
+    path:   ENV['SITE_PATH'] || File.join(File.dirname(__FILE__), '../spec/fixtures/default')
+  },
+  log_file: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: steam.rb [options]'
+
+  # Filesystem adapter
+  opts.on('-p', '--path PATH', 'Serve a Wagon site from a path in your filesystem') do |path|
+    options[:adapter][:path] = File.expand_path(path)
+    options[:asset_path] = File.expand_path(File.join(path, 'public'))
+    options[:database] = options[:hosts] = nil
+  end
+
+  # MongoDB adapter
+  opts.on('-d', '--database DATABASE', 'Serve a Wagon site from a MongoDB database') do |database|
+    options[:adapter].merge!(name: :'mongoDB', database: database)
+    options[:adapter][:hosts] ||= ['127.0.0.1']
+    options[:adapter].delete(:path)
+  end
+  opts.on('--hosts x,y,z', Array, 'Specify the MongoDB hosts') do |hosts|
+    options[:adapter][:hosts] = hosts
+  end
+
+  # Assets path
+  opts.on('-a', '--assets-path ASSETS_PATH', 'Tell Steam where to find the assets (if local)') do |path|
+    options[:asset_path] = path
+  end
+
+  # Asset host
+  opts.on('-h', '--asset-host HOST', 'Required if the assets are stored on Amazon S3 or through a CDN') do |host|
+    options[:asset_host]
+  end
+
+  # TCP port
+  opts.on('-p', '--port PORT', 'Run the HTTP server on the specified port (by default: 8080') do |port|
+    server_options[:port] = port
+  end
+
+  # Logger
+  opts.on('-l', '--log-file LOG_FILE', 'Log file of the Steam server') do |file|
+    options[:log_file] = File.expand_path(file)
+  end
+
+  # Help
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+require_relative '../lib/locomotive/steam'
+require_relative '../lib/locomotive/steam/server'
+
+Locomotive::Steam.configure do |config|
+  config.mode           = :test
+  config.adapter        = options[:adapter]
+  config.serve_assets   = options[:asset_path].present?
+  config.asset_path     = options[:asset_path]
+  config.asset_host     = options[:asset_host]
+  config.minify_assets  = false
+end
+
+Locomotive::Common.reset
+Locomotive::Common.configure do |config|
+  config.notifier = Locomotive::Common::Logger.setup(options[:log_file])
+end
+
+app = Locomotive::Steam::Server.to_app
+
+# Note: alt thin settings (Threaded)
+server = Thin::Server.new(server_options[:address], server_options[:port], app)
+server.threaded = true
+server.start
+# FIXME: Rack::Handler::Thin.run app (not threaded)
+
+# WEBRick rack handler
+# Rack::Handler::WEBrick.run app
+
+Locomotive::Common::Logger.info 'Server started...'

data/config/locales/en.yml

@@ -27,6 +27,7 @@ en:
       session_assign: "Syntax Error in 'session_assign' - Valid syntax: session_assign [var] = [source]"
     messages:
       blank: "can't not be blank"
+      unique: "must be unique"
 
   pagination:
     previous: "« Previous"
@@ -186,4 +187,4 @@ en:
       default: ! '%a, %d %b %Y %H:%M:%S %z'
       long: ! '%B %d, %Y %H:%M'
       short: ! '%d %b %H:%M'
-    pm: pm
+    pm: pm

data/config/locales/fr.yml

@@ -17,6 +17,7 @@ fr:
   errors:
     messages:
       blank: "doit être rempli(e)"
+      unique: "doit être unique"
 
   pagination:
     previous: "« Précédent"
@@ -145,4 +146,4 @@ fr:
       skip_last_comma: true
       words_connector: ", "
       two_words_connector: " et "
-      last_word_connector: " et "
+      last_word_connector: " et "

data/lib/locomotive/steam.rb

@@ -1,22 +1,28 @@
-require 'locomotive/models'
-require 'locomotive/decorators'
 require 'locomotive/common'
 
-require_relative 'steam/exceptions'
-require_relative 'steam/decorators'
-require_relative 'steam/configuration'
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/deprecation'
+require 'active_support/core_ext'
 
-require 'sprockets'
-require 'sprockets-sass'
-require 'haml'
-require 'compass'
+require_relative      'steam/core_ext'
+require_relative      'steam/configuration'
+require_relative_all  'steam/decorators'
+require_relative      'steam/liquid'
 
-#require 'httmultiparty'
-require 'mime/types'
+require_relative      'steam/models'
+require_relative_all  'steam/entities'
+require_relative      'steam/repositories'
+require_relative      'steam/services'
 
 module Locomotive
   module Steam
-    TEMPLATE_EXTENSIONS = %w(liquid haml)
+
+    FRONTMATTER_REGEXP = /^(?<yaml>(---\s*\n.*?\n?)^(---\s*$\n?))?(?<template>.*)/mo
+
+    WILDCARD = 'content_type_template'.freeze
+
+    CONTENT_ENTRY_ENGINE_CLASS_NAME = /^Locomotive::ContentEntry(.*)$/o
 
     class << self
       attr_writer :configuration
@@ -32,15 +38,18 @@ module Locomotive
 
     def self.configure
       yield(configuration)
-    end
 
-    class << self
-      def method_missing(name, *args, &block)
-        Locomotive::Steam.configuration.public_send(name)
-      rescue
-        super
-      end
+      require_relative 'steam/initializers'
     end
 
+    # FIXME: not sure it will ever be needed
+    # class << self
+    #   def method_missing(name, *args, &block)
+    #     Locomotive::Steam.configuration.public_send(name)
+    #   rescue
+    #     super
+    #   end
+    # end
+
   end
 end

data/lib/locomotive/steam/adapters/concerns/key.rb

@@ -0,0 +1,15 @@
+module Locomotive::Steam
+  module Adapters
+    module Concerns
+
+      module Key
+
+        def key(name, operator)
+          Locomotive::Steam::Adapters::Memory::Query.key(name, operator)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+require_relative 'memory'
+
+require_relative 'filesystem/simple_cache_store'
+
+require_relative 'filesystem/yaml_loader'
+require_relative_all 'filesystem/yaml_loaders'
+
+require_relative 'filesystem/sanitizer'
+require_relative_all 'filesystem/sanitizers'
+
+module Locomotive::Steam
+
+  class FilesystemAdapter < Struct.new(:options)
+
+    include Morphine
+    include Locomotive::Steam::Adapters::Concerns::Key
+
+    register :cache do
+      Locomotive::Steam::Adapters::Filesystem::SimpleCacheStore.new
+    end
+
+    register(:yaml_loaders)  { build_yaml_loaders }
+    register(:sanitizers)    { build_sanitizers }
+
+    def all(mapper, scope)
+      memoized_dataset(mapper, scope)
+    end
+
+    def query(mapper, scope, &block)
+      _query(mapper, scope, &block).tap do |default|
+        if scope.site
+          default.where(site_id: scope.site._id)
+        end
+      end
+    end
+
+    def create(mapper, scope, entity)
+      sanitizers[mapper.name].with(scope) do |sanitizer|
+        dataset = memoized_dataset(mapper, scope)
+        dataset.insert(entity)
+        sanitizer.apply_to_entity_with_dataset(entity, dataset)
+      end
+    end
+
+    def find(mapper, scope, id)
+      _query(mapper, scope) { where(_id: id) }.first
+    end
+
+    def base_url(mapper, scope, entity = nil)
+      ''
+    end
+
+    def count(mapper, scope, &block)
+      query(mapper, scope, &block).count
+    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)
+      cache.fetch(cache_key(mapper, scope)) do
+        dataset(mapper, scope)
+      end
+    end
+
+    def cache_key(mapper, scope)
+      "#{scope.to_key}_#{mapper.name}"
+    end
+
+    def dataset(mapper, scope)
+      Locomotive::Steam::Adapters::Memory::Dataset.new(mapper.name).tap do |dataset|
+        populate_dataset(dataset, mapper, scope)
+      end
+    end
+
+    def populate_dataset(dataset, mapper, scope)
+      sanitizers[mapper.name].with(scope) do |sanitizer|
+        collection(mapper, scope).each do |attributes|
+          entity = mapper.to_entity(attributes.dup)
+
+          dataset.insert(entity)
+          sanitizer.apply_to(entity)
+        end
+
+        sanitizer.apply_to(dataset)
+      end
+    end
+
+    def collection(mapper, scope)
+      yaml_loaders[mapper.name].load(scope)
+    end
+
+    def build_yaml_loaders
+      %i(sites pages content_types content_entries snippets translations theme_assets).inject({}) do |memo, name|
+        memo[name] = build_klass('YAMLLoaders', name).new(site_path)
+        memo
+      end
+    end
+
+    def build_sanitizers
+      hash = Hash.new { build_klass('Sanitizers', :simple).new }
+      %i(pages content_types content_entries snippets).inject(hash) do |memo, name|
+        memo[name] = build_klass('Sanitizers', name).new
+        memo
+      end
+    end
+
+    def build_klass(type, name)
+      _name = name.to_s.singularize.camelize
+      "Locomotive::Steam::Adapters::Filesystem::#{type}::#{_name}".constantize
+    end
+
+    def site_path
+      options.respond_to?(:has_key?) ? options[:path] : options
+    end
+
+  end
+
+end
+
+

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

@@ -0,0 +1,54 @@
+module Locomotive::Steam
+  module Adapters
+    module Filesystem
+
+      module Sanitizer
+
+        extend Forwardable
+
+        def_delegators :@scope, :site, :locale, :locales, :default_locale
+
+        attr_reader :scope
+
+        def setup(scope)
+          @scope = scope
+          self
+        end
+
+        def with(scope, &block)
+          setup(scope)
+          yield(self)
+        end
+
+        def apply_to(entity_or_dataset)
+          if entity_or_dataset.respond_to?(:all)
+            apply_to_dataset(entity_or_dataset)
+          else
+            apply_to_entity(entity_or_dataset)
+          end
+        end
+
+        def apply_to_dataset(dataset)
+          dataset
+        end
+
+        def apply_to_entity(entity)
+          attach_site_to(entity)
+          entity
+        end
+
+        def apply_to_entity_with_dataset(entity, dataset)
+          entity
+        end
+
+        def attach_site_to(entity)
+          entity[:site_id] = scope.site._id if scope.site
+        end
+
+        alias :current_locale :locale
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Locomotive::Steam
+  module Adapters
+    module Filesystem
+      module Sanitizers
+
+        class ContentEntry
+
+          include Adapters::Filesystem::Sanitizer
+
+          def apply_to_entity(entity)
+            super
+            add_label(entity)
+          end
+
+          def apply_to_dataset(dataset)
+            dataset.all.each do |entity|
+              _apply_to_dataset(entity, dataset)
+            end
+          end
+
+          def apply_to_entity_with_dataset(entity, dataset)
+            # Note: this statement attaches the site to the entity
+            apply_to_entity(entity)
+
+            # make sure it gets an unique slug and an _id
+            _apply_to_dataset(entity, dataset)
+          end
+
+          private
+
+          def _apply_to_dataset(entity, dataset)
+            set_slug(entity, dataset)
+            set_id(entity)
+          end
+
+          def add_label(entity)
+            value = entity.attributes.delete(:_label)
+            name  = entity.content_type.label_field_name
+
+            if entity.attributes[name].respond_to?(:translations) # localized?
+              entity.attributes[name][default_locale] = value
+            else
+              entity.attributes[name] ||= value
+            end
+          end
+
+          def set_id(entity)
+            if (slug = entity[:_slug]).respond_to?(:translations)
+              entity[:_id] = slug[locale]
+            else
+              entity[:_id] = slug
+            end
+          end
+
+          def set_slug(entity, dataset)
+            if entity._label.respond_to?(:translations) # localized?
+              entity._label.each do |locale, label|
+                entity[:_slug][locale] ||= slugify(entity._id, label, dataset, locale)
+              end
+            else
+              # Note: replace the translations of the I18nField by a string
+              entity[:_slug].translations = slugify(entity._id, entity._label, dataset)
+            end
+          end
+
+          def slugify(id, label, dataset, locale = nil)
+            base, index = label.permalink(false), nil
+            _slugify = -> (i) { [base, i].compact.join('-') }
+
+            while !is_slug_unique?(id, _slugify.call(index), dataset, locale)
+              index = index ? index + 1 : 1
+            end
+
+            _slugify.call(index)
+          end
+
+          def is_slug_unique?(id, slug, dataset, locale)
+            dataset.query(locale) { where(_slug: slug, k(:_id, :ne) => id) }.first.nil?
+          end
+
+        end
+
+      end
+    end
+  end
+end