effective_regions 1.0.0

data/Rakefile

@@ -0,0 +1,23 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+# Our tasks
+load 'lib/tasks/effective_regions_tasks.rake'
+
+# Testing tasks
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task :default => :spec

data/app/assets/javascripts/effective/snippets/current_user_info.js.coffee

@@ -0,0 +1,24 @@
+CKEDITOR.dialog.add 'current_user_info', (editor) ->
+  title: 'Current User info',
+  minWidth: 200,
+  minHeight: 100,
+  contents: [
+    {
+      id: 'current_user_info',
+      elements: [
+        {
+          id: 'method',
+          type: 'select',
+          label: 'Current User Info',
+          items: [
+            ['E-mail', 'email'],
+            ['Full Name', 'full_name'],
+            ['First Name', 'first_name'],
+            ['Last Name', 'last_name']
+          ],
+          setup: (widget) -> this.setValue(widget.data.method),
+          commit: (widget) -> widget.setData('method', this.getValue())
+        }
+      ]
+    }
+  ]

data/app/controllers/effective/regions_controller.rb

@@ -0,0 +1,154 @@
+module Effective
+  class RegionsController < ApplicationController
+    respond_to :html, :json
+    layout false
+
+    before_filter :authenticate_user! if defined?(Devise)
+    skip_log_page_views :quiet => true, :only => [:snippet, :snippets, :templates] if defined?(EffectiveLogging)
+
+    skip_before_filter :verify_authenticity_token, :only => [:update]
+
+    def edit
+      EffectiveRegions.authorized?(self, :edit, Effective::Region.new())
+
+      cookies['effective_regions_editting'] = {:value => request.referrer, :path => '/'}
+
+      # TODO: turn this into a cookie or something better.
+      redirect_to request.url.gsub('/edit', '') + '?edit=true'
+    end
+
+    def update
+      javascript_should_refresh_page = ''
+
+      Effective::Region.transaction do
+        (request.fullpath.slice!(0..4) rescue nil) if request.fullpath.to_s.starts_with?('/edit') # This is so the before_save_method can reference the real current page
+
+        region_params.each do |key, vals| # article_section_2_title => {:content => '<p></p>'}
+          to_save = nil  # Which object, the regionable, or the region (if global) to save
+
+          regionable, title = find_regionable(key)
+
+          if regionable
+            EffectiveRegions.authorized?(self, :update, regionable) # can I update the regionable object?
+
+            region = regionable.regions.find { |region| region.title == title }
+            region ||= regionable.regions.build(:title => title)
+
+            to_save = regionable
+          else
+            region = Effective::Region.global.where(:title => title).first_or_initialize
+            EffectiveRegions.authorized?(self, :update, region) # can I update the global region?
+
+            to_save = region
+          end
+
+          region.content = cleanup(vals[:content])
+
+          region.snippets = HashWithIndifferentAccess.new()
+          (vals[:snippets] || []).each { |snippet, vals| region.snippets[snippet] = vals }
+
+          # Last chance for a developer to make some changes here
+          if (run_before_save_method(region, regionable) rescue nil) == :refresh
+            javascript_should_refresh_page = 'refresh'
+          end
+
+          to_save.save!
+        end
+
+        render :text => javascript_should_refresh_page, :status => 200
+        return
+      end
+
+      render :text => 'error', :status => :unprocessable_entity
+    end
+
+    def snippets
+      EffectiveRegions.authorized?(self, :edit, Effective::Region.new())
+
+      retval = {}
+      EffectiveRegions.snippets.each do |snippet|
+        retval[snippet.class_name] = {
+          :dialog_url => snippet.snippet_dialog_url,
+          :label => snippet.snippet_label,
+          :description => snippet.snippet_description,
+          :inline => snippet.snippet_inline,
+          :editables => snippet.snippet_editables,
+          :tag => snippet.snippet_tag.to_s
+          #:template => ActionView::Base.new(ActionController::Base.view_paths, {}, ActionController::Base.new).render(:partial => snippet.to_partial_path, :object => snippet, :locals => {:snippet => snippet})
+        }
+      end
+
+      render :json => retval
+    end
+
+    def snippet # This is a GET.  CKEDITOR passes us data, we need to render the non-editable content
+      klass = "Effective::Snippets::#{region_params[:name].try(:classify)}".safe_constantize
+
+      if klass.present?
+        @snippet = klass.new(region_params[:data])
+        render :partial => @snippet.to_partial_path, :object => @snippet, :locals => {:snippet => @snippet, :snippet_preview => true}
+      else
+        render :text => "Missing class Effective::Snippets::#{region_params[:name].try(:classify)}"
+      end
+    end
+
+    def templates
+      EffectiveRegions.authorized?(self, :edit, Effective::Region.new())
+
+      retval = EffectiveRegions.templates.map do |template|
+        {
+          :title => template.title,
+          :description => template.description,
+          :image => template.image || "#{template.class_name}.png",
+          :html => render_to_string(:partial => template.to_partial_path, :object => template, :locals => {:template => template})
+        }
+      end
+
+      render :json => retval
+    end
+
+    protected
+
+    def find_regionable(key)
+      regionable = nil
+      title = nil
+
+      if(class_name, id, title = key.scan(/(\w+)_(\d+)_(\w+)/).flatten).present?
+        regionable = (class_name.classify.safe_constantize).find(id) rescue nil
+      end
+
+      return regionable, (title || key)
+    end
+
+    def cleanup(str)
+      (str || '').tap do |str|
+        str.chomp!('<p>&nbsp;</p>') # Remove any trailing empty <p>'s
+        str.gsub!("\n", '')
+        str.strip!
+      end
+    end
+
+    def region_params
+      begin
+        params.require(:effective_regions).permit!
+      rescue => e
+        params[:effective_regions]
+      end
+    end
+
+    private
+
+    def run_before_save_method(region, regionable)
+      return nil if region == nil
+
+      if EffectiveRegions.before_save_method.respond_to?(:call)
+        view_context.instance_exec(region, (regionable || :global), &EffectiveRegions.before_save_method)
+      elsif EffectiveRegions.before_save_method.kind_of?(Symbol)
+        self.instance_exec(self, region, (regionable || :global), &EffectiveRegions.before_save_method)
+      end
+
+    end
+
+  end
+end
+

