locomotivecms 3.0.0.pre.alpha

data/lib/locomotive/carrierwave/patches.rb

@@ -0,0 +1,32 @@
+module CarrierWave
+
+  class SanitizedFile
+
+    # FIXME (Did) CarrierWave speaks mime type now
+    def content_type_with_file_mime_type
+      content_type_without_file_mime_type || File.mime_type?(original_filename)
+    end
+
+    alias_method_chain :content_type, :file_mime_type
+
+  end
+
+  module Uploader
+
+    class Base
+
+      def build_store_dir(*args)
+        default_dir = self.class.store_dir
+
+        if default_dir.blank? || default_dir == 'uploads'
+          File.join(args.map(&:to_s))
+        else
+          File.join([default_dir] + args.map(&:to_s))
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/locomotive/configuration.rb

@@ -0,0 +1,96 @@
+module Locomotive
+  class Configuration
+
+    @@default_locales = %w{en de fr pl pt pt-BR it nl nb es ru et ja zh-CN cs bg sk sr}
+
+    @@defaults = {
+      name:                         'Locomotive',
+      # forbidden_paths:            %w{layouts snippets stylesheets javascripts assets admin system api},
+      reserved_site_handles:        %w(sites my_account password sign_in sign_out),
+      reserved_slugs:               %w{stylesheets javascripts assets admin locomotive images api pages edit},
+      locales:                      @@default_locales,
+      site_locales:                 @@default_locales,
+      cookie_key:                   '_locomotive_session',
+      enable_logs:                  false,
+      enable_admin_ssl:             false,
+      delayed_job:                  false,
+      default_locale:               :en,
+      mailer_sender:                'support@example.com',
+      unsafe_token_authentication:  false,
+      ui:                     {
+        per_page:             10
+      },
+      rack_cache:             {
+        verbose:     true,
+        metastore:   URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/meta"), # URI encoded in case of spaces
+        entitystore: URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/body")
+      },
+      devise_modules:             [:registerable, :rememberable, :database_authenticatable, :recoverable, :trackable, :validatable, :encryptable, { encryptor: :sha1 }],
+      context_assign_extensions:  { },
+      models_for_templatization:  [],
+      csrf_protection:            false,
+      theme_assets_checksum:      false,
+      asset_host:                 nil
+    }
+
+    cattr_accessor :settings
+
+    def initialize
+      @@settings = self.class.get_from_hash(@@defaults)
+    end
+
+    def self.settings
+      @@settings
+    end
+
+    def method_missing(name, *args, &block)
+      self.settings.send(name, *args, &block)
+    end
+
+    protected
+
+    # converts a hash map into a ConfigurationHash
+    def self.get_from_hash(hash)
+      config = ConfigurationHash.new
+
+      hash.each_pair do |key, value|
+        config[key] = value.is_a?(Hash) ? self.get_from_hash(value) : value
+      end
+
+      config
+    end
+  end
+
+  # specialized hash for storing configuration settings
+  class ConfigurationHash < Hash
+    # ensure that default entries always produce
+    # instances of the ConfigurationHash class
+    def default(key=nil)
+      include?(key) ? self[key] : self[key] = self.class.new
+    end
+
+    # retrieves the specified key and yields it
+    # if a block is provided
+    def [](key, &block)
+      if block_given?
+        self.delete(key) unless super(key).respond_to?(:keys)
+        yield(super(key))
+      else
+        super(key)
+      end
+
+      # block_given? ? yield(super(key)) : super(key)
+    end
+
+    # provides member-based access to keys
+    # i.e. params.id === params[:id]
+    # note: all keys are converted to symbols
+    def method_missing(name, *args, &block)
+      if name.to_s.ends_with? '='
+        send :[]=, name.to_s.chomp('=').to_sym, *args
+      else
+        send(:[], name.to_sym, &block)
+      end
+    end
+  end
+end

