tandem 0.2.0.rc

data/app/controllers/tandem/contents_controller.rb

@@ -0,0 +1,94 @@
+module Tandem
+  class ContentsController < ::Tandem::ApplicationController
+    load_and_authorize_resource
+    layout 'tandem/popup'
+
+=begin ### default scaffold actions not currently used
+    # GET /contents
+    # GET /contents.json
+    def index
+      @contents = @page.contents.all
+      authorize_content!
+  
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render json: @contents }
+      end
+    end
+  
+    # GET /contents/1
+    # GET /contents/1.json
+    def show
+      @content = @page.contents.find(params[:id])
+      authorize_content!
+
+      respond_to do |format|
+        format.html # show.html.erb
+        format.json { render json: @content }
+      end
+    end
+  
+    # GET /contents/new
+    # GET /contents/new.json
+    def new
+      @content = @page.contents.new
+      authorize_content!
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.json { render json: @content }
+      end
+    end
+  
+    # POST /contents
+    # POST /contents.json
+    def create
+      @content = Content::Text.new(params[:content].merge(:page_id => @page.id))
+      authorize_content!
+
+      respond_to do |format|
+        if @content.save
+          format.html { render action: "success", notice: 'Content was successfully created.' }
+          format.json { render json: @content, status: :created, location: @content }
+        else
+          format.html { render action: "new" }
+          format.json { render json: @content.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # DELETE /contents/1
+    # DELETE /contents/1.json
+    def destroy
+      @content = @page.contents.find(params[:id])
+      authorize_content!
+
+      @content.destroy
+
+      respond_to do |format|
+        format.html { redirect_to page_contents_url }
+        format.json { head :ok }
+      end
+    end
+
+=end
+
+    # GET /contents/1/edit
+    def edit
+    end
+
+    # PUT /contents/1
+    # PUT /contents/1.json
+    def update
+      param_key = ActiveModel::Naming.param_key(@content)
+
+      respond_to do |format|
+        if @content.update_attributes(params[param_key])
+          format.json { render json: @content }
+        else
+          format.json { render json: @content.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  end
+end

data/app/controllers/tandem/images_controller.rb

@@ -0,0 +1,92 @@
+module Tandem
+  class ImagesController < ::Tandem::ApplicationController
+    load_and_authorize_resource
+    skip_load_and_authorize_resource :only => :thumb
+    skip_authorization_check :only => :thumb
+    layout 'tandem/image'
+
+    # GET /images
+    # GET /images.json
+    def index
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render json: @images }
+      end
+    end
+  
+    # GET /images/1
+    # GET /images/1.json
+    def show
+      respond_to do |format|
+        format.html #show.html.erb
+        format.json { render json: @image }
+      end
+    end
+  
+    # GET /images/1/thumb
+    # GET /images/1/thumb.json
+    #this method is deliberately forgiving to image id's that don't exist
+    def thumb
+      @image = Tandem::Image.find_by_id(params[:id])
+      @content = Tandem::Content::Image.new(image: @image)
+      respond_to do |format|
+        format.html { render layout: nil }# thumb.html.erb
+      end
+    end
+
+    # GET /images/new
+    # GET /images/new.json
+    def new
+      @update_gallery = params['update_gallery'].present?
+      respond_to do |format|
+        format.html # new.html.erb
+        format.json { render json: @image }
+      end
+    end
+  
+    # GET /images/1/edit
+    def edit
+    end
+  
+    # POST /images
+    # POST /images.json
+    def create
+      respond_to do |format|
+        if @image.save
+          format.html { redirect_to new_image_path(update_gallery: true), notice: 'Image was successfully created.' }
+          format.json { render json: @image, status: :created, location: @image }
+        else
+          format.html { render action: "new" }
+          format.json { render json: @image.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # PUT /images/1
+    # PUT /images/1.json
+    def update
+      respond_to do |format|
+        if @image.update_attributes(params[:image])
+          format.html { redirect_to @image, notice: 'Image was successfully updated.' }
+          format.json { head :ok }
+        else
+          format.html { render action: "edit" }
+          format.json { render json: @image.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # DELETE /images/1
+    # DELETE /images/1.json
+    def destroy
+      @image.destroy
+  
+      respond_to do |format|
+        format.html { redirect_to images_url }
+        format.json { head :ok }
+      end
+    end
+
+    private
+  end
+end

data/app/controllers/tandem/pages_controller.rb

@@ -0,0 +1,108 @@
+module Tandem
+  class PagesController < ::Tandem::ApplicationController
+    load_and_authorize_resource :except => :home, :find_by => :slug
+    layout :pages_layout
+
+    # GET /pages/home
+    # GET /pages.home.json
+    def home
+      @page = Page.where(is_default: true).first || Page.first || create_default_page
+      authorize!(:show, Page)
+      respond_to do |format|
+        format.html { render (@page.template.present? ? @page.template : 'show'), notice: @page.new_record? ? 'No Pages Found.' : '' }
+        format.json { render json: @page }
+      end
+    end
+
+    # GET /pages
+    # GET /pages.json
+    def index
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render json: @pages }
+      end
+    end
+  
+    # GET /pages/1
+    # GET /pages/1.json
+    def show
+      respond_to do |format|
+        format.html { render @page.template if @page.template.present? }
+        format.json { render json: @page }
+      end
+    end
+  
+    # GET /pages/new
+    # GET /pages/new.json
+    def new
+      @page.parent ||= Page.where(id: params['parent_id']).first
+      respond_to do |format|
+        format.html { render layout: false if request.xhr? }
+        format.json { render json: @page }
+      end
+    end
+  
+    # GET /pages/1/edit
+    def edit
+      respond_to do |format|
+        format.html { render layout: false if request.xhr? }
+      end
+    end
+
+    # POST /pages
+    # POST /pages.json
+    def create
+      respond_to do |format|
+        if @page.save
+          format.html { redirect_to @page, notice: 'Page was successfully created.' }
+          format.json { render json: @page, status: :created, location: @page }
+        else
+          format.html { render action: "new" }
+          format.json { render json: @page.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # PUT /pages/1
+    # PUT /pages/1.json
+    def update
+      respond_to do |format|
+        if @page.update_attributes(params[:page])
+          format.html { redirect_to @page, notice: 'Page was successfully updated.' }
+          format.json  { head :no_content }
+        else
+          format.html { render action: "edit" }
+          format.json { render json: @page.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # DELETE /pages/1
+    # DELETE /pages/1.json
+    def destroy
+      @page.destroy
+
+      respond_to do |format|
+        format.html { redirect_to pages_url }
+        format.json { head :ok }
+      end
+    end
+
+    private
+
+    def pages_layout
+      case params[:action]
+        when 'show', 'home'
+          @page.layout.present? ? @page.layout : 'application'
+        when 'new', 'create', 'edit', 'update'
+          'tandem/popup'
+        else
+          'application'
+      end
+    end
+
+    def create_default_page
+      Page.create!(link_label: 'Sample Page', slug: 'sample', is_default: true)
+    end
+  end
+end

data/app/helpers/tandem/application_helper.rb

@@ -0,0 +1,29 @@
+module Tandem
+  module ApplicationHelper
+    def self.included(base)
+      main_app_url_helpers.each do |helper|
+        base.send(:define_method, helper) do |*arguments|
+          arguments = nil if arguments.empty?
+          main_app.send(helper, arguments)
+        end
+      end
+    end
+
+
+    def render_eco_template(template, locals = {})
+      @eco_templates ||= {}
+
+      if @eco_templates[template].nil?
+        template_file = File.read("#{Tandem::Engine.config.root}/app/assets/javascripts/tandem/#{template}.jst.eco")
+        @eco_templates[template] = Eco.context_for(template_file)
+      end
+
+      @eco_templates[template].call("render", locals).html_safe
+    end
+
+    private
+      def self.main_app_url_helpers
+        ::Rails.application.routes.url_helpers.methods.select{|method| method.match(/^(?!hash\_for).*_(path|url)$/)}
+      end
+  end
+end

data/app/helpers/tandem/contents_helper.rb

@@ -0,0 +1,19 @@
+module Tandem
+  module ContentsHelper
+
+    def image_content_url(image_content, format = :original)
+      image_content.image.present? ? image_content.image.resource.url(format) : 'tandem/blank_image.jpg'
+    end
+
+    def image_content_tag(image_content, options = {}, format = :original)
+      options = {style: ""}.merge(options) if format == :thumb
+      image_tag image_content_url(image_content, format), options
+    end
+
+    def text_content_text_area_options(editor = 'plain', options = {})
+      options.tap do |options|
+        options[:class] = 'wymeditor' if editor == 'wysiwyg'
+      end
+    end
+  end
+end

data/app/helpers/tandem/images_helper.rb

@@ -0,0 +1,10 @@
+module Tandem
+  module ImagesHelper
+
+    def tandem_image_tag(image, options = {}, format = nil)
+      options = {style: "height:#{Tandem::Image::THUMB_HEIGHT}px;width:#{Tandem::Image::THUMB_WIDTH}px;border:5px solid #ccc;"}.merge(options) if format == :thumb
+      image_tag image.resource.url(format), options
+    end
+
+  end
+end

data/app/helpers/tandem/pages_helper.rb

@@ -0,0 +1,243 @@
+module Tandem
+  module PagesHelper
+
+    include ContentsHelper
+
+    def self.included(base)
+      Tandem::Content.subclasses.each do |klass|
+        # tandem_#{klass.simple_type}_tag is provided as an alias of tandem_content_tag,
+        # specifying the type of content through the method name. For example:
+        #
+        #    <%= tandem_image_tag(:test_image) %>
+        #
+        # is equivalent to:
+        #
+        #    <%= tandem_content_tag(:test_image, :image) %>
+        #
+        base.send(:define_method, "tandem_#{klass.simple_type}_tag") do |identifier, options = {}, html_options = {}|
+          tandem_content_tag identifier, klass.simple_type, options, html_options
+        end
+      end
+    end
+
+    # tandem_content_tag creates an HTML DIV element with id and class parameters that
+    # relate to the specified Tandem Content object and contains an internal content element.
+    # If a Tandem::Content record doesn't exist for the unique combination of:
+    # request_key, identifier and type, one will be created automatically. For example:
+    #
+    #    <%= tandem_content_tag(:test_image, :image) %>
+    #
+    # would find_or_create a Tandem::Content::Image object and produce the following HTML:
+    #
+    #    <div class="tandem_content" id="test_image">...<img id="tandem_content_image_test_image" class="tandem_content_image bar"...</div>
+    #
+    # If the user is authorized to update content then an edit link will be generated in
+    # conjunction with the content. For example:
+    #
+    #    <%= tandem_content_tag(:test_text, :text) %>
+    #
+    # would produce the following HTML (assuming `can? :update, tandem_content` => true):
+    #
+    #    <div class="tandem_content" id="test_text">
+    #      <div class="tandem_toolbar" id="tandem_toolbar_test_text">
+    #        <a href="#" id="tandem_edit_link_test_text" title="Edit test_text" class="tandem_edit_link" editor_options="{&quot;identifier&quot;:&quot;test_text&quot;,&quot;type&quot;:&quot;text&quot;}">Edit</a>
+    #      </div>
+    #      ....
+    #    </div>
+    #
+    # If a user specifies link information for the corresponding Tandem::Content object,
+    # then an A HTML element will be generated surrounding the content. For example:
+    #
+    #    <%= tandem_content_tag(:test_image, :image) %>
+    #
+    # produces (assuming that tandem_content.link? => true):
+    #
+    #    <div class="tandem_content" id="test_image">
+    #      ...
+    #      <a id="tandem_content_link_test_image" class="tandem_content_link" ...
+    #        <img id="tandem_content_image_test_image" class="tandem_content_image" ...
+    #      </a>
+    #    </div>
+    #
+    # tandem_content_tag accepts a hash of html_options, which will be converted to
+    # additional HTML attributes of the generated container div. If you specify a <tt>:class</tt> value, it will be combined
+    # with the default class name for your object. For example:
+    #
+    #    <%= tandem_content_tag(:test_image, :image, {}, :class => "bar", :style => 'display:none') %>...
+    #
+    # produces:
+    #
+    #    <div class="tandem_content bar" id="test_image" style = "display:none">...
+    #
+    # tandem_content_tag also accepts a hash of options, which will be converted to
+    # additional HTML attributes of the internal asset type. If you specify a <tt>:class</tt> value, it will be combined
+    # with the default class name for your object. For example:
+    #
+    #    <%= tandem_content_tag(:test_image, :image, :class => "bar", :width => 80) %>...
+    #
+    # produces:
+    #
+    #    ...<img id="tandem_content_image_test_image" class="tandem_content_image bar" width = "80"...
+    #
+    # Finally, text tandem_content_tags support an <tt>:editor</tt> option, which defaults to <tt>:plain</tt>, but
+    # can also be changed to <tt>:wysiwyg</tt> to enable a WYSIWYG editor, e.g.
+    #
+    #     <%= tandem_content_tag(:main_body, :text, editor: :wysiwyg) %>
+    def tandem_content_tag(identifier, type, options = {}, html_options = {})
+      options[:editor] ||= :plain
+
+      using_tandem_abilities do
+        tandem_content = Content.scoped_type(type).constantize.find_or_create_by_request_key_and_tag(request_key, identifier)
+
+        content = case tandem_content
+          when Content::Text
+            content_tag(:div, tandem_content, options.merge(
+                id: "#{dom_class(tandem_content)}_#{identifier}",
+                class: "#{dom_class(tandem_content)} #{options[:class]}".strip
+            )) {
+              tandem_content.formatted_content.html_safe
+            }
+          when Content::Image
+            image_content_tag(tandem_content,options.merge(
+                id: "#{dom_class(tandem_content)}_#{identifier}",
+                class: "#{dom_class(tandem_content)} #{options[:class]}".strip
+            ))
+          else
+            raise "Unable to create #{tandem_content.class.name}: #{tandem_content.errors.inspect}" if tandem_content.new_record?
+            raise "Rendering behavior not defined for: #{tandem_content.class.name}"
+        end
+
+        content = link_to(content,tandem_content.link_url,{
+            id: "tandem_content_link_#{identifier}",
+            class: "tandem_content_link",
+            target: tandem_content.link_target
+        }) if tandem_content.link?
+
+        content = content_tag(:div, tandem_content, {
+            id: "tandem_toolbar_#{identifier}",
+            class: "tandem_toolbar #{options[:class]}".strip
+        }) {
+          link_to("Edit", tandem.edit_content_path(tandem_content.id, editor: options[:editor]),{
+              id: "tandem_edit_link_#{identifier}",
+              class: "tandem_edit_link #{options[:class]}".strip,
+              title: "editing #{identifier}"
+          })
+        } + content if can? :update, tandem_content
+
+        html_options.merge! id: identifier
+        html_options[:class] ||= ''
+        html_options[:class] << ' tandem_content' if can? :update, tandem_content
+        html_options[:class].strip!
+
+        content_tag(:div, tandem_content, html_options) { content }
+      end
+    end
+
+    #todo... document this
+    def tandem_navigation_tag(active_page, pages_collection = nil, html_options = {})
+      html_options, pages_collection = pages_collection, nil if pages_collection.is_a?(Hash)
+
+      html_options[:class] ||= 'nav'
+
+      page_groups = (pages_collection || Page.all).inject({}) do |groups, page|
+        if groups[page.parent_id.to_s]
+          groups[page.parent_id.to_s] << page
+        else
+          groups[page.parent_id.to_s] = [page]
+        end
+        groups
+      end
+
+      # generate must be in scope for the iterate proc declaration, but must be defined below iterate, so that iterate is recursively in scope
+      generate = nil
+
+      iterate = Proc.new do |parent_id|
+        #very important to delete the group from the collection, or it is possible users can create looping relationships
+        (page_groups.delete(parent_id.to_s) || {}).inject(''.html_safe) do |buffer, page|
+          buffer + generate.call(page)
+        end
+      end
+
+      generate = Proc.new do |page|
+        content_tag_for(:li, page, :tandem, class: "#{page == active_page ? 'active' : ''}") do
+          link_to(page.link_label, tandem.page_path(page), class: "#{page == active_page ? 'active' : ''}") +
+          content_tag(:ul) do
+            iterate.call(page.id)
+          end
+        end
+      end
+
+      content_tag(:ul, html_options) do
+        iterate.call(page_groups.keys.first)
+      end
+    end
+
+    def tandem_page_links(options ={})
+      return if cannot?(:create, @page) && cannot?(:update, @page) && cannot?(:destroy, @page)
+
+      options[:id] ||= 'tandem_page_links'
+
+      content_tag(:ul, options) do
+        links = []
+        
+        if can?(:create, @page)
+          links << link_to('New Page', tandem.new_page_path(parent_id: @page.id), :class => :page_link, :id => :page_new_link)
+        end
+
+        if @page.persisted? && can?(:update, @page)
+          links << link_to('Edit Page', tandem.edit_page_path(@page), :class => :page_link, :id => :page_edit_link)
+        end
+
+        if @page.persisted? && can?(:destroy, @page)
+          links << link_to('Destroy Page', tandem.page_path(@page), :confirm => 'Are you sure?', :method => :delete)
+        end
+
+        if can?(:index, ::Tandem::Page)
+          links << link_to('Page Listing', tandem.pages_path)
+        end
+
+        links.collect! do |link|
+          content_tag(:li, link)
+        end
+
+        raw(links.join)
+      end
+    end
+
+    def valid_layouts
+      @valid_layouts ||= Dir["#{::Rails.root}/app/views/layouts/**/*.html*"].collect do |layout|
+        name = layout.match(/layouts\/([\w\-\/]*)((\.\w*){2})$/)[1]
+        name unless name == 'application'
+      end.compact
+    end
+
+    def valid_templates
+      @valid_templates ||= Dir["#{::Rails.root}/app/views/tandem/pages/**/*.*.*"].collect do |template|
+        template_name = File.basename(template).split('.').first
+        template_name if valid_custom_template?(template_name)
+      end.compact
+    end
+
+    private
+      def invalid_templates
+        ['show', 'edit', 'index', 'new']
+      end
+
+      def valid_custom_template?(template_name)
+        template_name[0] != '_' && !invalid_templates.include?(template_name)
+      end
+
+      def request_key
+        key = "#{controller_path}-#{action_name}".gsub(/[^\w]|_/, '-')
+        key += "-#{params[:id]}" if key == 'tandem-pages-show'
+        key
+      end
+
+      def using_tandem_abilities
+        controller.instance_variable_set :@current_ability, ::Tandem::Ability.new(::Tandem::Configuration.current_user.call(request))
+        yield.tap do
+          controller.instance_variable_set :@current_ability, nil
+        end
+      end
+  end
+end

data/app/models/tandem/ability.rb

@@ -0,0 +1,6 @@
+module Tandem
+  class Ability
+    include CanCan::Ability
+    define_method :initialize, Configuration.user_abilities
+  end
+end

data/app/models/tandem/content/image.rb

@@ -0,0 +1,7 @@
+module Tandem
+  class Content::Image < Content
+    #todo: the following line introduces an artifact field on the other types of Content. For now there is only one other field type, so this down and dirty association is quickest.
+    #todo: I've already added a polymorphic field "attachment" that is designed for this same purpose, but is currently not being used for anything, it should be removed as well^^.
+    belongs_to :image, class_name: 'Tandem::Image'
+  end
+end

data/app/models/tandem/content/text.rb

@@ -0,0 +1,7 @@
+module Tandem
+  class Content::Text < Content
+    def formatted_content
+      content.presence || '<p>Sample Content</p>'
+    end
+  end
+end

data/app/models/tandem/content.rb

@@ -0,0 +1,41 @@
+module Tandem
+  class Content < ActiveRecord::Base
+    validates :tag, presence: true
+    validates :request_key, presence: true, uniqueness: {:scope => [:tag, :type]}
+
+    
+    #enforce abstract class architecture
+    validates :type, presence: true, exclusion: ['Tandem::Content']
+
+    attr_accessible :tag, :content, :details, :link_url, :link_target, :attachment_id, :attachment_type, :image_id, :request_key
+
+    def self.subclass_names
+      @subclass_names ||= subclasses.map { |sc| sc.name }
+    end
+
+    def self.simple_types
+      @simple_types ||= subclasses.map { |sc| sc.simple_type }
+    end
+
+    def self.valid_simple_type?(type)
+      simple_types.include?(type.to_s.downcase.to_sym)
+    end
+
+    def self.simple_type
+      name =~ /^Tandem\:\:Content\:\:(.*)/
+      ($1 or raise "Unable to determine simple type for abstract class: #{name}").downcase.to_sym
+    end
+
+    def self.scoped_type(type)
+      valid_simple_type?(type) or raise "Invalid Tandem::Content.simple_type: '#{type}'. Valid options #{simple_types.join(', ')}"
+      "Tandem::Content::#{type.to_s.camelize}"
+    end
+
+    def link?
+      link_url.present?
+    end
+  end
+end
+
+load 'image.rb'
+load 'text.rb'

data/app/models/tandem/image.rb

@@ -0,0 +1,27 @@
+module Tandem
+  class Image < ActiveRecord::Base
+
+    THUMB_WIDTH = 150
+    THUMB_HEIGHT = 150
+
+    has_attached_file :resource, Tandem::Configuration.paperclip_options
+
+    validates_attachment_presence :resource
+    validates_attachment_size :resource, :less_than => 1.megabyte
+    validates_attachment_content_type :resource, :content_type => ['image/gif', 'image/jpg', 'image/jpeg', 'image/png']
+
+    has_many :content_images, class_name: 'Tandem::Content::Image'
+
+    default_scope order('created_at DESC')
+
+    attr_accessible :resource
+
+    def thumb_url
+      resource.url(:thumb)
+    end
+
+    def as_json(options={})
+      super(:methods => :thumb_url)
+    end
+  end
+end