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

data/lib/locomotive/steam/configuration.rb

@@ -2,11 +2,115 @@ module Locomotive
   module Steam
 
     class Configuration
+
+      # Mainly used in the liquid templates (variable name: {{ mode }})
+      # to distinguish the page rendered in Wagon (:test) or in the Engine.
+      #
+      # default: :production
+      #
       attr_accessor :mode
+      def mode; @mode || :production; end
+
+      # Steam needs an adapter in order to fetch the site content (site itself, pages, content entries, ...etc).
+      # By default, Steam is shipped with 2 adapters:
+      #     - Filesystem (options: path). the path option should point to the root path of the site
+      #     - MongoDB (options: database, hosts)
+      #
+      # default: { name: :filesytem, path: nil }
+      #
+      attr_accessor :adapter
 
-      def initialize
-        self.mode = :production
+      # Manage the list of middlewares used by the rack stack.
+      #
+      # Example:
+      #
+      #   Locomotive::Steam.configure do |config|
+      #     ...
+      #     config.middleware.remove Rack::Lint
+      #     ...
+      #     config.middleware.insert_after Middleware::Locale, MySlugMiddleware, answer: 42
+      #     ...
+      #   end
+      #
+      attr_accessor :middleware
+      def middleware
+        @middleware ||= Middlewares::StackProxy.new(&Locomotive::Steam::Server.default_middlewares)
       end
+
+      # Add the checksum of a theme asset at the end of its path to allow public caching.
+      #
+      # default: false (disabled)
+      #
+      attr_accessor :theme_assets_checksum
+      def theme_assets_checksum; @theme_assets_checksum.nil? ? false : @theme_assets_checksum; end
+
+      # Enable serving of images, stylesheets, and JavaScripts from an asset server.
+      # Useful if a CDN is used to serve assets.
+      #
+      # default: nil
+      #
+      attr_accessor :asset_host
+
+      # Tell if Steam has to also serve static (images) or dynamic (SASS, Coffeescript) assets.
+      #
+      # default: true
+      #
+      attr_accessor :serve_assets
+      def serve_assets; @serve_assets.nil? ? true : @serve_assets; end
+
+      # Path to the assets (if Steam serves the assets).
+      #
+      # default: nil
+      #
+      attr_accessor :asset_path
+
+      # If java is installed and if this option is enabled,
+      # then YUI::JavaScriptCompressor and YUI::CssCompressor are used to minify the css and the javascript.
+      #
+      # default: false
+      #
+      attr_accessor :minify_assets
+      def minify_assets; @minify_assets.nil? ? false : @minify_assets; end
+
+      # Dragonfly needs it to generate the protective SHA.
+      #
+      # default: 'please change it'
+      #
+      attr_accessor :image_resizer_secret
+      def image_resizer_secret; @image_resizer_secret.nil? ? 'please change it' : @image_resizer_secret; end
+
+      # Enable the Cross-site request forgery protection for POST requests.
+      #
+      # default: true
+      #
+      attr_accessor :csrf_protection
+      def csrf_protection; @csrf_protection.nil? ? true : @csrf_protection; end
+
+      # Options for the store of Moneta (Session)
+      #
+      # default: { store: Moneta.new(:Memory, expires: true) }
+      #
+      attr_accessor :moneta
+      def moneta; @moneta.nil? ? { store: Moneta.new(:Memory, expires: true) } : @moneta; end
+
+      # Lambda called once a Services instance has been built.
+      # It is used when we want to change one of the services
+      #
+      # Example:
+      #
+      # Locomotive::Steam.configure do |config|
+      #
+      #   config.services_hook = -> (services) {
+      #     require 'my_custom_site_finder'
+      #     services.site_finder = MyCustomSiteFinder.new
+      #   }
+      #
+      # end
+      #
+      # default: nil
+      #
+      attr_accessor :services_hook
+
     end
 
   end

data/lib/locomotive/steam/core_ext.rb

@@ -2,4 +2,5 @@ require_relative 'core_ext/hash'
 require_relative 'core_ext/string'
 require_relative 'core_ext/array'
 require_relative 'core_ext/boolean/true'
-require_relative 'core_ext/boolean/false'
+require_relative 'core_ext/boolean/false'
+require_relative 'core_ext/kernel'

data/lib/locomotive/steam/core_ext/hash.rb

@@ -1,27 +1,39 @@
-class Hash
+# Big thanks to Tim Ruffles (https://github.com/timruffles)
+# https://gist.github.com/timruffles/2780508
+module HashConverter
+  class << self
 
-  def underscore_keys
-    new_hash = {}
+    def to_underscore(hash)
+      convert(hash, :underscore)
+    end
 
-    self.each_pair do |key, value|
-      if value.respond_to?(:collect!) # Array
-        value.collect do |item|
-          if item.respond_to?(:each_pair) # Hash item within
-            item.underscore_keys
-          else
-            item
-          end
-        end
-      elsif value.respond_to?(:each_pair) # Hash
-        value = value.underscore_keys
-      end
+    def to_string(hash)
+      convert(hash, :to_s)
+    end
 
