tenon 1.1.8 → 2.0.0

data/Rakefile

@@ -5,23 +5,17 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 Bundler::GemHelper.install_tasks
 Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
-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')
 
-RSpec::Core::RakeTask.new(:fastspec) do |task|
-  file_list = FileList['spec/**/*_spec.rb']
+require 'rake/testtask'
 
-  %w(requests integration features).each do |exclude|
-    file_list = file_list.exclude("spec/#{exclude}/**/*_spec.rb")
-  end
-
-  task.pattern = file_list
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
 end
 
-task default: :spec
+task default: :test

data/app/assets/javascripts/tenon/application.js

@@ -0,0 +1,4 @@
+//= require jquery
+//= require cocoon
+//= require jquery-fileupload/basic
+//= require jquery-fileupload/vendor/tmpl

data/app/controllers/tenon/assets_controller.rb

@@ -1,46 +1,45 @@
 module Tenon
   class AssetsController < Tenon::ResourcesController
-    def index
-      respond_to do |format|
-        format.html
-        format.json do
-          @assets = Tenon::Asset.all
-          @assets = @assets.where(search_args) if params[:q]
-          @assets = @assets.with_type(params[:type]) unless params[:type].blank?
-          @assets = @assets.paginate(per_page: 20, page: params[:page])
-          @assets = Tenon::PaginatingDecorator.decorate(@assets)
-        end
-      end
-    end
-
     def edit
+      super
       render layout: false
     end
 
-    def create
-      asset = Tenon::Asset.new(resource_params)
-      flash[:notice] = t('tenon.assets.successfully_uploaded') if asset.save && !request.xhr?
-      @asset = asset.decorate
-      respond_with(@asset, location: assets_path)
-    end
-
     def update
       if resource_params[:duplicate] == '1'
-        new_asset = Tenon::Asset.new(resource_params)
+        @asset = Asset.find(params[:id])
+        new_asset = Asset.new(resource_params)
+        authorize(new_asset)
         new_asset.attachment = @asset.attachment
         new_asset.save
         new_asset.crop_x = nil
         working_asset = new_asset
       else
-        working_asset = @asset
+        working_asset = Asset.find(params[:id])
+        authorize(working_asset)
         working_asset.update_attributes(resource_params)
       end
       working_asset.attachment.reprocess! if working_asset.cropping?
       @asset = working_asset.decorate
-      respond_with(@asset, location: polymorphic_index_path)
+      self.resource = @asset
+
+      respond_to do |format|
+        format.html do
+          if @asset.valid?
+            redirect_to after_update_path
+          else
+            render action: :edit
+          end
+        end
+        format.json do
+          render json: @asset
+        end
+      end
     end
 
     def crop
+      @asset = Asset.find(params[:id])
+      authorize @asset, :update?
       render layout: false
     end
 

data/app/controllers/tenon/base_controller.rb

@@ -1,42 +1,51 @@
 module Tenon
   class BaseController < ApplicationController
+    include Pundit
+
+    # Not worried about forgery here, you need to be logged in
+    skip_before_action :verify_authenticity_token
+
     layout :layout_for_resource
 
-    before_filter :set_title
-    before_filter :require_admin, unless: :devise_controller?
+    before_action :set_page_title, :set_default_context_title
+    before_action :require_admin, unless: :devise_controller?
 
-    rescue_from CanCan::AccessDenied do |exception|
-      flash[:warning] = t('tenon.common.you_are_not_authorized')
+    rescue_from Pundit::NotAuthorizedError do |exception|
+      flash[:warning] = 'You are not authorized to access that page.'
       redirect_to root_path
     end
 
     private
 
     def layout_for_resource
-      if devise_controller?
-        'tenon/login'
-      else
-        'tenon/application'
-      end
+      'tenon/application'
     end
 
-    def set_title
+    def set_page_title
       case params[:action]
       when 'new', 'create'
-        @page_title = "#{t('tenon.common.new')} #{params[:controller].gsub('tenon/', '').singularize.humanize}".titleize
+        @page_title = "New #{params[:controller].gsub('tenon/', '').singularize.humanize}".titleize
       when 'edit', 'update'