data/app/helpers/effective_regions_helper.rb

@@ -0,0 +1,108 @@
+module EffectiveRegionsHelper
+  def effective_region(*args)
+    options = args.extract_options!
+    block_given? ? ckeditor_region(args, options) { yield } : ckeditor_region(args, options)
+  end
+
+  def simple_effective_region(*args)
+    (options = args.extract_options!).merge!(:type => :simple)
+    block_given? ? ckeditor_region(args, options) { yield } : ckeditor_region(args, options)
+  end
+
+  def snippet_effective_region(*args)
+    (options = args.extract_options!).merge!(:type => :snippets)
+    block_given? ? ckeditor_region(args, options) { yield } : ckeditor_region(args, options)
+  end
+
+  def wrapped_snippet_effective_region(*args)
+    (options = args.extract_options!).merge!(:type => :wrapped_snippets)
+    block_given? ? ckeditor_region(args, options) { yield } : ckeditor_region(args, options)
+  end
+
+  # Loads the Ckeditor Javascript & Stylesheets only when in edit mode
+  def effective_regions_include_tags
+    if effectively_editting?
+      javascript_include_tag('effective_ckeditor') + stylesheet_link_tag('effective_ckeditor')
+    end
+  end
+
+  def effectively_editting?
+    @effectively_editting ||= request.fullpath.include?('?edit=true')
+  end
+
+  private
+
+  def ckeditor_region(args, options = {}, &block)
+    obj = args.first
+    title = args.last.to_s.parameterize
+    editable_tag = options.delete(:editable_tag) || :div
+
+    # Set up the editable div options we need to send to ckeditor
+    if effectively_editting?
+      opts = {
+        :contenteditable => true,
+        'data-effective-ckeditor' => (options.delete(:type) || :full).to_s,
+        'data-allowed-snippets' => [options.delete(:snippets)].flatten.compact.to_json,
+        :style => ['-webkit-user-modify: read-write;', options.delete(:style), ('display: inline;' if options.delete(:inline))].compact.join(' '),
+        :class => ['effective-region', options.delete(:class)].compact.join(' ')
+      }.merge(options)
+    end
+
+    if obj.kind_of?(ActiveRecord::Base)
+      raise StandardError.new('Object passed to effective_region helper must declare act_as_regionable') unless obj.respond_to?(:acts_as_regionable)
+
+      region = obj.regions.find { |region| region.title == title }
+
+      if effectively_editting?
+        can_edit = (EffectiveRegions.authorized?(controller, :update, obj) rescue false)
+        opts[:id] = [model_name_from_record_or_class(obj).param_key(), obj.id, title].join('_')
+      end
+    else # This is a global region
+      regions = (@effective_regions_global ||= Effective::Region.global.to_a)
+      region = regions.find { |region| region.title == title } || Effective::Region.new(:title => title)
+
+      if effectively_editting?
+        can_edit = (EffectiveRegions.authorized?(controller, :update, region) rescue false)
+        opts[:id] = title.to_s.parameterize
+      end
+    end
+
+    if effectively_editting? && can_edit # If we need the editable div
+      content_tag(editable_tag, opts) do
+        region.try(:content).present? ? render_region(region, true) : ((capture(&block).strip.html_safe) if block_given?)
+      end
+    else
+      region.try(:content).present? ? render_region(region, false) : ((capture(&block).strip.html_safe) if block_given?)
+    end
+  end
+
+  def render_region(region, can_edit = true)
+    return '' unless region
+
+    region.content.tap do |html|
+      html.scan(/\[(snippet_\d+)\]/).flatten.uniq.each do |id| # find snippet_1 and replace with snippet content
+        snippet = region.snippet_objects.find { |snippet| snippet.id == id }
+        html.gsub!("[#{id}]", render_snippet(snippet, can_edit)) if snippet
+      end
+    end.html_safe
+  end
+
+  def render_snippet(snippet, can_edit = true)
+    return '' unless snippet
+
+    if Rails.env.production?
+      content = render(:partial => snippet.to_partial_path, :object => snippet, :locals => {:snippet => snippet}) rescue ''
+    else
+      content = render(:partial => snippet.to_partial_path, :object => snippet, :locals => {:snippet => snippet})
+    end
+
+    if effectively_editting? && can_edit
+      content_tag(snippet.snippet_tag, content, :data => {'effective-snippet' => snippet.class_name, 'snippet-data' => snippet.data().to_json})
+    else
+      content
+    end.html_safe
+  end
+
+
+
+end