data/lib/locomotive/core_ext.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+## Array
+
+class Array
+
+  def all
+    self
+  end
+end
+
+## String
+
+class String #:nodoc
+
+  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
+
+## Hash
+
+class Hash #:nodoc
+
+  def underscore_keys
+    new_hash = {}
+
+    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
+
+      new_key = key.is_a?(String) ? key.underscore : key # only String keys
+
+      new_hash[new_key] = value
+    end
+
+    self.replace(new_hash)
+  end
+
+end
+
+class Boolean #:nodoc
+  BOOLEAN_MAP = {
+    true => true, "true" => true, "TRUE" => true, "1" => true, 1 => true, 1.0 => true,
+    false => false, "false" => false, "FALSE" => false, "0" => false, 0 => false, 0.0 => false
+  }
+
+  def self.set(value)
+    value = BOOLEAN_MAP[value]
+    value.nil? ? nil : value
+  end
+
+  def self.get(value)
+    value
+  end
+end

data/lib/locomotive/custom_fields.rb

@@ -0,0 +1,70 @@
+# Custom options for CustomFields
+CustomFields.options = {
+  reserved_names: Mongoid.destructive_fields + %w(id _id send created_at updated_at)
+}
+
+module CustomFields
+
+  class Field
+
+    field :ui_enabled, type: Boolean, default: true
+
+    def class_name_to_content_type
+      self._parent.send :class_name_to_content_type, self.class_name
+    end
+
+    protected
+
+    def ensure_class_name_security
+      self._parent.send :ensure_class_name_security, self
+    end
+  end
+
+  module Types
+
+    module File
+
+      class FileUploader < ::CarrierWave::Uploader::Base
+
+        include ::CarrierWave::MimeTypes
+
+        process :set_content_type
+
+        # Set correct paths
+        def store_dir
+          "sites/#{model.site_id}/#{model._type.demodulize.underscore}/#{model.id}/files"
+        end
+
+        def image?
+          !(content_type =~ /image/).nil?
+        end
+
+        # In some situations, for instance, for the notification email when a content entry is created,
+        # we need to know the url of the file without breaking the upload process.
+        # Actually, the uploaded file will be written on the filesystem after the email is sent.
+        #
+        # @param [ String ] host Required to build the full url in the Filesystem is used (optional)
+        #
+        # @return [ String ] The url to the soon uploaded file
+        #
+        def guess_url(host = nil)
+          this = self.class.new(model, mounted_as)
+          this.retrieve_from_store!(model.read_uploader(mounted_as))
+
+          if this.url =~ /^http/ || host.blank?
+            this.url
+          else
+            URI.join("http://#{host}", this.url).to_s
+          end
+        end
+
+        def cache_dir
+          "#{Rails.root}/tmp/uploads"
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/dependencies.rb

@@ -0,0 +1,39 @@
+require 'bson'
+require 'moped'
+require 'mongoid'
+require 'mongoid/railtie'
+require 'mongoid/tree'
+require 'mongo_session_store'
+require 'devise'
+require 'devise/orm/mongoid'
+require 'devise-encryptable'
+require 'simple_token_authentication'
+require 'kaminari'
+require 'bootstrap-kaminari-views'
+require 'bootstrap-sass'
+require 'font-awesome-sass'
+require 'autoprefixer-rails'
+require 'haml'
+require 'simple_form'
+require 'responders'
+require 'carrierwave'
+require 'custom_fields'
+require 'mimetype_fu'
+require 'actionmailer_with_request'
+require 'httparty'
+require 'select2-rails'
+require 'dragonfly'
+require 'pundit'
+require 'sanitize'
+require 'stringex'
+require 'bazaar'
+require 'csv'
+
+require 'compass-rails'
+require 'codemirror/rails'
+require 'jquery/rails'
+require 'jquery-ui-rails'
+require 'backbone-on-rails'
+
+require 'grape'
+require 'grape-entity'

data/lib/locomotive/devise.rb

@@ -0,0 +1,22 @@
+# patches for devise here
+
+# http://blog.plataformatec.com.br/2013/11/e-mail-enumeration-in-devise-in-paranoid-mode/
+# Put this inside config/initializers/devise_paranoid_fix.rb
+require 'devise/strategies/database_authenticatable'
+
+Devise::Strategies::DatabaseAuthenticatable.class_eval do
+  def authenticate!
+    resource  = valid_password? && mapping.to.find_for_database_authentication(authentication_hash)
+    encrypted = false
+
+    return fail(:invalid) unless resource
+
+    if validate(resource){ encrypted = true; resource.valid_password?(password) }
+      resource.after_database_authentication
+      success!(resource)
+    end
+
+    mapping.to.new.password = password if !encrypted && Devise.paranoid
+    fail(:not_found_in_database) unless resource
+  end
+end