-      new_key = key.is_a?(String) ? key.underscore : key # only String keys
+    def to_sym(hash)
+      convert(hash, :to_sym)
+    end
 
-      new_hash[new_key] = value
+    # FIXME: not sure it will be ever needed
+    # def to_camel_case hash
+    #   convert hash, :camelize, :lower
+    # end
+
+    def convert(obj, *method)
+      case obj
+      when Hash
+        obj.inject({}) do |h, (k,v)|
+          v = convert(v, *method)
+          h[k.send(*method)] = v
+          h
+        end
+      when Array
+        obj.map { |m| convert(m, *method) }
+      else
+        obj
+      end
     end
 
-    self.replace(new_hash)
   end
-
 end

data/lib/locomotive/steam/core_ext/kernel.rb

@@ -0,0 +1,14 @@
+module Kernel
+
+  def require_relative_all(paths, sub = nil)
+    main_path = File.dirname(caller.first.sub(/:\d+$/, ''))
+    main_path = File.join(main_path, sub) if sub
+
+    [*paths].each do |path|
+      Dir[File.join(main_path, path, '*.rb')].each { |file| require file }
+    end
+  end
+
+end
+
+

data/lib/locomotive/steam/core_ext/string.rb

@@ -1,8 +1,37 @@
-class String
-  def to_bool
-    return true if self == true || self =~ (/(true|t|yes|y|1)$/i)
-    return false if self == false || self.blank? || self =~ (/(false|f|no|n|0)$/i)
-    
-    raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+unless String.public_instance_methods.include?(:to_bool)
+  class String
+
+    def to_bool
+      return true if self == true || self =~ (/(true|t|yes|y|1)$/i)
+      return false if self == false || self.blank? || self =~ (/(false|f|no|n|0)$/i)
+
+      raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+    end
+
+  end
+end
+
+unless String.public_instance_methods.include?(:permalink)
+  require 'stringex'
+
+  class String
+
+    def permalink(underscore = false)
+      # if the slug includes one "_" at least, we consider that the "_" is used instead of "-".
+      _permalink = if !self.index('_').nil?
+        self.to_url(replace_whitespace_with: '_')
+      else
+        self.to_url
+      end
+
+      underscore ? _permalink.underscore : _permalink
+    end
+
+    def permalink!(underscore = false)
+      replace(self.permalink(underscore))
+    end
+
+    alias :parameterize! :permalink!
+
   end
 end

data/lib/locomotive/steam/decorators/i18n_decorator.rb

@@ -0,0 +1,99 @@
+module Locomotive
+  module Steam
+    module Decorators
+
+      class I18nDecorator < SimpleDelegator
+
+        attr_accessor :__localized_attributes__
+        attr_accessor :__frozen_locale__
+        attr_reader   :__locale__
+        attr_reader   :__default_locale__
+
+        def initialize(object, locale = nil, default_locale = nil)
+          # ::Object.send(:puts, "Decorating #{object.class.name} with #{self.class.name}")
+
+          self.__localized_attributes__ = object.localized_attributes
+          self.__frozen_locale__        = false
+          self.__locale__               = locale
+          self.__default_locale__       = default_locale
+
+          super(object)
+        end
+
+        class << self
+
+          def decorate(object_or_list, locale = nil, default_locale = nil)
+            decorated = [[object_or_list]].flatten.map do |object|
+              new(object, locale, default_locale)
+            end
+
+            object_or_list.respond_to?(:localized_attributes) ? decorated.first : decorated
+          end
+
+        end
+
+        def __locale__=(locale)
+          unless self.__frozen_locale__
+            @__locale__ = locale.try(:to_sym)
+          end
+        end
+
+        def __default_locale__=(locale)
+          @__default_locale__ = locale.try(:to_sym)
+        end
+
+        def __with_locale__(locale, &block)
+          old_locale, self.__locale__  = __locale__, locale.to_sym
+          self.__freeze_locale__
+          yield.tap do
+            self.__unfreeze_locale__
+            self.__locale__ = old_locale
+          end
+        end
+
+        def __freeze_locale__
+          @__frozen_locale__ = true
+        end
+
+        def __unfreeze_locale__
+          @__frozen_locale__ = false
+        end
+
+        def __is_localized_attribute__(name)
+          __localized_attributes__.include?(name.to_sym)
+        end
+
+        def __get_localized_value__(name)
+          field = __getobj__.public_send(name.to_sym)
+          field[__locale__] || field[__default_locale__]
+        end
+
+        def __set_localized_value__(name, value)
+          field = __getobj__.public_send(name.to_sym)
+          field[__locale__] = value
+        end
+
+        def method_missing(name, *args, &block)
+          if __is_localized_attribute__(name)
+            __get_localized_value__(name)
+          elsif name.to_s.end_with?('=') && __is_localized_attribute__(name.to_s.chop)
+            __set_localized_value__(name.to_s.chop, args.first)
+          else
+            # Note: we want to hit the method_missing of the target object
+            __getobj__.send(name, *args, &block)
+          end
+        end
+
+        #:nocov:
+        def inspect
+          "[Decorated #{__getobj__.class.name}][I18n] attributes exist? " +
+          __getobj__.respond_to?(:attributes).inspect +
+          ', localized attributes: ' + @__localized_attributes__.inspect +
+          ', locale: ' + @__locale__.inspect
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/decorators/template_decorator.rb