data/app/models/concerns/acts_as_regionable.rb

@@ -0,0 +1,34 @@
+module ActsAsRegionable
+  extend ActiveSupport::Concern
+
+  module ActiveRecord
+    def acts_as_regionable(*options)
+      @acts_as_regionable_opts = options || []
+      include ::ActsAsRegionable
+    end
+  end
+
+  included do
+    has_many :regions, :as => :regionable, :class_name => 'Effective::Region', :dependent => :delete_all, :autosave => true
+  end
+
+  module ClassMethods
+  end
+
+  def acts_as_regionable
+    true
+  end
+
+  def snippet_objects(klass = nil)
+    objs = regions.map { |region| region.snippet_objects }.flatten
+
+    if klass
+      objs = objs.select { |obj| obj.class == klass }
+    else
+      objs
+    end
+
+  end
+
+end
+

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

data/app/models/effective/region.rb

@@ -0,0 +1,44 @@
+module Effective
+  class Region < ActiveRecord::Base
+    self.table_name = EffectiveRegions.regions_table_name.to_s
+
+    belongs_to :regionable, :polymorphic => true
+
+    structure do
+      title             :string, :validates => [:presence]
+      content           :text
+      snippets          :text
+
+      timestamps
+    end
+
+    serialize :snippets, HashWithIndifferentAccess
+
+    scope :global, -> { where("#{EffectiveRegions.regions_table_name}.regionable_type IS NULL").where("#{EffectiveRegions.regions_table_name}.regionable_id IS NULL") }
+
+    def snippets
+      self[:snippets] || HashWithIndifferentAccess.new()
+    end
+
+    # Hash of the Snippets objectified
+    #
+    # Returns a Hash of {'snippet_1' => CurrentUserInfo.new(snippets[:key]['options'])}
+    def snippet_objects
+      @snippet_objects ||= snippets.map do |key, snippet|  # Key here is 'snippet_1'
+        if snippet['class_name']
+          klass = "Effective::Snippets::#{snippet['class_name'].classify}".safe_constantize
+          klass.new(snippet.merge!(:region => self, :id => key)) if klass
+        end
+      end.compact
+    end
+
+    def global?
+      regionable_id == nil && regionable_type == nil
+    end
+
+  end
+end
+
+
+
+

data/app/models/effective/snippets/current_user_info.rb

@@ -0,0 +1,12 @@
+module Effective
+  module Snippets
+    class CurrentUserInfo < Snippet
+      attribute :method, String
+
+      def snippet_tag
+        :span
+      end
+      
+    end
+  end
+end

data/app/models/effective/snippets/snippet.rb

@@ -0,0 +1,69 @@
+require 'virtus'
+
+module Effective
+  module Snippets
+    class Snippet
+      include Virtus.model
+
+      attribute :id, String # This will be snippet_12345
+      attribute :region, Effective::Region # The region Object
+
+      # SO I have to add some restrictions on how snippets are built:
+
+      # Each Snippet has to be a block (or inline) element with nested children.
+      # It has to start with a root object
+
+      # That root object has to do {snippet_data(snippet)}
+
+
+      def initialize(atts = {})
+        (atts || {}).each { |k, v| self.send("#{k}=", v) if respond_to?("#{k}=") }
+      end
+
+      def id
+        super.presence || "snippet_#{object_id}"
+      end
+
+      def data
+        self.attributes.reject { |k, v| [:region, :id].include?(k) }
+      end
+
+      def to_partial_path
+        "effective/snippets/#{class_name}"
+      end
+
+      def class_name
+        @class_name ||= self.class.name.demodulize.underscore.to_sym
+      end
+
+      ### The following methods are used for the CKEditor widget creation.
+      def snippet_label
+        class_name.to_s.humanize
+      end
+
+      def snippet_description
+        "Insert #{snippet_label}"
+      end
+
+      def snippet_dialog_url
+        "/assets/effective/snippets/#{class_name}.js"
+      end
+
+      # This is the tag that the ckeditor snippet will be created as
+      # It supports divs and spans, but that's it
+      # No ULs, or LIs
+      def snippet_tag
+        :div
+      end
+
+      def snippet_inline
+        [:span].include?(snippet_tag)
+      end
+
+      def snippet_editables
+        false
+      end
+
+    end
+  end
+end