-        @page_title = "#{t('tenon.common.edit')} #{params[:controller].gsub('tenon/', '').singularize.humanize}".titleize
+        @page_title = "Edit #{params[:controller].gsub('tenon/', '').singularize.humanize}".titleize
       else
         @page_title = params[:controller].gsub('tenon/', '').humanize.titleize
       end
       @page_title = 'Tenon' if params[:controller].gsub('tenon/', '') == 'index'
     end
 
+    def set_default_context_title
+      @context_title = controller_name.humanize
+    end
+
     def require_admin
       unless current_user && current_user.staff?
-        flash[:warning] = t('tenon.common.youre_not_authorized_for_that') if current_user
+        flash[:warning] = "You're not authorized for that." if current_user
         redirect_to new_user_session_path
       end
     end
+
+    def xhr_or_js?
+      request.xhr? || request.format.js? || request.format.json?
+    end
   end
 end

data/app/controllers/tenon/index_controller.rb

@@ -1,8 +1,4 @@
 module Tenon
   class IndexController < Tenon::BaseController
-    def index
-      @warnings = Tenon::WarningGenerator.generate(root_path)
-      @tenon_callouts = Tenon::TenonCallout.published
-    end
   end
 end

data/app/controllers/tenon/item_versions_controller.rb

@@ -1,5 +1,7 @@
 module Tenon
   class ItemVersionsController < Tenon::BaseController
+    respond_to :html, :json
+
     def create
       @item_version = ItemVersion.new(resource_params)
       item_params = @item_version.item_type.gsub('Tenon::', '').underscore
@@ -7,7 +9,7 @@ module Tenon
       @item_version.creator_id = current_user.id
       @item_version.save
       respond_to do |format|
-        format.json
+        format.json { render status: 200, nothing: true }
       end
     end
 
@@ -18,7 +20,6 @@ module Tenon
       )
 
       respond_to do |format|
-        # Modal
         format.html { render layout: false }
       end
     end
@@ -28,14 +29,21 @@ module Tenon
         # Modal
         format.html { render layout: false }
 
