tribeca_cms 0.1.1

data/lib/locomotive/action_controller/section_helpers.rb

@@ -0,0 +1,29 @@
+module Locomotive
+  module ActionController
+    module SectionHelpers
+
+      extend ActiveSupport::Concern
+
+      def sections(key = nil)
+        if !key.nil? && key.to_sym == :sub
+          @locomotive_sections[:sub] || self.controller_name.dasherize
+        else
+          @locomotive_sections[:main]
+        end
+      end
+
+      module ClassMethods
+
+        def sections(main, sub = nil)
+          before_filter do |c|
+            sub = sub.call(c) if sub.respond_to?(:call)
+            sections = { :main => main, :sub => sub }
+            c.instance_variable_set(:@locomotive_sections, sections)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/action_controller/url_helpers.rb

@@ -0,0 +1,38 @@
+module Locomotive
+  module ActionController
+    module UrlHelpers
+
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :current_site_public_url, :switch_to_site_url, :public_page_url
+      end
+
+      def current_site_public_url
+        request.protocol + request.host_with_port
+      end
+
+      def switch_to_site_url(site, options = {})
+        options = { :fullpath => true, :protocol => true }.merge(options)
+
+        url = "#{site.subdomain}.#{Locomotive.config.domain}"
+        url += ":#{request.port}" if request.port != 80
+
+        url = File.join(url, request.fullpath) if options[:fullpath]
+        url = "http://#{url}" if options[:protocol]
+        url
+      end
+
+      def public_page_url(page, options = {})
+        # Rails.logger.debug "[public_page_url] =====> #{page.attributes.inspect} / #{page.fullpath.inspect}\n\n"
+        if content = options.delete(:content)
+          File.join(current_site_public_url, page.fullpath.gsub('content_type_template', ''), content._slug)
+        else
+          File.join(current_site_public_url, page.fullpath)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/carrierwave.rb

@@ -0,0 +1,10 @@
+require 'carrierwave/processing/mime_types'
+
+require 'locomotive/carrierwave/base'
+require 'locomotive/carrierwave/asset'
+require 'locomotive/carrierwave/patches'
+
+# register missing mime types
+EXTENSIONS[:eot] = 'application/vnd.ms-fontobject'
+EXTENSIONS[:woff] = 'application/x-woff'
+EXTENSIONS[:otf] = 'application/octet-stream'

data/lib/locomotive/carrierwave/asset.rb

@@ -0,0 +1,72 @@
+module Locomotive
+  module CarrierWave
+    module Uploader
+      module Asset
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          include ::CarrierWave::MimeTypes
+
+          process :set_content_type
+          process :set_content_type_of_model
+          process :set_size
+          process :set_width_and_height
+
+        end
+
+        module ClassMethods
+
+          def content_types
+            {
+              :image      => ['image/jpeg', 'image/pjpeg', 'image/gif', 'image/png', 'image/x-png', 'image/jpg', 'image/x-icon'],
+              :media      => [/^video/, 'application/x-shockwave-flash', 'application/x-flash-video', 'application/x-swf', /^audio/, 'application/ogg', 'application/x-mp3'],
+              :pdf        => ['application/pdf', 'application/x-pdf'],
+              :stylesheet => ['text/css'],
+              :javascript => ['text/javascript', 'text/js', 'application/x-javascript', 'application/javascript', 'text/x-component'],
+              :font       => ['application/x-font-ttf', 'application/vnd.ms-fontobject', 'image/svg+xml', 'application/x-woff']
+            }
+          end
+
+        end
+
+        def set_content_type_of_model(*args)
+          value         = :other
+          content_type  = file.content_type
+
+          if content_type.blank? || content_type == 'application/octet-stream'
+            content_type = File.mime_type?(original_filename)
+          end
+
+          self.class.content_types.each_pair do |type, rules|
+            rules.each do |rule|
+              case rule
+              when String then value = type if content_type == rule
+              when Regexp then value = type if (content_type =~ rule) == 0
+              end
+            end
+          end
+
+          model.content_type = value
+        end
+
+        def set_size(*args)
+          model.size = file.size
+        end
+
+        def set_width_and_height
+          if model.image?
+            magick = ::Magick::Image.read(current_path).first
+            model.width, model.height = magick.columns, magick.rows
+          end
+        end
+
+        def image?(file)
+          model.image?
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/carrierwave/base.rb

