tenon 1.1.8 → 2.0.0

data/lib/tenon/warning_generator.rb

@@ -1,29 +0,0 @@
-module Tenon
-  class WarningGenerator
-    def self.generate(root_path)
-      new.warnings(root_path)
-    end
-
-    def warnings(root_path)
-      warnings = []
-      warnings << "Your site needs a title.<br /><br /><a class='btn btn-comp btn-block' href='#{root_path}settings'>OK</a>".html_safe if Tenon::MySettings.site_title.blank?
-      warnings << "Your site needs an address.<br /><br /><a class='btn btn-comp btn-block' href='#{root_path}settings'>OK</a>".html_safe if Tenon::MySettings.site_url.blank?
-      warnings << "You haven't entered an email address to receive contact messages.<br /><br /><a class='btn btn-comp btn-block' href='#{root_path}settings'>Correct This</a>".html_safe  if Tenon::MySettings.contact_email.blank?
-      warnings << "You haven't entered an email address from which to send contact messages and other site notices.<br /><br /><a class='btn btn-comp btn-block' href='#{root_path}settings'>Correct This</a>".html_safe  if Tenon::MySettings.from_email.blank?
-      warnings << "You haven't entered the Google Analytics code.<br /><br /><a class='btn btn-comp btn-block' href='#{root_path}settings'>Correct This</a>".html_safe if Tenon::MySettings.google_analytics.blank?
-      warnings << 'You have not included a custom favicon.' unless favicon && favicon.size > 0
-      warnings
-    end
-
-    private
-
-    def favicon
-      return @favicon if @favicon
-      begin
-        @favicon = File.read(File.join(Rails.root, 'public', 'favicon.ico'))
-      rescue Errno::ENOENT
-        @favicon = nil
-      end
-    end
-  end
-end

data/spec/controllers/tenon/assets_controller_spec.rb

