tribeca_cms 0.1.1

data/lib/locomotive/rails.rb

@@ -0,0 +1 @@
+require 'locomotive/rails/action_view'

data/lib/locomotive/rails/action_view.rb

@@ -0,0 +1,9 @@
+# http://jfire.io/blog/2012/04/30/how-to-securely-bootstrap-json-in-a-rails-view/
+class ActionView::Base
+  def json_escape(s)
+    result = s.to_s.gsub('/', '\/')
+    s.html_safe? ? result.html_safe : result
+  end
+
+  alias j json_escape
+end

data/lib/locomotive/regexps.rb

@@ -0,0 +1,11 @@
+module Locomotive
+  module Regexps
+
+    SUBDOMAIN           = /^[a-z][a-z0-9_-]*[a-z0-9]{1}$/
+
+    DOMAIN              = /^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix
+
+    URL                 = /((http|https|ftp):\/)?\/\S*/
+
+  end
+end

data/lib/locomotive/render.rb

@@ -0,0 +1,177 @@
+module Locomotive
+  module Render
+
+    extend ActiveSupport::Concern
+
+    protected
+
+    # Render a Locomotive page from the request fullpath and the current site.
+    # If the page corresponds to a redirect, then a 301 redirection is made.
+    #
+    def render_locomotive_page
+      if request.fullpath =~ /^\/#{Locomotive.mounted_on}\//
+        render :template => '/locomotive/errors/404', :layout => '/locomotive/layouts/not_logged_in', :status => :not_found
+      else
+        @page = locomotive_page
+
+        if @page.present? && @page.redirect?
+          self.redirect_to_locomotive_page and return
+        end
+
+        render_no_page_error and return if @page.nil?
+
+        output = @page.render(locomotive_context)
+
+        self.prepare_and_set_response(output)
+      end
+    end
+
+    # Redirect to the url given by the redirect_url field of the
+    # Locomotive page. If we are in the editing mode, the "_edit" prefix
+    # will be added as well.
+    #
+    def redirect_to_locomotive_page
+      redirect_url = @page.redirect_url
+
+      redirect_url = "#{redirect_url}/_edit" if self.editing_page?
+
+      redirect_to(redirect_url, :status => @page.redirect_type)
+    end
+
+    # Render the page which tells that no page exists.
+    # This case should not happen since all the sites contains
+    # the "Page Not Found" page.
+    #
+    def render_no_page_error
+      render :template => '/locomotive/errors/no_page', :layout => false
+    end
+
+    # Prepare and set the response object for the Locomotive page retrieved
+    # from the path. The caching (with Varnish for instance) if defined is done here.
+    # It is also here that the content type of the request is set (html or json).
+    # Behind the scene, it just calls simply the Rails render method.
+    #
+    # @param [ String ] The rendered Locomotive page
+    #
+    def prepare_and_set_response(output)
+      flash.discard
+
+      response.headers['Content-Type']  = "#{@page.response_type}; charset=utf-8"
+      response.headers['Editable']      = 'true' unless self.editing_page? || current_locomotive_account.nil?
+
+      if @page.with_cache?
+        fresh_when :etag => @page, :last_modified => @page.updated_at.utc, :public => true
+
+        if @page.cache_strategy != 'simple' # varnish
+          response.headers['Editable']      = ''
+          response.cache_control[:max_age]  = @page.cache_strategy
+        end
+      end
+
+      render :text => output, :layout => false, :status => page_status unless performed?
+    end
+
+    # Tell if the current Locomotive page is being edited.
+    #
+    # @return [ Boolean ] True if being edited.
+    #
+    def editing_page?
+      !!@editing
+    end
+
+    # Get the symbol matching the status of the current Locomotive page.
+    # It can be either :ok or :not_found (404)
+    #
+    # @return [ Symbol ] :ok if the page is not the "Page not found" one.
+    #
+    def page_status
+      @page.not_found? ? :not_found : :ok
+    end
+
+    # Get the Locomotive page matching the request and scoped by the current Locomotive site
+    #
+    # @return [ Object ] The Locomotive::Page
+    #
+    def locomotive_page
+      current_site.fetch_page self.locomotive_page_path, current_locomotive_account.present?
+    end
+
+    # Build the path that can be understood by Locomotive in order to retrieve
+    # the matching Locomotive page (see the locomotive_page method)
+    #
+    # @return [ String ] The path to the Locomotive page
+    #
+    def locomotive_page_path
+      path = (params[:path] || params[:page_path] || request.fullpath).clone # TODO: params[:path] is more consistent
+      path = path.split('?').first # take everything before the query string or the lookup fails
+      path.gsub!(/\.[a-zA-Z][a-zA-Z0-9]{2,}$/, '') # remove the page extension
+      path.gsub!(/^\//, '') # remove the leading slash
+
+      path = 'index' if path.blank? || path == '_edit'
+
+      path
+    end
+
+    # Build the Liquid context used to render the Locomotive page. It
+    # stores both assigns and registers.
+    #
+    # @return [ Object ] A Liquid::Context object.
+    #
+    def locomotive_context
+      assigns = self.locomotive_default_assigns
+
+      assigns.merge!(Locomotive.config.context_assign_extensions)
+
+      assigns.merge!(flash.to_hash.stringify_keys) # data from public submissions
+
+      if defined?(@page) && @page.templatized? # add instance from content type
+        content_entry = @page.content_entry.to_liquid
+        ['content_entry', 'entry', @page.target_entry_name].each do |key|
+          assigns[key] = content_entry
+        end
+      end
+
+      # Tip: switch from false to true to enable the re-thrown exception flag
+      ::Liquid::Context.new({}, assigns, self.locomotive_default_registers, false)
+    end
+
+    # Return the default Liquid assigns used inside the Locomotive Liquid context
+    #
+    # @return [ Hash ] The default liquid assigns object
+    #
+    def locomotive_default_assigns
+      {
+        'site'              => current_site.to_liquid,
+        'page'              => @page,
+        'models'            => Locomotive::Liquid::Drops::ContentTypes.new,
+        'contents'          => Locomotive::Liquid::Drops::ContentTypes.new, # DEPRECATED
+        'current_page'      => self.params[:page],
+        'params'            => self.params,
+        'path'              => request.path,
+        'fullpath'          => request.fullpath,
+        'url'               => request.url,
+        'now'               => Time.now.utc,
+        'today'             => Date.today,
+        'locale'            => I18n.locale.to_s,
+        'default_locale'    => current_site.default_locale.to_s,
+        'locales'           => current_site.locales,
+        'current_user'      => Locomotive::Liquid::Drops::CurrentUser.new(current_locomotive_account)
+      }
+    end
+
+    # Return the default Liquid registers used inside the Locomotive Liquid context
+    #
+    # @return [ Hash ] The default liquid registers object
+    #
+    def locomotive_default_registers
+      {
+        :controller     => self,
+        :site           => current_site,
+        :page           => @page,
+        :inline_editor  => self.editing_page?,
+        :current_locomotive_account => current_locomotive_account
+      }
+    end
+
+  end
+end

data/lib/locomotive/routing.rb

@@ -0,0 +1,2 @@
+require 'locomotive/routing/default_constraint'
+require 'locomotive/routing/site_dispatcher'

data/lib/locomotive/routing/default_constraint.rb

@@ -0,0 +1,42 @@
+module Locomotive
+  module Routing
+    class DefaultConstraint
+
+      def self.matches?(request)
+        if Locomotive.config.multi_sites?
+          domain, subdomain = domain_and_subdomain(request)
+          subdomain = 'www' if subdomain.blank?
+
+          domain == Locomotive.config.domain && Locomotive.config.reserved_subdomains.include?(subdomain)
+        else
+          false
+        end
+      end
+
+      # see actionpack/lib/action_dispatch/http/url.rb for more information
+      def self.domain_and_subdomain(request)
+        [extract_domain(request), extract_subdomain(request)]
+      end
+
+      def self.extract_domain(request, tld_length = 1)
+        return nil unless named_host?(request.host)
+        request.host.split('.').last(1 + tld_length).join('.')
+      end
+
+      def self.extract_subdomain(request, tld_length = 1)
+        subdomains(request, tld_length).join('.')
+      end
+
+      def self.named_host?(host)
+        !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+      end
+
+      def self.subdomains(request, tld_length = 1)
+        return [] unless named_host?(request.host)
+        parts = request.host.split('.')
+        parts[0..-(tld_length+2)]
+      end
+
+    end
+  end
+end

data/lib/locomotive/routing/site_dispatcher.rb

@@ -0,0 +1,54 @@
+module Locomotive
+  module Routing
+    module SiteDispatcher
+
+      extend ActiveSupport::Concern
+
+      included do
+        if self.respond_to?(:before_filter)
+          before_filter :fetch_site
+
+          helper_method :current_site
+        end
+      end
+
+      protected
+
+      def fetch_site
+        Locomotive.log "[fetch site] host = #{request.host} / #{request.env['HTTP_HOST']}"
+
+        if Locomotive.config.multi_sites?
+          @current_site ||= Locomotive::Site.match_domain(request.host).first
+        else
+          @current_site ||= Locomotive::Site.first
+        end
+      end
+
+      def current_site
+        @current_site || fetch_site
+      end
+
+      def require_site
+        return true if current_site
+
+        redirect_to installation_url and return false if Locomotive::Account.count == 0 || Locomotive::Site.count == 0
+
+        render_no_site_error and return false
+      end
+
+      def render_no_site_error
+        render :template => '/locomotive/errors/no_site', :layout => false, :status => :not_found
+      end
+
+      def validate_site_membership
+        return true if current_site.present? && current_site.accounts.include?(current_locomotive_account)
+
+        sign_out(current_locomotive_account)
+        flash[:alert] = I18n.t(:no_membership, :scope => [:devise, :failure, :locomotive_account])
+        redirect_to new_locomotive_account_session_url and return false
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/session_store.rb

@@ -0,0 +1,64 @@
+module ActionDispatch
+  module Session
+    class MongoidStore < AbstractStore
+
+      class Session
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        field :data, :type => String, :default => [Marshal.dump({})].pack("m*")
+        index :updated_at
+      end
+
+      # The class used for session storage.
+      cattr_accessor :session_class
+      self.session_class = Session
+
+      SESSION_RECORD_KEY = 'rack.session.record'.freeze
+
+      private
+        def generate_sid
+          BSON::ObjectId.new
+        end
+
+        def get_session(env, sid)
+          sid ||= generate_sid
+          session = find_session(sid)
+          env[SESSION_RECORD_KEY] = session
+          [sid, unpack(session.data)]
+        end
+
+        def set_session(env, sid, session_data, options)
+          record = env[SESSION_RECORD_KEY] ||= find_session(sid)
+          record.data = pack(session_data)
+          # Rack spec dictates that set_session should return true or false
+          # depending on whether or not the session was saved or not.
+          # However, ActionPack seems to want a session id instead.
+          record.save ? sid : false
+        end
+
+        def find_session(id)
+          id = BSON::ObjectId.from_string(id.to_s)
+          @@session_class.first(:conditions => { :_id => id }) ||
+            @@session_class.new(:id => id)
+        end
+
+        def pack(data)
+          [Marshal.dump(data)].pack("m*")
+        end
+
+        def unpack(packed)
+          return nil unless packed
+          Marshal.load(packed.unpack("m*").first)
+        end
+
+        def destroy(env)
+          session = @@session_class.first(:conditions => { :_id => env[SESSION_RECORD_KEY].id })
+          session.try(:destroy)
+
+          env[SESSION_RECORD_KEY] = nil
+        end
+
+    end
+  end
+end

data/lib/locomotive/version.rb

@@ -0,0 +1,3 @@
+module Tribeca #:nodoc
+  VERSION = '0.1.1'
+end

data/lib/locomotive_cms.rb

@@ -0,0 +1 @@
+require 'locomotive/engine'

data/lib/tasks/cucumber.rake

@@ -0,0 +1,66 @@
+# IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a
+# newer version of cucumber-rails. Consider adding your own code to a new file
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# files.
+
+require 'rails'
+
+unless ARGV.any? {|a| a =~ /^gems/} # Don't load anything when running the gems:* tasks
+
+vendored_cucumber_bin = Dir["#{Rails.root}/vendor/{gems,plugins}/cucumber*/bin/cucumber"].first
+$LOAD_PATH.unshift(File.dirname(vendored_cucumber_bin) + '/../lib') unless vendored_cucumber_bin.nil?
+
+begin
+  require 'cucumber/rake/task'
+
+  namespace :cucumber do
+    Cucumber::Rake::Task.new({:ok => 'db:test:prepare'}, 'Run features that should pass') do |t|
+      t.binary = vendored_cucumber_bin # If nil, the gem's binary is used.
+      t.fork = true # You may get faster startup if you set this to false
+      t.profile = 'default'
+    end
+
+    Cucumber::Rake::Task.new({:wip => 'db:test:prepare'}, 'Run features that are being worked on') do |t|
+      t.binary = vendored_cucumber_bin
+      t.fork = true # You may get faster startup if you set this to false
+      t.profile = 'wip'
+    end
+
+    Cucumber::Rake::Task.new({:rerun => 'db:test:prepare'}, 'Record failing features and run only them if any exist') do |t|
+      t.binary = vendored_cucumber_bin
+      t.fork = true # You may get faster startup if you set this to false
+      t.profile = 'rerun'
+    end
+
+    desc 'Run all features'
+    task :all => [:ok, :wip]
+
+    task :statsetup do
+      require 'rails/code_statistics'
+      ::STATS_DIRECTORIES << %w(Cucumber\ features features) if File.exist?('features')
+      ::CodeStatistics::TEST_TYPES << "Cucumber features" if File.exist?('features')
+    end
+  end
+  desc 'Alias for cucumber:ok'
+  task :cucumber => 'cucumber:ok'
+
+  task :default => :cucumber
+
+  task :features => :cucumber do
+    STDERR.puts "*** The 'features' task is deprecated. See rake -T cucumber ***"
+  end
+
+  # In case we don't have ActiveRecord, append a no-op task that we can depend upon.
+  task 'db:test:prepare' do
+  end
+
+  task :stats => 'cucumber:statsetup'
+rescue LoadError
+  desc 'cucumber rake task not available (cucumber not installed)'
+  task :cucumber do
+    abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
+  end
+end
+
+end

data/lib/tasks/locomotive.rake

@@ -0,0 +1,220 @@
+# encoding: utf-8
+
+namespace :locomotive do
+
+  # desc 'Fetch the Locomotive default site template for the installation'
+  # task :fetch_default_site_template => :environment do
+  #   puts "Downloading default site template from '#{Locomotive::Import.DEFAULT_SITE_TEMPLATE}'"
+  #   `curl -L -s -o #{Rails.root}/tmp/default_site_template.zip #{Locomotive::Import.DEFAULT_SITE_TEMPLATE}`
+  #   puts '...done'
+  # end
+
+  desc 'Rebuild the serialized template of all the site pages'
+  task :rebuild_serialized_page_templates => :environment do
+    Locomotive::Site.all.each do |site|
+      pages = site.pages.to_a
+      while !pages.empty? do
+        page = pages.pop
+        begin
+          page.send :_parse_and_serialize_template
+          page.save
+          puts "[#{site.name}] processing...#{page.title}"
+        rescue TypeError => e
+          pages.insert(0, page)
+        end
+      end
+    end
+  end
+
+  desc 'Add a new admin user (NOTE: currently only supports adding user to first site)'
+  task :add_admin => :environment do
+    name = ask('Display name: ') { |q| q.echo = true }
+    email = ask('Email address: ') { |q| q.echo = true }
+    password = ask('Password: ') { |q| q.echo = '*' }
+    password_confirm = ask('Confirm password: ') { |q| q.echo = '*' }
+
+    account = Locomotive::Account.create :email => email, :password => password, :password_confirmation => password_confirm, :name => name
+
+    # TODO: this should be changed to work for multi-sites (see desc)
+    site = Locomotive::Site.first
+    site.memberships.build :account => account, :role => 'admin'
+    site.save!
+  end
+
+  namespace :upgrade do
+
+    desc 'Fix issue with the editable file and i18n in the 2.0.0.rc'
+    task :fix_editable_files => :environment do
+      Locomotive::Page.all.each do |page|
+        page.editable_elements.each_with_index do |el, index|
+          next if el._type != 'Locomotive::EditableFile' || el.attributes['source'].is_a?(Hash)
+
+          value = el.attributes['source']
+
+          page.collection.update({ '_id' => page._id }, { '$unset' => { "editable_elements.#{index}.content" => 1 }, '$set' => { "editable_elements.#{index}.source" => { 'en' => value } } })
+        end
+      end
+    end
+
+    desc 'Make blocks and editable_elements consistent'
+    task :make_editable_elements_consistent => :environment do
+      Locomotive::Site.all.each do |site|
+      # site = Locomotive::Site.find('50acd6f087f64350c9000010')
+        site.locales.each do |locale|
+          ::Mongoid::Fields::I18n.locale = locale
+          # page = Locomotive::Page.find('50acd6f087f64350c9000012') # home page
+          # page = Locomotive::Page.find('50ae35ff87f643f3df0000bc') # company
+          site.pages.each do |page|
+            puts "[#{site.name}] #{page.fullpath} (#{locale})"
+
+            found_elements = []
+
+            page.template.walk do |node, memo|
+              case node
+              when Locomotive::Liquid::Tags::InheritedBlock
+                puts "found block ! #{node.name} --- #{memo[:parent_block_name]}"
+
+                # set the new name based on a potential parent block
+                name = node.name.gsub(/[\"\']/o, '')
+
+                if memo[:parent_block_name] && !name.starts_with?(memo[:parent_block_name])
+                  name = "#{memo[:parent_block_name]}/#{name}"
+                end
+
+                puts "new_name = #{name}"
+
+                # retrieve all the editable elements of this block and set them the new name
+                page.find_editable_elements(node.name).each do |el|
+                  # puts "**> hurray found the element #{el.block} _ #{el.slug}"
+                  el.block = name
+                  puts "**> hurray found the element #{el.block} _ #{el.slug} | #{page.find_editable_element(name, el.slug).present?.inspect}"
+                end
+
+                # assign the new name to the block
+                node.instance_variable_set :@name, name
+
+                # record the new parent block name for children
+                memo[:parent_block_name] = name
+
+              when Locomotive::Liquid::Tags::Editable::ShortText,
+                  Locomotive::Liquid::Tags::Editable::LongText,
+                  Locomotive::Liquid::Tags::Editable::Control,
+                  Locomotive::Liquid::Tags::Editable::File
+
+                puts "\tfound editable_element ! #{node.slug} --- #{memo[:parent_block_name]}"
+
+                slug = node.slug.gsub(/[\"\']/o, '')
+
+                # assign the new slug to the editable element
+                puts "\t\t...looking for #{node.slug} inside #{memo[:parent_block_name]}"
+
+                options = node.instance_variable_get :@options
+                block   = options[:block].blank? ? memo[:parent_block_name] : options[:block]
+
+                if el = page.find_editable_element(block, node.slug)
+                  puts "\t\t--> yep found the element"
+
+                  el.slug   = slug
+                  el.block  = memo[:parent_block_name] # just to make sure
+
+                  node.instance_variable_set :@slug, slug
+
+                  options.delete(:block)
+                  node.instance_variable_set :@block, nil  # just to make sure
+
+                  found_elements << el._id
+                else
+                  puts "\t\t[WARNING] el not found (#{block} - #{slug})"
+                end
+
+              end
+
+              memo
+            end # page walk
+
+            puts "found elements = #{found_elements.join(', ')} / #{page.editable_elements.count}"
+
+            # "hide" useless editable elements
+            page.editable_elements.each do |el|
+              next if found_elements.include?(el._id)
+              el.disabled = true
+            end
+
+            # serialize
+            page.send(:_serialize_template)
+
+            # puts page.template.inspect
+
+            # save ?
+            page.instance_variable_set :@template_changed, false
+            page.save
+
+            # TODO:
+            #  x ", block: 'Asset #1'"" ???? les re-assigner a "main" d'une facon ou d'une autre
+            #   => en fait, ce sont des editable elements qui n'ont pas vrais blocks
+            #  x hide useless editable elements
+            #  x re-serializer le template
+            #  ? skipper la methode parse (quoique pas besoin car template non modifie)
+            #  x snippets
+            #  x sauvegarder (sans callbacks ??)
+          end # loop: pages
+        end # loop: locales
+      end # loop: sites
+    end # task: make_editable_elements_consistent
+
+  end # namespace: upgrade
+
+  desc 'Generate the documentation about the REST API'
+  task :generate_api_doc => :environment do
+
+    require 'locomotive/misc/api_documentation'
+
+    output = Locomotive::Misc::ApiDocumentation.generate
+
+    path = File.join(Dir.pwd, 'public')
+
+    File.open(File.join(path, 'locomotive_api.html'), 'w') do |file|
+      file.write(output)
+    end
+  end
+
+  namespace :maintenance do
+
+    desc 'Unset the translation of the editable elements for a LOCALE'
+    task :unset_editable_elements_translation => :environment do
+      if ENV['LOCALE'].blank?
+        puts 'LOCALE is required'
+      else
+        locale  = ENV['LOCALE'].downcase
+        pages   = ENV['SITE_ID'].blank? ? Locomotive::Page.all : Locomotive::Site.find(ENV['SITE_ID']).pages
+
+        pages.each do |page|
+          modifications = {}
+
+          page.editable_elements.each_with_index do |el, index|
+            next if ['Locomotive::EditableFile', 'Locomotive::EditableControl'].include?(el._type)
+
+            if el.locales
+              modifications["editable_elements.#{index}.locales"] = el.locales - [locale]
+            end
+
+            if el.content_translations
+              modifications["editable_elements.#{index}.content"] = el.content_translations.delete_if { |_locale, _| _locale == locale }
+            end
+
+            if el.default_content_translations
+              modifications["editable_elements.#{index}.default_content"] = el.default_content_translations.delete_if { |_locale, _| _locale == locale }
+            end
+          end
+
+          # persist the modifications
+          unless modifications.empty?
+            page.collection.update({ '_id' => page._id }, { '$set' => modifications })
+          end
+        end
+      end
+    end
+
+  end
+
+end