-        format.json {
+        format.json do
           params.delete(:item_id) if params[:item_id] == ''
-          @item_versions = ItemVersion.where(
-            item_type: params[:item_type],
-            item_id: params[:item_id]
+          @item_versions = ItemVersion
+            .where(params.slice(:item_type, :item_id).permit!)
+            .paginate(page: params[:page], per_page: 5)
+
+          serializer = ActiveModel::Serializer.serializer_for(ItemVersion.new)
+          respond_with(
+            @item_versions,
+            serializer: Tenon::PaginatingSerializer,
+            each_serializer: serializer,
+            root: 'records',
+            serialization_scope: view_context
           )
-          .paginate(page: params[:page], per_page: 5)
-        }
+        end
       end
     end
 
@@ -44,5 +52,9 @@ module Tenon
     def resource_params
       params.require(:item_version).permit!
     end
+
+    def default_serializer_options
+      { root: 'record', scope: view_context }
+    end
   end
 end

data/app/controllers/tenon/resources_controller.rb

@@ -1,89 +1,157 @@
 module Tenon
-  class ResourcesController < Tenon::BaseController
+  class ResourcesController < BaseController
+    wrap_parameters format: [:json]
     respond_to :html, :json, :js
-
-    def initialize(*args)
-      self.class.load_and_authorize_resource(send(:load_options))
-      super(*args)
-    end
+    after_action :verify_authorized
+    after_action :verify_policy_scoped,
+      only: :index,
+      if: -> { request.format.json? }
 
     def index
-      authorize!(:index, klass)
+      authorize(klass)
       params[:page] = 1 if params[:page].to_i == 0
       respond_to do |format|
         format.html
         format.json do
-          self.collection = klass.all
-          self.collection = collection.where(search_args) if params[:q]
-          self.collection = collection.paginate(per_page: 20, page: params[:page])
+          self.collection = filterer.filter
+          self.collection = collection.paginate(per_page: 50, page: params[:page])
           self.collection = Tenon::PaginatingDecorator.decorate(collection)
+          respond_with(
+            collection,
+            serializer: Tenon::PaginatingSerializer,
+            each_serializer: ActiveModel::Serializer.serializer_for(klass.new),
+            root: 'records'
+          )
         end
       end
     end
 
     def new
+      self.resource = klass.new
+      authorize(resource)
+      before_new
       if params[:version] && resource.respond_to?(:revert)
         @item_version = Tenon::ItemVersion.find(params[:version])
         resource.revert(@item_version)
       end
-      respond_with(resource)
+
+      respond_to do |format|
+        format.html
+      end
     end
 
     def edit
+      self.resource = policy_scope(klass).find(params[:id])
+      authorize(resource)
+      before_edit
       if params[:version] && resource.respond_to?(:revert)
         @item_version = Tenon::ItemVersion.find(params[:version])
         resource.revert(@item_version)
       end
-      respond_with(resource)
+
+      respond_to do |format|
+        format.html
+      end
     end
 
     def update
-      authorize!(:publish, resource)
+      self.resource = policy_scope(klass).find(params[:id])
+      authorize(resource)
+      before_update
       if resource.update_attributes(resource_params)
         save_item_version if resource.respond_to?(:versions)
-        flash[:notice] = "#{human_name} #{t('tenon.common.saved_successfully')}." unless request.xhr?
+        flash[:notice] = "#{human_name} saved successfully." unless xhr_or_js?
       end
-
       self.resource = resource.decorate
-      respond_with(resource.decorate, location: after_update_path)
+
+      respond_to do |format|
+        format.html do
+          if resource.valid?
+            redirect_to after_update_path
+          else
+            render action: :edit
+          end
+        end
+
+        format.json do
+          if resource.valid?
+            render json: resource
+          else
+            render status: 422, json: { errors: resource.errors }
+          end
+        end
+      end
     end
 
     def create
       self.resource = klass.new(resource_params).decorate
-      authorize!(:publish, resource)
-      if resource.save && !request.xhr?
-        flash[:notice] = "#{human_name} #{t('tenon.common.saved_successfully')}."
+      authorize(resource)
+      before_create
+      if resource.save
+        flash[:notice] = "#{human_name} saved successfully." unless xhr_or_js?
         save_item_version if resource.respond_to?(:versions)
       end
-      respond_with(resource.decorate, location: after_create_path, status: (201 if resource.valid?))
+
+      respond_to do |format|
+        format.html do
+          if resource.valid?
+            redirect_to after_create_path
+          else
+            render action: :new
+          end
+        end
+
+        format.json do
+          if resource.valid?
+            render json: resource
+          else
+            render status: 422, json: { errors: resource.errors }
+          end
+        end
+      end
     end
 
     def destroy
+      self.resource = policy_scope(klass).find(params[:id])
+      authorize(resource)
+      before_destroy
       if resource.destroy
         respond_with(resource, location: polymorphic_index_path)
       else
         respond_to do |format|
           format.json do
-            render json: { errors: resource.errors }
+            render status: 422, json: { errors: resource.errors }
           end
         end
       end
     end
 
     def reorder
-      self.collection = klass.reorder!(params['item_list'])
+      authorize(klass)
+      self.collection = klass.reorder!(params[:ids])
       respond_with(collection, location: polymorphic_index_path)
     end
 
     private
 
+    # Serializer Setup Methods
+    def default_serializer_options
+      { root: 'record', scope: view_context }
+    end
+
+    # Override these to execute code after resources are loaded
+    # but before saved/acted upon
+    %w(new edit update create destroy reorder).each do |action|
+      define_method("before_#{action}") { }
+    end
+
     def save_item_version
       item_version = resource.versions.build
       item_version.attrs = resource_params
       item_version.user = current_user
       item_version.created_at = resource.updated_at
       item_version.save_type = 'post-save'
-      item_version.title = t('tenon.item_versions.post_save')
+      item_version.title = 'Post-Save'
       item_version.save
     end
 
@@ -137,18 +205,20 @@ module Tenon
       polymorphic_path([klass])
     end
 
-    def load_options
-      { except: [:index, :create] }
+    def quick_search_fields
+      ["#{klass.table_name}.title"]
     end
 
-    def search_args
-      ["#{klass.table_name}.title ILIKE ?", "%#{params[:q]}%"]
+    def filterer
+      Tenon::GenericFilterer.new(
+        policy_scope(klass),
+        params,
+        quick_search_fields
+      )
     end
 
     def resource_params
-      fail 'Define strong paramaters in controller method resource_params'
+      raise 'Define strong paramaters in controller method resource_params'
     end
-
-    helper_method :sidebar
   end
 end

data/app/controllers/tenon/simple_resources_controller.rb

@@ -1,13 +1,13 @@
 # This is for controllers that have simple forms that just use a modal
 module Tenon
   class SimpleResourcesController < Tenon::ResourcesController
-    def index
-      self.resource = klass.new
-      super
-    end
+    # def index
+    #   self.resource = klass.new
+    #   super
+    # end
 
-    def edit
-      render partial: 'form', locals: { singular_name => resource }
-    end
+    # def edit
+    #   render partial: 'form', locals: { singular_name => resource }
+    # end
   end
 end

data/app/controllers/tenon/styleguides_controller.rb

@@ -0,0 +1,10 @@
+module Tenon
+  class StyleguidesController < Tenon::BaseController
+    respond_to :html
+
+    def index
+      @context_title = 'Styleguide'
+      @mock = Tenon::Styleguide.new
+    end
+  end
+end

data/app/decorators/tenon/application_decorator.rb

@@ -2,6 +2,10 @@ module Tenon
   class ApplicationDecorator < Draper::Decorator
     delegate_all
 
+    def serializer_class
+      "#{object.class}Serializer".safe_constantize
+    end
+
     def path
       h.url_for(object)
     end
@@ -10,14 +14,6 @@ module Tenon
       h.url_for([:edit, object])
     end
 
-    def edit_link(opts = {})
-      h.edit_link(object, opts)
-    end
-
-    def delete_link(opts = {})
-      h.delete_link(object, opts)
-    end
-
     def published?
       if object.try(:publish_at)
         object.publish_at <= Time.now

data/app/decorators/tenon/asset_decorator.rb

@@ -17,31 +17,6 @@ module Tenon
       h.truncate(name, length: 50)
     end
 
-    def crop_link
-      h.action_link(
-        I18n.t('tenon.assets.crop'),
-        [:crop, object],
-        'crop',
-        class: 'asset-crop',
-        data: {
-          'asset-id' => object.id,
-          'post-crop-handler' => 'Tenon.features.AssetListPostCropHandler'
-        }
-      ) if object.attachment_content_type.include?('image') || object.attachment_content_type.include?('video')
-    end
-
-    def edit_link(opts = {})
-      defaults = {
-        'data-modal-remote' => true,
-        'data-modal-title' => I18n.t('tenon.assets.edit_asset')
-      }
-      super(opts.merge(defaults))
-    end
-
-    def download_link
-      h.action_link(I18n.t('tenon.assets.download'), object.attachment.url, 'download', target: '_')
-    end
-
     def style_urls
       styles = object.attachment.styles.map do |key, style|
         [key, object.attachment.url(key)]

data/app/filterers/tenon/generic_filterer.rb

@@ -0,0 +1,24 @@
+# Returns an <tt>ActiveRecord::Collection</tt> filtered based on the presence of
+# params[:q] and the quick_search_fields passed into the initializer
+#
+# quick_search_fields should be an array of strings including table name
+# eg. <tt>['title', 'description']</tt>
+class Tenon::GenericFilterer < Tenon::BaseFilterer
+  def initialize(scope, params, quick_search_fields)
+    @quick_search_fields = quick_search_fields
+    super(scope, params)
+  end
+
+  def filter
+    quick_search if params[:q].present?
+    scope
+  end
+
+  private
+
+  def quick_search
+    @quick_search_fields.each do |field_name|
+      @scope = scope.where("#{field_name} ILIKE ?", "%#{params[:q]}%")
+    end
+  end
+end