@@ -1,262 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::AssetsController do
-  routes { Tenon::Engine.routes }
-
-  let(:asset) { double.as_null_object }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-
-  before do
-    controller.stub(:current_user) { user }
-    controller.stub(:polymorphic_index_path) { '/tenon/asset-library' }
-  end
-
-  describe 'GET index.html' do
-    it 'should render the index template' do
-      get :index, format: 'html'
-      expect(response).to render_template('index')
-    end
-  end
-
-  describe 'GET index.json' do
-    before do
-      [:all, :where, :with_type, :paginate].each do |query|
-        Tenon::Asset.stub(query) { Tenon::Asset }
-      end
-    end
-
-    context 'without params[:q] and without params[:type]' do
-      it 'should find, paginate, and decorate the Assets' do
-        expect(Tenon::Asset).to receive(:all) { Tenon::Asset }
-        expect(Tenon::Asset).to receive(:paginate) { Tenon::Asset }
-        expect(Tenon::PaginatingDecorator).to receive(:decorate).with(Tenon::Asset)
-        get :index, format: 'json'
-      end
-
-      it "shouldn't search or sort the assets by type" do
-        expect(Tenon::Asset).not_to receive(:where)
-        expect(Tenon::Asset).not_to receive(:with_type)
-        get :index, format: 'json'
-      end
-    end
-
-    context 'with params[:q] = "search"' do
-      it 'should search the assets with the query' do
-        args = [
-          'attachment_file_name ILIKE :q OR title ILIKE :q',
-          { q: '%search%' }
-        ]
-        expect(Tenon::Asset).to receive(:where).with(args)
-        get :index, format: 'json', q: 'search'
-      end
-
-      it 'should not sort the assets by type' do
-        expect(Tenon::Asset).not_to receive(:with_type)
-        get :index, format: 'json', q: 'search'
-      end
-    end
-
-    context 'with params[:type] = "images"' do
-      it 'should search the assets with the type' do
-        expect(Tenon::Asset).to receive(:with_type).with('images')
-        get :index, format: 'json', type: 'images'
-      end
-
-      it 'should not search the assets by type' do
-        expect(Tenon::Asset).not_to receive(:where)
-        get :index, format: 'json', type: 'images'
-      end
-    end
-
-    context 'with params[:q] = "search" and params[:type] = "images"' do
-      it 'should search the assets and sort them by type' do
-        args = [
-          'attachment_file_name ILIKE :q OR title ILIKE :q',
-          { q: '%search%' }
-        ]
-        expect(Tenon::Asset).to receive(:where).with(args)
-        expect(Tenon::Asset).to receive(:with_type).with('images')
-        get :index, format: 'json', type: 'images', q: 'search'
-      end
-    end
-  end
-
-  describe 'GET edit' do
-    before do
-      Tenon::Asset.stub(:find)
-    end
-
-    it 'should not render the layout' do
-      get :edit, id: 1
-      expect(response).to render_template(layout: false)
-    end
-  end
-
-  describe 'GET crop' do
-    before do
-      Tenon::Asset.stub(:find)
-    end
-
-    it 'should not render the layout' do
-      get :crop, id: 1
-      expect(response).to render_template(layout: false)
-    end
-  end
-
-  describe 'POST create' do
-    let(:params) { { 'test' => 'test' } }
-    it 'should instantiate an Asset' do
-      expect(Tenon::Asset).to receive(:new).with(params) { double.as_null_object }
-      post :create, asset: params
-    end
-
-    it 'should attempt to save it' do
-      Tenon::Asset.stub(:new) { asset }
-      expect(asset).to receive(:save)
-      post :create, asset: params
-    end
-
-    context 'with a valid Asset' do
-      before do
-        Tenon::Asset.stub(:new) { asset }
-        asset.stub(:save) { true }
-      end
-
-      it 'should set flash[:notice]' do
-        post :create, asset: params
-        expect(controller.flash[:notice]).not_to be_nil
-      end
-
-      it "should redirect to '/tenon/asset-library'" do
-        post :create, asset: params
-        expect(response).to redirect_to '/tenon/asset-library'
-      end
-    end
-
-    context 'with an invalid Asset' do
-      before do
-        Tenon::Asset.stub(:new) { asset }
-        asset.stub(:save) { false }
-        asset.stub(:errors) { { anything: 'will do' } }
-      end
-
-      it 'should not set flash[:notice]' do
-        post :create, asset: params, format: 'json'
-        expect(controller.flash[:notice]).to be_nil
-      end
-
-      it 'should render the errors' do
-        post :create, asset: params, format: 'json'
-        expect(JSON.parse(response.body).keys).to include('errors')
-      end
-    end
-  end
-
-  describe 'PATCH update' do
-    before do
-      Tenon::Asset.stub(:find) { double.as_null_object }
-    end
-
-    it 'should find an asset' do
-      expect(Tenon::Asset).to receive(:find).with('1')
-      patch :update, asset: { test: 'test' }, id: 1
-    end
-
-    context 'when creating a duplicate' do
-      let(:existing_asset) { double(attachment: 'test') }
-      let(:new_asset) { double(:cropping? => false).as_null_object }
-      let(:params) { { 'test' => 'test', 'duplicate' => '1' } }
-
-      before do
-        Tenon::Asset.stub(:find) { existing_asset }
-        Tenon::Asset.stub(:new) { new_asset }
-      end
-
-      it 'should create a new asset' do
-        expect(Tenon::Asset).to receive(:new).with(params)
-        patch :update, asset: params, id: 1
-      end
-
-      it "should copy the existing asset's attachment to the new asset" do
-        expect(new_asset).to receive(:attachment=).with(existing_asset.attachment)
-        patch :update, asset: params, id: 1
-      end
-
-      it 'should save and reset the crop field on the new asset' do
-        expect(new_asset).to receive(:save)
-        expect(new_asset).to receive(:crop_x=) { nil }
-        patch :update, asset: params, id: 1
-      end
-
-      it 'should not be reprocessed again' do
-        attachment = double
-        new_asset.stub(:attachment) { attachment }
-        expect(attachment).not_to receive(:reprocess!)
-        patch :update, asset: params, id: 1
-      end
-
-      it 'should be decorated' do
-        expect(new_asset).to receive(:decorate)
-        patch :update, asset: params, id: 1
-      end
-
-      it 'should render success' do
-        patch :update, asset: params, id: 1, format: 'json'
-        expect(response).to be_success
-      end
-    end
-
-    context 'when not creating a duplicate' do
-      let(:existing_asset) do
-        double(attachment: 'test', :cropping? => cropping).as_null_object
-      end
-      let(:params) { { 'test' => 'test' } }
-      let(:cropping) { nil }
-
-      before do
-        Tenon::Asset.stub(:find) { existing_asset }
-      end
-
-      it 'should attempt to update the attributes' do
-        expect(existing_asset).to receive(:update_attributes).with(params)
-        patch :update, asset: params, id: 1
-      end
-
-      it 'should decorate the asset' do
-        expect(existing_asset).to receive(:decorate)
-        patch :update, asset: params, id: 1
-      end
-
-      it 'should render success' do
-        patch :update, asset: params, id: 1, format: 'json'
-        expect(response).to be_success
-      end
-
-      context 'when not cropping' do
-        it 'should not reprocess the asset' do
-          attachment = double
-          existing_asset.stub(:attachment) { attachment }
-          expect(attachment).not_to receive(:reprocess!)
-          patch :update, asset: params, id: 1
-        end
-      end
-
-      context 'when cropping' do
-        let(:cropping) { true }
-        it 'should reprocess the asset' do
-          attachment = double
-          existing_asset.stub(:attachment) { attachment }
-          expect(attachment).to receive(:reprocess!)
-          patch :update, asset: params, id: 1
-        end
-      end
-    end
-  end
-end