@@ -0,0 +1,15 @@
+module CarrierWave
+  module Uploader
+    class Base
+
+      def to_label
+        File.basename(self.to_s, File.extname(self.to_s))
+      end
+
+      def to_liquid
+        Locomotive::Liquid::Drops::Uploader.new(self)
+      end
+
+    end
+  end
+end

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,122 @@
+module Locomotive
+  class Configuration
+
+    @@defaults = {
+      :name                   => 'LocomotiveApp',
+      :domain                 => 'example.com',
+      :reserved_subdomains    => %w{www admin email blog webmail mail support help site sites},
+      # :forbidden_paths      => %w{layouts snippets stylesheets javascripts assets admin system api},
+      :reserved_slugs         => %w{stylesheets javascripts assets admin locomotive images api pages edit},
+      :locales                => %w{en de fr pl pt-BR it nl nb es ru et},
+      :site_locales           => %w{en de fr pl pt-BR it nl nb es ru et},
+      :cookie_key             => '_locomotive_session',
+      :enable_logs            => false,
+      :delayed_job            => false,
+      :default_locale         => :en,
+      :mailer_sender          => 'support@example.com',
+      :manage_subdomain       => false,
+      :manage_manage_domains  => false,
+      :ui                     => {
+        :latest_entries_nb    => 5,
+        :max_content_types    => 2
+      },
+      :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             => [:rememberable, :database_authenticatable, :token_authenticatable, :recoverable, :trackable, :validatable, :encryptable, { :encryptor => :sha1 }],
+      :context_assign_extensions  => { },
+      :models_for_templatization  => [],
+      :csrf_protection            => false
+    }
+
+    cattr_accessor :settings
+
+    def initialize
+      @@settings = self.class.get_from_hash(@@defaults)
+    end
+
+    def self.settings
+      @@settings
+    end
+
+    def multi_sites?
+      self.multi_sites != false
+    end
+
+    def manage_subdomain?
+      self.manage_subdomain == true
+    end
+
+    def manage_domains?
+      self.manage_domains == true
+    end
+
+    def manage_subdomain_n_domains?
+      self.manage_subdomain? && self.manage_domains?
+    end
+
+    def reserved_subdomains
+      if self.multi_sites?
+        if self.multi_sites.reserved_subdomains.blank?
+          @@defaults[:reserved_subdomains]
+        else
+          self.multi_sites.reserved_subdomains
+        end
+      else
+        []
+      end
+    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,64 @@
+# encoding: utf-8
+
+## String
+
+class String #:nodoc
+
+  def permalink
+    self.to_ascii.parameterize('-')
+  end
+
+  def permalink!
+    replace(self.permalink)
+  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,66 @@
+# Custom options for CustomFields
+CustomFields.options = {
+  :reserved_names => Mongoid.destructive_fields + %w(created_at updated_at)
+}
+
+module CustomFields
+
+  class Field
+
+    include Locomotive::Mongoid::Presenter
+
+    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
+
+    def self.presenter_class
+      Locomotive::ContentFieldPresenter
+    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}/content_#{model.class.model_name.demodulize.underscore}/#{model.id}/files"
+        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.
+        #
+        # @return [ String ] The url to the soon uploaded file
+        #
+        def guess_url
+          this = self.class.new(model, mounted_as)
+          this.retrieve_from_store!(model.read_uploader(mounted_as))
+          this.url.to_s
+        end
+
+        def cache_dir
+          "#{Rails.root}/tmp/uploads"
+        end
+
+      end
+
+    end
+
+  end
+end
+