@@ -0,0 +1,37 @@
+require_relative 'i18n_decorator'
+
+module Locomotive
+  module Steam
+    module Decorators
+
+      class TemplateDecorator < I18nDecorator
+
+        def liquid_source
+          if respond_to?(:template_path) && template_path
+            source_from_template_file
+          else
+            self.source
+          end
+        end
+
+        private
+
+        def source_from_template_file
+          source = File.open(template_path).read.force_encoding('utf-8')
+
+          if match = source.match(FRONTMATTER_REGEXP)
+            source = match[:template]
+          end
+
+          if template_path.ends_with?('.haml')
+            Haml::Engine.new(source).render
+          else
+            source
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/entities/content_entry.rb

@@ -0,0 +1,151 @@
+require 'chronic'
+
+module Locomotive::Steam
+
+  class ContentEntry
+
+    include Locomotive::Steam::Models::Entity
+
+    attr_accessor :content_type
+
+    def initialize(attributes = {})
+      super({
+        _visible:     true,
+        _position:    0,
+        created_at:   Time.zone.now,
+        updated_at:   Time.zone.now
+      }.merge(attributes))
+    end
+
+    def _visible?; !!self[:_visible]; end
+    alias :visible? :_visible?
+
+    def _slug; self[:_slug]; end
+    alias :_permalink :_slug
+
+    def method_missing(name, *args, &block)
+      if is_dynamic_attribute?(name)
+        cast_value(name)
+      elsif attributes.include?(name)
+        self[name]
+      else
+        super
+      end
+    end
+
+    def valid?
+      errors.clear
+      content_type.fields.required.each do |field|
+        errors.add_on_blank(field.name.to_sym)
+      end
+      errors.empty?
+    end
+
+    def content_type
+      @content_type || attributes[:content_type]
+    end
+
+    def content_type_id
+      @content_type.try(&:_id) || attributes[:content_type_id]
+    end
+
+    def content_type_slug
+      content_type.slug
+    end
+
+    def _class_name
+      "Locomotive::ContentEntry#{content_type_id}"
+    end
+
+    def _label
+      self[content_type.label_field_name]
+    end
+
+    def to_liquid
+      Locomotive::Steam::Liquid::Drops::ContentEntry.new(self)
+    end
+
+    private
+
+    def is_dynamic_attribute?(name)
+      content_type.fields_by_name.has_key?(name)
+    end
+
+    def cast_value(name)
+      field = content_type.fields_by_name[name]
+
+      begin
+        _cast_value(field)
+      rescue Exception => e
+        Locomotive::Common::Logger.info "[#{content_type.slug}][#{_label}] Unable to cast the \"#{name}\" field, reason: #{e.message}".yellow
+        nil
+      end
+    end
+
+    def _cast_value(field)
+      if private_methods.include?(:"_cast_#{field.type}")
+        send(:"_cast_#{field.type}", field)
+      else
+        attributes[field.name]
+      end
+    end
+
+    def _cast_integer(field)
+      _cast_convertor(field.name, &:to_i)
+    end
+
+    def _cast_float(field)
+      _cast_convertor(field.name, &:to_f)
+    end
+
+    def _cast_file(field)
+      _cast_convertor(field.name) do |value|
+        FileField.new(value, base_url, self.updated_at)
+      end
+    end
+
+    def _cast_date(field)
+      _cast_time(field, :to_date)
+    end
+
+    def _cast_date_time(field)
+      _cast_time(field, :to_date)
+    end
+
+    def _cast_time(field, end_method)
+      _cast_convertor(field.name) do |value|
+        value.is_a?(String) ? Chronic.parse(value).send(end_method) : value
+      end
+    end
+
+    def _cast_select(field)
+      _cast_convertor(:"#{field.name}_id") do |value|
+        field.select_options.find(value).try(:name)
+      end
+    end
+
+    def _cast_convertor(name, &block)
+      if (value = attributes[name]).respond_to?(:translations)
+        value.each { |l, _value| value[l] = yield(_value) }
+        value
+      else
+        yield(value)
+      end
+    end
+
+    # Represent a file
+    class FileField < Struct.new(:filename, :base, :updated_at)
+
+      def url
+        "#{base}/#{filename}"
+      end
+
+      def to_liquid
+        Locomotive::Steam::Liquid::Drops::UploadedFile.new(self)
+      end
+
+    end
+
+  end
+
+end