data/spec/controllers/tenon/comments_controller_spec.rb

@@ -1,173 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::CommentsController do
-  routes { Tenon::Engine.routes }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-
-  let(:comment) { double.as_null_object }
-
-  before do
-    controller.stub(:current_user) { user }
-    controller.stub(:polymorphic_index_path) { '/tenon/comments' }
-
-  end
-
-  describe 'GET index.html' do
-    it 'should get the comment counts' do
-      expect(Tenon::Comment).to receive(:count) { [] }
-      expect(Tenon::Comment).to receive(:approved) { [] }
-      expect(Tenon::Comment).to receive(:unapproved) { [] }
-      get :index, format: 'html'
-    end
-
-    it 'should assign the comment counts' do
-      get :index, format: 'html'
-      expect(assigns[:counts]).not_to be_nil
-    end
-  end
-
-  describe 'GET index.json' do
-    before do
-      [:all, :where, :approved, :unapproved, :paginate].each do |query|
-        Tenon::Comment.stub(query) { Tenon::Comment }
-      end
-    end
-
-    context 'without params[:q] and without params[:type]' do
-      it 'should find and paginate, and decorate the Comments' do
-        expect(Tenon::Comment).to receive(:all) { Tenon::Comment }
-        expect(Tenon::Comment).to receive(:paginate) { Tenon::Comment }
-        expect(Tenon::PaginatingDecorator).to receive(:decorate).with(Tenon::Comment)
-        get :index, format: 'json'
-      end
-
-      it "shouldn't search or sort the comments by type" do
-        expect(Tenon::Comment).not_to receive(:where)
-        expect(Tenon::Comment).not_to receive(:approved)
-        expect(Tenon::Comment).not_to receive(:unapproved)
-        get :index, format: 'json'
-      end
-    end
-
-    context 'with params[:q] = "search"' do
-      it 'should search the comments with the query' do
-        args = [
-          'author ILIKE :q OR author_url ILIKE :q OR author_email ILIKE :q OR content ILIKE :q OR user_ip ILIKE :q',
-          { q: '%search%' }
-        ]
-        expect(Tenon::Comment).to receive(:all) { Tenon::Comment }
-        expect(Tenon::Comment).to receive(:where).with(args) { Tenon::Comment }
-        get :index, format: 'json', q: 'search'
-      end
-
-      it 'should not sort the comments by type' do
-        expect(Tenon::Comment).not_to receive(:with_type)
-        get :index, format: 'json', q: 'search'
-      end
-    end
-
-    %w(approved unapproved).each do |type|
-      context "with params[:type] = #{type}" do
-        it 'should search the comments with the type' do
-          expect(Tenon::Comment).to receive(type)
-          get :index, format: 'json', type: type
-        end
-
-        it 'should not search the comments by type' do
-          expect(Tenon::Comment).not_to receive(:where)
-          get :index, format: 'json', type: 'images'
-        end
-      end
-
-      context "with params[:q] = 'search' and params[:type] = '#{type}'" do
-        it 'should search the comments and sort them by type' do
-          args = [
-            'author ILIKE :q OR author_url ILIKE :q OR author_email ILIKE :q OR content ILIKE :q OR user_ip ILIKE :q',
-            { q: '%search%' }
-          ]
-          expect(Tenon::Comment).to receive(:where).with(args)
-          expect(Tenon::Comment).to receive(type)
-          get :index, format: 'json', type: type, q: 'search'
-        end
-      end
-    end
-  end
-
-  %w(toggle_approved).each do |action|
-    describe "GET #{action}.json" do
-      let(:comment) { double }
-      before { Tenon::Comment.stub(:find) { comment } }
-
-      context 'when successful' do
-        before do
-          comment.stub("#{action}!") { true }
-        end
-
-        it 'should render the comment to json' do
-          get action, id: 1, format: 'json'
-          expect(response.body).to eq double.to_json
-        end
-
-        it 'should be successful' do
-          get action, id: 1, format: 'json'
-          expect(response).to be_success
-        end
-      end
-
-      context 'when not successful' do
-        before do
-          comment.stub("#{action}!") { false }
-        end
-
-        it 'should return an error' do
-          get action, id: 1, format: 'json'
-          expect(response).not_to be_success
-        end
-      end
-    end
-
-    describe "GET #{action}.html" do
-      let(:comment) { double }
-      before { Tenon::Comment.stub(:find) { comment } }
-
-      context 'when successful' do
-        before do
-          comment.stub("#{action}!") { true }
-        end
-
-        it 'should set the flash[:notice]' do
-          get action, id: 1, format: 'html'
-          expect(controller.flash[:notice]).not_to be_blank
-        end
-
-        it 'should redirect to index' do
-          get action, id: 1, format: 'html'
-          expect(response).to redirect_to '/tenon/comments'
-        end
-      end
-
-      context 'when not successful' do
-        before do
-          comment.stub("#{action}!") { false }
-        end
-
-        it 'should set the flash[:warning]' do
-          get action, id: 1, format: 'html'
-          expect(controller.flash[:warning]).not_to be_blank
-        end
-
-        it 'should redirect to index' do
-          get action, id: 1, format: 'html'
-          expect(response).to redirect_to '/tenon/comments'
-        end
-      end
-    end
-  end
-end