data/lib/locomotive/dragonfly.rb

@@ -0,0 +1,63 @@
+module Locomotive
+  module Dragonfly
+
+    def self.resize_url(source, resize_string)
+      if file = self.fetch_file(source)
+        file.thumb(resize_string).url
+      else
+        Locomotive.log :error, "Unable to resize on the fly: #{source.inspect}"
+        return
+      end
+    end
+
+    def self.thumbnail_pdf(source, resize_string)
+      if file = self.fetch_file(source)
+        file.thumb(resize_string, format: 'png', frame: 0).encode('png').url
+      else
+        Locomotive.log :error, "Unable to convert the pdf: #{source.inspect}"
+        return
+      end
+    end
+
+    def self.fetch_file(source)
+      file = nil
+
+      if source.is_a?(String) || source.is_a?(Hash) # simple string or theme asset
+        source = source['url'] if source.is_a?(Hash)
+
+        clean_source!(source)
+
+        if source =~ /^http/
+          file = self.app.fetch_url(source)
+        else
+          file = self.app.fetch_file(File.join('public', source))
+        end
+
+      elsif source.respond_to?(:url) # carrierwave uploader
+        if source.file.respond_to?(:url)
+          file = self.app.fetch_url(source.url) # amazon s3, cloud files, ...etc
+        else
+          file = self.app.fetch_file(source.path)
+        end
+
+      end
+
+      file
+    end
+
+    def self.app
+      ::Dragonfly.app(:engine)
+    end
+
+    protected
+
+    def self.clean_source!(source)
+      # remove the leading / trailing whitespaces
+      source.strip!
+
+      # remove the query part (usually, timestamp) if local file
+      source.sub!(/(\?.*)$/, '') unless source =~ /^http/
+    end
+
+  end
+end

data/lib/locomotive/engine.rb

@@ -0,0 +1,60 @@
+require 'locomotive/dependencies'
+require 'locomotive'
+
+$:.unshift File.dirname(__FILE__) # TODO: not sure about that, looks pretty useless
+
+module Locomotive
+  class Engine < Rails::Engine
+
+    isolate_namespace Locomotive
+
+    paths['mongodb/migrate'] = 'mongodb/migrate'
+
+    initializer 'steam' do |app|
+      require 'locomotive/steam_adaptor'
+    end
+
+    initializer 'locomotive.content_types' do |app|
+      # Load all the dynamic classes (custom fields)
+      begin
+        ContentType.all.collect { |content_type| content_type.klass_with_custom_fields(:entries) }
+      rescue Exception => e
+        # let assume it's because of the first install (meaning no config.yml file)
+        Locomotive.log :warn, "WARNING: unable to load the content types, #{e.message}"
+      end
+    end
+
+    initializer 'locomotive.action_controller' do |app|
+      ::ActionController::Base.wrap_parameters format: [:json]
+    end
+
+    initializer 'locomotive.devise' do |app|
+      ::DeviseController.respond_to :html, :json
+    end
+
+    initializer "locomotive.precompile.hook", group: :all do |app|
+      app.config.assets.precompile += %w(
+        locomotive/wysihtml5_reset.css
+        locomotive/wysihtml5_editor.css
+        locomotive.js
+        locomotive.css
+        locomotive/not_logged_in.js
+        locomotive/not_logged_in.css)
+
+      # Uncomment the lines below to view the names of assets as they are
+      # precompiled for the rails asset pipeline
+      # def compile_asset?(path)
+      #   puts "Compiling: #{path}"
+      #   true
+      # end
+
+      # app.config.assets.precompile = [ method(:compile_asset?).to_proc ]
+    end
+
+    initializer 'locomotive.middlewares' do |app|
+      app.middleware.insert_before(Rack::Runtime, '::Locomotive::Middlewares::Permalink', nil)
+      app.middleware.use '::Locomotive::Middlewares::Site'
+    end
+
+  end
+end