trusty-cms 3.1.8 → 3.1.9

data/vendor/extensions/multi-site-extension/lib/multi_site/page_extensions.rb

@@ -0,0 +1,81 @@
+# Unlike other scoped classes, there is no site association in the Page class. Instead, Site has a homepage association and Page has some retrieval methods that turn a page request into site information.
+
+module MultiSite::PageExtensions
+  def self.included(base)
+    base.class_eval {
+      include InstanceMethods
+      alias_method :url_without_sites, :url
+      alias_method :url, :url_with_sites
+      mattr_accessor :current_site
+      belongs_to :site
+      before_create :associate_with_site
+    }
+    base.extend ClassMethods
+    class << base
+
+      def find_by_path(path, live=true)
+        root = homepage
+        raise Page::MissingRootPageError unless root
+        path = root.path if clean_path(path) == "/"
+        result = root.find_by_path(path, live)
+
+        # If the result is a FileNotFoundPage and it
+        # doesn't match the current site, try to find one that does.
+        if result.is_a?(FileNotFoundPage) && result.site_id != homepage.site_id
+          get_site_specific_file_not_found(result)
+
+        # Otherwise, just go with it.
+        else
+          result
+        end
+      end
+
+      def current_site
+        @current_site ||= Site.default
+      end
+      def current_site=(site)
+        @current_site = site
+      end
+      def clean_path(path)
+        "/#{ path.to_s.strip }/".gsub(%r{//+}, '/')
+      end
+
+      # if the result is a FileNotFoundPage, try to find the one for this site.
+      # if you can't, return the initial result
+      def get_site_specific_file_not_found(result)
+        site_file_not_founds = FileNotFoundPage.where(site_id: homepage.site_id)
+        site_file_not_founds.any? ? site_file_not_founds.first : result
+      end
+
+    end
+  end
+
+  module InstanceMethods
+    def associate_with_site
+      self.site_id = self.parent.site.id if self.site_id.nil?
+    end
+  end
+
+  module ClassMethods
+
+    def find_by_slug_for_site(slug)
+      self.where(slug: slug, site_id: Page.current_site.id)
+    end
+
+    def homepage
+      if current_site.is_a?(Site)
+        homepage = self.current_site.homepage
+      end
+      homepage ||= find_by_parent_id(nil)
+    end
+  end
+
+  def url_with_sites
+    if parent
+      parent.child_url(self)
+    else
+      "/"
+    end
+  end
+
+end

data/vendor/extensions/multi-site-extension/lib/multi_site/pages_controller_extensions.rb

@@ -0,0 +1,55 @@
+module MultiSite::PagesControllerExtensions
+  def self.included(base)
+    base.class_eval {
+      alias_method :discover_current_site_without_root, :discover_current_site
+      alias_method :discover_current_site, :discover_current_site_with_root
+
+      alias_method :index_without_site, :index
+      alias_method :index, :index_with_site
+
+      alias_method :continue_url_without_site, :continue_url
+      alias_method :continue_url, :continue_url_with_site
+
+      alias_method :remove_without_back, :remove
+      alias_method :remove, :remove_with_back
+      responses.destroy.default do
+        return_url = session[:came_from]
+        session[:came_from] = nil
+        if model.class == Page or model.class < Page
+          redirect_to return_url || admin_pages_url(:site_id => model.site.id)
+        else
+          redirect_to continue_url(params)
+        end
+      end
+    }
+  end
+
+  # for compatibility with the standard issue of multi_site,
+  # a root parameter overrides other ways of setting site
+
+  def discover_current_site_with_root
+    site_from_root || discover_current_site_without_root
+  end
+
+  def site_from_root
+    if params[:root] && @homepage = Page.find(params[:root])
+      @site = @homepage.root.site
+    end
+  end
+
+  def index_with_site
+    @site ||= Page.current_site
+    @homepage ||= @site.homepage if @site
+    @homepage ||= Page.homepage
+    response_for :plural
+  end
+
+  def remove_with_back
+    session[:came_from] = request.env["HTTP_REFERER"]
+    remove_without_back
+  end
+
+  def continue_url_with_site(options={})
+    options[:redirect_to] || (params[:continue] ? edit_admin_page_url(model) : admin_pages_url(:site_id => model.site.id))
+  end
+end

data/vendor/extensions/multi-site-extension/lib/multi_site/resource_controller_extensions.rb

@@ -0,0 +1,42 @@
+module MultiSite::ResourceControllerExtensions
+
+  def self.included(base)
+    base.class_eval {
+      alias_method :discover_current_site_without_input, :discover_current_site
+      alias_method :discover_current_site, :discover_current_site_with_input
+    }
+  end
+
+  def current_site=(site=nil)
+    Page.current_site = site
+    set_session_site
+  end
+
+  # among other things this determines whether the site chooser is shown in the submenu
+
+  def sited_model?
+    model_class == Page || model_class.is_site_scoped?
+  end
+
+protected
+
+  def discover_current_site_with_input
+    site_from_param || site_from_session || discover_current_site_without_input
+  end
+
+  # for interface consistency we want to be able to remember site choices between requests
+
+  def set_session_site(site_id=nil)
+    site_id ||= current_site.id.to_s if current_site.is_a? Site
+    session[:site_id] = site_id
+  end
+
+  def site_from_session
+    session[:site_id] && Site.find(session[:site_id]) rescue nil
+  end
+
+  def site_from_param
+    params[:site_id] && Site.find(params[:site_id]) rescue nil
+  end
+
+end

data/vendor/extensions/multi-site-extension/lib/multi_site/route_extensions.rb

@@ -0,0 +1,22 @@
+module MultiSite
+  module RouteExtensions
+
+    def self.included(base)
+      base.alias_method :recognition_conditions_without_site, :recognition_conditions
+      base.alias_method :recognition_conditions, :recognition_conditions_with_site
+    end
+
+    def recognition_conditions_with_site
+      result = recognition_conditions_without_site
+      if site_names = conditions.delete(:site)
+        domains = [*site_names].map{ |site| Regexp.compile(::Site.find_by_name(site).domain) }
+        conditions[:site] = Regexp.union(*domains)
+        result << "conditions[:site] === env[:site]"
+      end
+      result
+    end
+
+  end
+end
+
+ActionController::Routing::Route.send :include, MultiSite::RouteExtensions

data/vendor/extensions/multi-site-extension/lib/multi_site/route_set_extensions.rb

@@ -0,0 +1,17 @@
+module MultiSite
+  module RouteSetExtensions
+
+    def self.included(base)
+      base.alias_method :extract_request_environment_without_site, :extract_request_environment
+      base.alias_method :extract_request_environment, :extract_request_environment_with_site
+    end
+
+    def extract_request_environment_with_site(request)
+      env = extract_request_environment_without_site(request)
+      env.merge! :site => request.host
+    end
+
+  end
+end
+
+ActionController::Routing::RouteSet.send :include, MultiSite::RouteSetExtensions

data/vendor/extensions/multi-site-extension/lib/multi_site/scoped_model.rb

@@ -0,0 +1,133 @@
+module MultiSite
+
+  module ScopedModel
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def is_site_scoped?
+        false
+      end
+
+      # only option at the moment is :shareable, which we take to mean that sites are optional:
+      # if true it causes us not to set the site automatically or to validate its presence,
+      # and to extend the scoping conditions so that objects with no site are returned as
+      # well as objects with the specified site
+      # that is, anything without a site is considered to be shared among all sites
+      # the default is false
+
+      def is_site_scoped(options={})
+        return if is_site_scoped?
+
+        options = {
+          :shareable => false
+        }.merge(options)
+
+        class_eval <<-EO
+          default_scope {where(site_scope_condition)}
+          extend MultiSite::ScopedModel::ScopedClassMethods
+          include MultiSite::ScopedModel::ScopedInstanceMethods
+        EO
+
+        belongs_to :site
+        Site.send(:has_many, plural_symbol_for_class)
+
+        before_validation :set_site
+        validates_presence_of :site unless options[:shareable]
+
+        class << self
+          attr_accessor :shareable
+          alias_method :paginate_without_site, :paginate
+          alias_method :paginate, :paginate_with_site
+          %w{count average minimum maximum sum}.each do |getter|
+            alias_method "#{getter}_without_site".intern, getter.intern
+            alias_method getter.intern, "#{getter}_with_site".intern
+          end
+        end
+
+        self.shareable = options[:shareable]
+      end
+    end
+
+    module ScopedClassMethods
+
+
+      def paginate_with_site(options={})
+        return paginate_without_site(options) unless sites?
+        where(site_scope_condition) do
+          paginate_without_site(options)
+        end
+      end
+
+      %w{count average minimum maximum sum}.each do |getter|
+        define_method("#{getter}_with_site") do |*args|
+          return send("#{getter}_without_site".intern, *args) unless sites?
+          with_scope(:find => {:conditions => site_scope_condition}) do
+            send "#{getter}_without_site".intern, *args
+          end
+        end
+      end
+
+      # this only works with :all and :first
+      # and should only be used in odd cases like migration.
+      def find_without_site(*args)
+        options = args.extract_options!
+        #set_readonly_option!(options)
+
+        case args.first
+          when :first then find_initial_without_site(options)     # defined here
+          when :all   then all_without_site(options)       # already defined by the alias chain
+        end
+      end
+
+      def find_initial_without_site(options)
+        options.update(:limit => 1)
+        all_without_site(options).first
+      end
+
+      def sites?
+        Site.table_exists? && Site.several?
+      end
+
+      def current_site!
+        raise(ActiveRecord::SiteNotFound, "#{self} is site-scoped but current_site is #{self.current_site.inspect}", caller) if sites? && !self.current_site && !self.is_shareable?
+        self.current_site
+      end
+
+      def current_site
+        Page.current_site
+      end
+
+      def site_scope_condition
+        if self.shareable
+          condition = ""
+          condition << "#{self.table_name}.site_id = #{self.current_site.id} OR " if self.current_site
+          condition << "#{self.table_name}.site_id IS NULL"
+        else
+          condition = "#{self.table_name}.site_id = #{self.current_site!.id}"
+        end
+        condition
+      end
+
+      def plural_symbol_for_class
+        self.to_s.pluralize.underscore.intern
+      end
+
+      def is_site_scoped?
+        true
+      end
+
+      def is_shareable?
+        !!self.shareable
+      end
+    end
+
+    module ScopedInstanceMethods
+      protected
+        def set_site
+          self.site ||= self.class.current_site! unless self.class.is_shareable?
+        end
+    end
+  end
+end

data/vendor/extensions/multi-site-extension/lib/multi_site/scoped_validation.rb

@@ -0,0 +1,33 @@
+module MultiSite::ScopedValidation
+
+  def self.included(base)
+
+    base.class_eval do
+      # scoping validations to the site should be very simple
+      # all you would normally need is something like this:
+      #
+      #   validates_uniqueness_of :email, :scope => :site_id
+      #
+      # but if you want to scope core trusty classes, you have a problem:
+      # their uniqueness validations have already been declared
+      # The only answer is to reach right back and change the validates_uniqueness_of method
+      # and to make it more awkward, that has to happen so early that we can't reflect on the site association.
+      # Hence the check for a site_id column. It's a hack, but a fairly harmless one.
+
+      def validates_uniqueness_of_with_site(*attr)
+        if table_exists? && column_names.include?('site_id')
+          configuration = attr.extract_options!
+          configuration[:scope] ||= :site_id
+          attr.push(configuration)
+        end
+        validates_uniqueness_of_without_site(*attr)
+      end
+
+      alias_method :validates_uniqueness_of_without_site, :validates_uniqueness_of
+      alias_method :validates_uniqueness_of, :validates_uniqueness_of_with_site
+    end
+
+  end
+end
+
+ActiveRecord::Validations::ClassMethods.send :include, MultiSite::ScopedValidation

data/vendor/extensions/multi-site-extension/lib/multi_site/site_chooser_helper.rb

@@ -0,0 +1,14 @@
+module MultiSite::SiteChooserHelper
+
+def sites_chooser_thing
+  return "" unless admin? && defined?(Site) && defined?(controller) && controller.sited_model? && controller.template_name == 'index' && Site.several?
+  options = Site.all.map{ |site| "<li>" + link_to( site.name, "#{request.path}?site_id=#{site.id}", :class => site == current_site ? 'fg' : '') + "</li>" }.join("")
+  chooser = %{<div id="site_chooser">}
+  #chooser << link_to("sites", admin_sites_url, {:id => 'show_site_list', :class => 'expandable'})
+  chooser << %{<ul id="nav"><li>Current Site: #{current_site.name}}
+  chooser << %{<ul class="expansion">#{options}</ul></li></ul>}
+  chooser << %{</div>}
+  chooser
+end
+
+end

data/vendor/extensions/multi-site-extension/lib/multi_site/site_controller_extensions.rb

@@ -0,0 +1,30 @@
+module MultiSite::SiteControllerExtensions
+  def self.included(base)
+    base.class_eval do
+      before_action :set_site
+      alias_method :process_page_without_home_path, :process_page
+      alias_method :process_page, :process_page_with_home_path
+    end
+  end
+
+  # If it's a file not found page and the path doesn't include
+  # the site's homepage path, try redirecting to include it.
+  def process_page_with_home_path(page)
+    homepage = Page.current_site.homepage
+    if page.is_a?(FileNotFoundPage) && !params[:url].include?(homepage.slug)
+      if homepage.slug != "/"
+        false if redirect_to "/#{homepage.slug}/#{params[:url]}"
+      else
+        process_page_without_home_path(page)
+      end
+    else
+      process_page_without_home_path(page)
+    end
+
+  end
+
+  def set_site
+    Page.current_site = Site.find_for_host(request.host)
+    true
+  end
+end

data/vendor/extensions/multi-site-extension/lib/tasks/multi_site_extension_tasks.rake

@@ -0,0 +1,28 @@
+namespace :trusty do
+  namespace :extensions do
+    namespace :multi_site do
+      
+      desc "Runs the migration of the Multi Site extension"
+      task :migrate => :environment do
+        require 'trusty_cms/extension_migrator'
+        if ENV["VERSION"]
+          MultiSiteExtension.migrator.migrate(ENV["VERSION"].to_i)
+        else
+          MultiSiteExtension.migrator.migrate
+        end
+      end
+      
+      desc "Copies public assets of the Multi Site to the instance public/ directory."
+      task :update => :environment do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        puts "Copying assets from MultiSiteExtension"
+        Dir[MultiSiteExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(MultiSiteExtension.root, '')
+          directory = File.dirname(path)
+          mkdir_p RAILS_ROOT + directory, :verbose => false
+          cp file, RAILS_ROOT + path, :verbose => false
+        end
+      end  
+    end
+  end
+end

data/vendor/extensions/multi-site-extension/lib/tasks/scoped_admin_extension_tasks.rake

@@ -0,0 +1,28 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :scoped_admin do
+      
+      desc "Runs the migration of the Scoped Admin extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ENV["VERSION"]
+          ScopedAdminExtension.migrator.migrate(ENV["VERSION"].to_i)
+        else
+          ScopedAdminExtension.migrator.migrate
+        end
+      end
+      
+      desc "Copies public assets of the Scoped Admin to the instance public/ directory."
+      task :update => :environment do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        puts "Copying assets from ScopedAdminExtension"
+        Dir[ScopedAdminExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(ScopedAdminExtension.root, '')
+          directory = File.dirname(path)
+          mkdir_p RAILS_ROOT + directory
+          cp file, RAILS_ROOT + path
+        end
+      end  
+    end
+  end
+end

data/vendor/extensions/multi-site-extension/lib/trusty-multi-site-extension.rb

@@ -0,0 +1 @@
+# Nothing to see here

data/vendor/extensions/multi-site-extension/multi_site_extension.rb

@@ -0,0 +1,61 @@
+require_dependency 'application_controller'
+
+class MultiSiteExtension < TrustyCms::Extension
+  version "3.0.2"
+  description %{ Enables virtual sites to be created with associated domain names.
+                 Also scopes the sitemap view to any given page (or the root of an
+                 individual site) and allows model classes to be scoped by site. }
+  url "http://trustarts.org/"
+
+
+  def activate
+
+    # Model extensions
+    ActiveRecord::Base.send :include, MultiSite::ScopedModel
+    Page.send :include, MultiSite::PageExtensions
+
+    # Controller extensions
+    ApplicationController.send :include, MultiSite::ApplicationControllerExtensions
+    Admin::ResourceController.send :include, MultiSite::ApplicationControllerExtensions
+    ApplicationController.send :include, MultiSite::ApplicationControllerFilterExtensions
+
+    #ActionController::Base.send :include, MultiSite::ApplicationControllerExtensions
+    SiteController.send :include, MultiSite::SiteControllerExtensions
+    Admin::ResourceController.send :include, MultiSite::ResourceControllerExtensions
+    Admin::PagesController.send :include, MultiSite::PagesControllerExtensions
+    Admin::ResourceController.send :helper, MultiSite::SiteChooserHelper
+    Admin::PagesController.send :helper, MultiSite::SiteChooserHelper
+    admin.layouts.index.add(:before_nav, "admin/layouts/site_chooser")
+    admin.pages.index.add(:before_nav, "admin/layouts/site_chooser")
+    admin.snippets.index.add(:before_nav, "admin/layouts/site_chooser")
+    Layout.send :is_site_scoped
+    Snippet.send :is_site_scoped
+    User.send :is_site_scoped, :shareable => true
+    ApplicationHelper.send :include, ScopedHelper
+
+    unless admin.users.edit.form && admin.users.edit.form.include?('choose_site')
+      admin.users.edit.add :form, "choose_site", :after => "edit_roles"
+      admin.layouts.edit.add :form, "choose_site", :before => "edit_timestamp"
+      admin.snippets.edit.add :form, "choose_site", :before => "edit_filter" unless admin.snippets.edit.form.include?("choose_site")
+    end
+
+
+    unless defined? admin.site
+      TrustyCms::AdminUI.send :include, MultiSite::AdminUI
+      admin.site = TrustyCms::AdminUI.load_default_site_regions
+    end
+
+    if respond_to?(:tab)
+      tab("Settings") do
+        add_item "Sites", "/admin/sites", :after => "Extensions", :visibility => [:admin]
+      end
+    else
+      admin.tabs.add "Sites", "/admin/sites", :visibility => [:admin]
+    end
+  end
+
+  def deactivate
+  end
+end
+
+class ActiveRecord::SiteNotFound < Exception; end

data/vendor/extensions/snippets-extension/snippets_extension.rb

@@ -0,0 +1,46 @@
+class SnippetsExtension < TrustyCms::Extension
+
+  def activate
+    if defined?(Radiant::Exporter)
+      TrustyCms::Exporter.exportable_models << Snippet
+      TrustyCms::Exporter.template_models << Snippet
+    end
+
+    Page.class_eval do
+      include SnippetTags
+    end
+
+    TrustyCms::AdminUI.class_eval do
+      attr_accessor :snippet
+
+      alias_method :snippets, :snippet
+
+      def load_default_snippet_regions
+        OpenStruct.new.tap do |snippet|
+          snippet.edit = TrustyCms::AdminUI::RegionSet.new do |edit|
+            edit.main.concat %w{edit_header edit_form}
+            edit.form.concat %w{edit_title edit_content edit_filter}
+            edit.form_bottom.concat %w{edit_buttons edit_timestamp}
+          end
+          snippet.index = TrustyCms::AdminUI::RegionSet.new do |index|
+            index.top.concat %w{}
+            index.thead.concat %w{title_header actions_header}
+            index.tbody.concat %w{title_cell actions_cell}
+            index.bottom.concat %w{new_button}
+          end
+          snippet.new = snippet.edit
+          snippet.remove = snippet.edit
+        end
+      end
+    end
+
+    admin.snippet       ||= TrustyCms::AdminUI.load_default_snippet_regions
+
+    UserActionObserver.instance.send :add_observer!, ::Snippet
+
+    tab 'Design' do
+      add_item "Snippets", "/admin/snippets"
+    end
+
+  end
+end