data/spec/controllers/tenon/contacts_controller_spec.rb

@@ -1,174 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::ContactsController do
-  routes { Tenon::Engine.routes }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-
-  let(:contact) { double.as_null_object }
-
-  before do
-    controller.stub(:current_user) { user }
-    controller.stub(:polymorphic_index_path) { '/tenon/contacts' }
-  end
-
-  describe 'GET index.html' do
-    it 'should get the contact counts' do
-      expect(Tenon::Contact).to receive(:count) { [] }
-      expect(Tenon::Contact).to receive(:read) { [] }
-      expect(Tenon::Contact).to receive(:unread) { [] }
-      expect(Tenon::Contact).to receive(:replied) { [] }
-      expect(Tenon::Contact).to receive(:unreplied) { [] }
-      get :index, format: 'html'
-    end
-
-    it 'should assign the contact counts' do
-      get :index, format: 'html'
-      expect(assigns[:counts]).not_to be_nil
-    end
-  end
-
-  describe 'GET index.json' do
-    before do
-      [:all, :where, :approved, :unapproved, :paginate].each do |query|
-        Tenon::Contact.stub(query) { Tenon::Contact }
-      end
-    end
-
-    context 'without params[:q] and without params[:type]' do
-      it 'should find and paginate, and decorate the Comments' do
-        expect(Tenon::Contact).to receive(:all) { Tenon::Contact }
-        expect(Tenon::Contact).to receive(:paginate) { Tenon::Contact }
-        expect(Tenon::PaginatingDecorator).to receive(:decorate).with(Tenon::Contact)
-        get :index, format: 'json'
-      end
-
-      it "shouldn't search or sort the contacts by type" do
-        expect(Tenon::Contact).not_to receive(:where)
-        expect(Tenon::Contact).not_to receive(:approved)
-        expect(Tenon::Contact).not_to receive(:unapproved)
-        get :index, format: 'json'
-      end
-    end
-
-    context 'with params[:q] = "search"' do
-      it 'should search the contacts with the query' do
-        args = [
-          'name ILIKE :q OR email ILIKE :q OR phone ILIKE :q OR content ILIKE :q OR user_ip ILIKE :q',
-          { q: '%search%' }
-        ]
-        expect(Tenon::Contact).to receive(:all) { Tenon::Contact }
-        expect(Tenon::Contact).to receive(:where).with(args) { Tenon::Contact }
-        get :index, format: 'json', q: 'search'
-      end
-
-      it 'should not sort the contacts by type' do
-        expect(Tenon::Contact).not_to receive(:with_type)
-        get :index, format: 'json', q: 'search'
-      end
-    end
-
-    %w(read unread replied unreplied).each do |type|
-      context "with params[:type] = #{type}" do
-        it 'should search the contacts with the type' do
-          expect(Tenon::Contact).to receive(type) { Tenon::Contact }
-          get :index, format: 'json', type: type
-        end
-
-        it 'should not search the contacts by type' do
-          expect(Tenon::Contact).not_to receive(:where)
-          get :index, format: 'json', type: 'images'
-        end
-      end
-
-      context "with params[:q] = 'search' and params[:type] = '#{type}'" do
-        it 'should search the contacts and sort them by type' do
-          args = [
-            'name ILIKE :q OR email ILIKE :q OR phone ILIKE :q OR content ILIKE :q OR user_ip ILIKE :q',
-            { q: '%search%' }
-          ]
-          expect(Tenon::Contact).to receive(:where).with(args) { Tenon::Contact }
-          expect(Tenon::Contact).to receive(type) { Tenon::Contact }
-          get :index, format: 'json', type: type, q: 'search'
-        end
-      end
-    end
-  end
-
-  %w(toggle_read toggle_replied).each do |action|
-    describe "GET #{action}.json" do
-      let(:contact) { double }
-      before { Tenon::Contact.stub(:find) { contact } }
-
-      context 'when successful' do
-        before do
-          contact.stub("#{action}!") { true }
-        end
-
-        it 'should render the contact to json' do
-          get action, id: 1, format: 'json'
-          expect(response.body).to eq double.to_json
-        end
-
-        it 'should be successful' do
-          get action, id: 1, format: 'json'
-          expect(response).to be_success
-        end
-      end
-
-      context 'when not successful' do
-        before do
-          contact.stub("#{action}!") { false }
-        end
-
-        it 'should return an error' do
-          get action, id: 1, format: 'json'
-          expect(response).not_to be_success
-        end
-      end
-    end
-
-    describe "GET #{action}.html" do
-      let(:contact) { double }
-      before { Tenon::Contact.stub(:find) { contact } }
-
-      context 'when successful' do
-        before do
-          contact.stub("#{action}!") { true }
-        end
-
-        it 'should set the flash[:notice]' do
-          get action, id: 1, format: 'html'
-          expect(controller.flash[:notice]).not_to be_blank
-        end
-
-        it 'should redirect to index' do
-          get action, id: 1, format: 'html'
-          expect(response).to redirect_to '/tenon/contacts'
-        end
-      end
-
-      context 'when not successful' do
-        before do
-          contact.stub("#{action}!") { false }
-        end
-
-        it 'should set the flash[:warning]' do
-          get action, id: 1, format: 'html'
-          expect(controller.flash[:warning]).not_to be_blank
-        end
-
-        it 'should redirect to index' do
-          get action, id: 1, format: 'html'
-          expect(response).to redirect_to '/tenon/contacts'
-        end
-      end
-    end
-  end
-end

data/spec/controllers/tenon/index_controller_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::IndexController do
-  routes { Tenon::Engine.routes }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-  let(:generator) { double(generate: 'test') }
-
-  before do
-    controller.stub(:current_user) { user }
-    stub_const('Tenon::WarningGenerator', generator)
-  end
-
-  describe 'GET index' do
-    it 'should assign the warnings from the Tenon::WarningGenerator' do
-      get :index
-      expect(assigns[:warnings]).to eq Tenon::WarningGenerator.generate
-    end
-
-    it 'should assign the callouts' do
-      get :index
-      expect(assigns[:tenon_callouts]).to eq Tenon::TenonCallout.published
-    end
-  end
-end

data/spec/controllers/tenon/item_assets_controller_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::ItemAssetsController do
-  routes { Tenon::Engine.routes }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-
-  before do
-    controller.stub(:current_user) { user }
-  end
-
-  describe 'GET new' do
-    it 'should assign @multiple to params[:multiple]' do
-      get :new, multiple: '1'
-      expect(assigns[:multiple]).to eq('1')
-    end
-
-    it 'should not render a layout' do
-      get :new
-      expect(response).to render_template(layout: false)
-    end
-  end
-end