landable 1.13.1 → 1.13.2

data/lib/tasks/landable/data.rake

@@ -5,26 +5,26 @@ include SchemaMoves::Helpers
 
 namespace :landable do
   namespace :data do
-    desc "Clean & restore database from specified source"
-    task :restore => [ 'db:drop', 'db:create', 'db:migrate', 'dump_and_load' ]
+    desc 'Clean & restore database from specified source'
+    task restore: ['db:drop', 'db:create', 'db:migrate', 'dump_and_load']
 
     desc 'Restore database from specified source'
     task dump_and_load: :environment do
-       STDOUT.puts 'Enter Remote DB Host'
-       host = STDIN.gets.strip
+      STDOUT.puts 'Enter Remote DB Host'
+      host = STDIN.gets.strip
 
-       STDOUT.puts 'Enter Remote Database'
-       database = STDIN.gets.strip
+      STDOUT.puts 'Enter Remote Database'
+      database = STDIN.gets.strip
 
-       STDOUT.puts 'Enter Remote Username'
-       username = STDIN.gets.strip
+      STDOUT.puts 'Enter Remote Username'
+      username = STDIN.gets.strip
 
-       `pg_dump -h #{host} -U #{username} --data-only --format plain --schema landable #{database} > landable_import.sql`
-       `psql #{Rails.configuration.database_configuration[Rails.env]["database"]} -f landable_import.sql`
-       `rm landable_import.sql`
+      `pg_dump -h #{host} -U #{username} --data-only --format plain --schema landable #{database} > landable_import.sql`
+      `psql #{Rails.configuration.database_configuration[Rails.env]['database']} -f landable_import.sql`
+      `rm landable_import.sql`
     end
 
-    desc "Migrates all to new schema"
+    desc 'Migrates all to new schema'
     task move_schemas: :environment do
       get_schema_names
       create_schemas
@@ -32,11 +32,10 @@ namespace :landable do
       drop_old_schemas if want_to_drop_old_schemas?
     end
 
-    desc "Drop the old schemas"
+    desc 'Drop the old schemas'
     task drop_schemas: :environment do
       get_schema_names false
       drop_old_schemas if want_to_drop_old_schemas?
     end
-
   end
 end

data/lib/tasks/landable/pgtap.rake

@@ -1,35 +1,29 @@
 namespace :landable do
   namespace :pgtap do
-    def has_pgprove?
-      @@has_prove ||= Kernel.system('which pg_prove > /dev/null')
+    def pgprove?
+      @has_prove ||= Kernel.system('which pg_prove > /dev/null')
     end
 
-    def has_pgconfig?
-      @@has_pgconfig ||= Kernel.system('which pg_config > /dev/null')
+    def pgconfig?
+      @has_pgconfig ||= Kernel.system('which pg_config > /dev/null')
     end
 
-    def has_pgtap?
+    def pgtap?
       has_pgtap = false
 
-      if has_pgconfig?
+      if pgconfig?
         sharedir = "#{`pg_config | grep SHAREDIR | awk {' print $3 '}`.strip}/extension/pgtap.control"
-        if File.file?("#{sharedir}")
-          has_pgtap = true
-        end
+        has_pgtap = true if File.file?("#{sharedir}")
       end
 
       has_pgtap
     end
 
-    desc "Run PGTap unit tests"
-    task :run, [:test_file] => [ :environment ] do |t, args|
-      dbdir = "#{Rails.root}/../../db"
-
-      tests = args[:test_file] ? args[:test_file] : "*.sql"
-
-      if has_pgprove? and has_pgtap?
+    desc 'Run PGTap unit tests'
+    task :run, [:test_file] => [:environment] do |_t, _args|
+      if pgprove? && pgtap?
         # Load pgtap functions into database.  Will not complain if already loaded.
-        ActiveRecord::Base.connection.execute("CREATE EXTENSION IF NOT EXISTS pgtap;")
+        ActiveRecord::Base.connection.execute('CREATE EXTENSION IF NOT EXISTS pgtap;')
 
         # Runs the tests.  Wrapped pg_prove call in shell script due to issues with return values
         sh "cd #{Rails.root}/../../script && ./pgtap"
@@ -40,5 +34,5 @@ namespace :landable do
     end
   end
 
-  task :pgtap => 'pgtap:run'
+  task pgtap: 'pgtap:run'
 end

data/lib/tasks/landable/seed.rake

@@ -1,16 +1,16 @@
 namespace :landable do
   namespace :seed do
     desc 'Seed extra data (starter themes)'
-    task :extras => :environment do
+    task extras: :environment do
       Landable::Seeds.seed(:extras)
     end
 
     desc 'Seed required data (categories)'
-    task :required => :environment do
+    task required: :environment do
       Landable::Seeds.seed(:required)
     end
   end
 
   desc 'Seed required and extra data'
-  task :seed => ['seed:required', 'seed:extras']
-end
+  task seed: ['seed:required', 'seed:extras']
+end

data/spec/concerns/landable/has_assets_spec.rb

@@ -2,39 +2,36 @@ require 'spec_helper'
 
 module Landable
   describe HasAssets do
-
     before(:each) { create_list :asset, 4 }
 
     let(:assets) { Landable::Asset.first(3) }
-    let(:subject) {
-      build :page, {
-        body: "
+    let(:subject) do
+      build :page, body: "
           <div>{% img_tag #{assets[0].name} %}</div>
           <div>{% asset_url #{assets[1].name} %}</div>
           <div>{% asset_description #{assets[2].name} %}</div>
           <div>{% img_tag #{assets[0].name} %}</div>
         "
-      }
-    }
+    end
 
     describe '#assets' do
       it 'should return assets matching #asset_names' do
-        result = double()
-        subject.should_receive(:asset_names) { ['one', 'two', 'three'] }
-        Landable::Asset.should_receive(:where).with(name: ['one', 'two', 'three']) { result }
-        subject.assets.should == result
+        result = double
+        subject.should_receive(:asset_names) { %w(one two three) }
+        Landable::Asset.should_receive(:where).with(name: %w(one two three)) { result }
+        subject.assets.should eq result
       end
     end
 
     describe '#asset_names' do
       it 'should pull asset names out of the body' do
-        subject.asset_names.sort.should == assets.map(&:name).uniq.sort
+        subject.asset_names.sort.should eq assets.map(&:name).uniq.sort
       end
     end
 
     describe '#save_assets!' do
       it 'should save the assets' do
-        assets_double = double()
+        assets_double = double
         subject.should_receive(:assets) { assets_double }
         subject.should_receive(:assets=).with(assets_double)
         subject.save_assets!
@@ -49,7 +46,7 @@ module Landable
     describe '#assets_as_hash' do
       it 'should return a hash of asset names to asset instances' do
         subject.save!
-        subject.assets_as_hash.should == Hash[assets.map { |asset| [asset.name, asset] }]
+        subject.assets_as_hash.should eq Hash[assets.map { |asset| [asset.name, asset] }]
       end
     end
 
@@ -57,19 +54,18 @@ module Landable
       it 'should reset the asset_names cache, then set the body' do
         subject.instance_eval { @asset_names = 'foo' }
         subject.body = 'bar'
-        subject.body.should == 'bar'
+        subject.body.should eq 'bar'
         subject.instance_eval { @asset_names }.should be_nil
-        subject.asset_names.should == []
+        subject.asset_names.should eq []
       end
     end
 
     describe '#assets_join_table_name' do
       it 'should generate the correct join_table, and then apologize for doing so' do
-        Page.send(:assets_join_table_name).should == "#{Landable.configuration.database_schema_prefix}landable.page_assets"
-        PageRevision.send(:assets_join_table_name).should == "#{Landable.configuration.database_schema_prefix}landable.page_revision_assets"
-        Theme.send(:assets_join_table_name).should == "#{Landable.configuration.database_schema_prefix}landable.theme_assets"
+        Page.send(:assets_join_table_name).should eq "#{Landable.configuration.database_schema_prefix}landable.page_assets"
+        PageRevision.send(:assets_join_table_name).should eq "#{Landable.configuration.database_schema_prefix}landable.page_revision_assets"
+        Theme.send(:assets_join_table_name).should eq "#{Landable.configuration.database_schema_prefix}landable.theme_assets"
       end
     end
-
   end
 end

data/spec/concerns/landable/has_templates_spec.rb

@@ -2,39 +2,36 @@ require 'spec_helper'
 
 module Landable
   describe HasTemplates do
-
-    before(:each) do 
+    before(:each) do
       create_list :template, 2
       create :template, slug: 'I have a space'
     end
 
     let(:templates) { Landable::Template.last(3) }
-    let(:subject) {
-      build :page, {
-        body: "
+    let(:subject) do
+      build :page, body: "
           <div>{% template #{templates[0].slug} %}</div>
           <div>{% template #{templates[1].slug} %}</div>
           <div>{% template #{templates[2].slug} %}</div>
         "
-      }
-    }
+    end
 
     describe '#templates' do
       it 'should return templates' do
         slugs = [templates[0].slug, templates[1].slug, templates[2].slug]
-        subject.templates.should == Landable::Template.where(slug: slugs)
+        subject.templates.should eq Landable::Template.where(slug: slugs)
       end
     end
 
     describe '#template_names' do
       it 'should pull template slugs out of the body' do
-        subject.template_names.sort.should == templates.map(&:slug).uniq.sort
+        subject.template_names.sort.should eq templates.map(&:slug).uniq.sort
       end
     end
 
     describe '#save_templates!' do
       it 'should save the templates' do
-        assets_double = double()
+        assets_double = double
         subject.should_receive(:templates) { assets_double }
         subject.should_receive(:templates=).with(assets_double)
         subject.save_templates!
@@ -50,15 +47,15 @@ module Landable
       it 'should reset the template_slug cache, then set the body' do
         subject.instance_eval { @template_slug = 'foo' }
         subject.body = 'bar'
-        subject.body.should == 'bar'
+        subject.body.should eq 'bar'
         subject.instance_eval { @template_slug }.should be_nil
-        subject.templates.should == []
+        subject.templates.should eq []
       end
     end
 
     describe '#templates_join_table_name' do
       it 'should generate the correct join_table, and then apologize for doing so' do
-        Page.send(:templates_join_table_name).should == "#{Landable.configuration.database_schema_prefix}landable.page_templates"
+        Page.send(:templates_join_table_name).should eq "#{Landable.configuration.database_schema_prefix}landable.page_templates"
       end
     end
   end

data/spec/concerns/landable/librarian.rb

@@ -9,21 +9,21 @@ module Landable
     end
 
     # tests
-    it "should soft delete a content managed Item" do
+    it 'should soft delete a content managed Item' do
       # setup
       current_page = Page.find(@page.id)
-      
+
       # actions
       current_page.deactivate
 
       # expectations
       expect(current_page).to be_a Page
       expect(current_page.deleted_at).to_not be_blank
-      
+
       # end
     end
 
-    it "should restore a content managed Item" do
+    it 'should restore a content managed Item' do
       # setup
       Page.find(@page.id).deactivate
       restored_page = Page.find(@page.id)

data/spec/concerns/landable/table_name_spec.rb

@@ -2,14 +2,12 @@ require 'spec_helper'
 
 module Landable
   describe TableName do
-
     describe '#table_name' do
       it 'should generate the correct table name' do
-        Page.send(:table_name).should == "#{Landable.configuration.database_schema_prefix}landable.pages"
-        PageRevision.send(:table_name).should == "#{Landable.configuration.database_schema_prefix}landable.page_revisions"
-        Theme.send(:table_name).should == "#{Landable.configuration.database_schema_prefix}landable.themes"
+        Page.send(:table_name).should eq "#{Landable.configuration.database_schema_prefix}landable.pages"
+        PageRevision.send(:table_name).should eq "#{Landable.configuration.database_schema_prefix}landable.page_revisions"
+        Theme.send(:table_name).should eq "#{Landable.configuration.database_schema_prefix}landable.themes"
       end
     end
-
   end
 end

data/spec/concerns/landable/traffic/table_name_spec.rb

@@ -3,14 +3,12 @@ require 'spec_helper'
 module Landable
   module Traffic
     describe TableName do
-
       describe '#table_name' do
         it 'should generate the correct table name' do
-          Visit.send(:table_name).should == "#{Landable.configuration.database_schema_prefix}landable_traffic.visits"
-          PageView.send(:table_name).should == "#{Landable.configuration.database_schema_prefix}landable_traffic.page_views"
+          Visit.send(:table_name).should eq "#{Landable.configuration.database_schema_prefix}landable_traffic.visits"
+          PageView.send(:table_name).should eq "#{Landable.configuration.database_schema_prefix}landable_traffic.page_views"
         end
       end
-
     end
   end
 end

data/spec/controllers/concerns/landable/variables_concern_spec.rb

@@ -6,12 +6,13 @@ module Landable
     # setup
     controller(ApplicationController) do
       protected
+
         def hello_world
-          "i live in a giant bucket."
+          'i live in a giant bucket.'
         end
 
         def hello_cleveland
-          "i am a banana."
+          'i am a banana.'
         end
     end
 
@@ -27,7 +28,7 @@ module Landable
     end
 
     # tests
-    it "should include the VariablesConcern module" do
+    it 'should include the VariablesConcern module' do
       # setup
       # actions
       # expectations
@@ -35,27 +36,27 @@ module Landable
       # end
     end
 
-    it "should use the #register_landable_variable with a similarly named method" do
+    it 'should use the #register_landable_variable with a similarly named method' do
       # setup
       # actions
       # expectations
-      expect(controller.fetch_landable_variables[:hello_world]).to eql("i live in a giant bucket.")
+      expect(controller.fetch_landable_variables[:hello_world]).to eql('i live in a giant bucket.')
       # end
     end
 
-    it "should use the #register_landable_variable with a custom named method" do
+    it 'should use the #register_landable_variable with a custom named method' do
       # setup
       # actions
       # expectations
-      expect(controller.fetch_landable_variables[:is_rejected]).to eql("i am a banana.")
+      expect(controller.fetch_landable_variables[:is_rejected]).to eql('i am a banana.')
       # end
     end
 
-    it "should use the #register_landable_variable with a string-based name" do
+    it 'should use the #register_landable_variable with a string-based name' do
       # setup
       # actions
       # expectations
-      expect(controller.fetch_landable_variables['is_rejected']).to eql("i am a banana.")
+      expect(controller.fetch_landable_variables['is_rejected']).to eql('i am a banana.')
       # end
     end
 
@@ -63,4 +64,4 @@ module Landable
   end
 
   # end
-end
+end

data/spec/controllers/landable/api/assets_controller_spec.rb

@@ -1,24 +1,25 @@
 require 'spec_helper'
 
-module Landable::Api
-  describe AssetsController, json: true do
-    routes { Landable::Engine.routes }
+module Landable
+  module Api
+    describe AssetsController, json: true do
+      routes { Landable::Engine.routes }
 
-    describe '#update' do
-      include_examples 'Authenticated API controller', :make_request
+      describe '#update' do
+        include_examples 'Authenticated API controller', :make_request
 
-      let(:asset) { create :asset, description: "Not updated" }
+        let(:asset) { create :asset, description: 'Not updated' }
 
-      def make_request
-        put :update, id: asset.id, asset: { description: "Updated" }
-      end
+        def make_request
+          put :update, id: asset.id, asset: { description: 'Updated' }
+        end
 
-      it "updates the asset description" do
-        make_request
-        asset.reload
-        asset.description.should == "Updated"
+        it 'updates the asset description' do
+          make_request
+          asset.reload
+          asset.description.should eq 'Updated'
+        end
       end
     end
   end
-
 end

data/spec/controllers/landable/api/audits_controller_spec.rb

@@ -1,147 +1,149 @@
 require 'spec_helper'
 
-module Landable::Api
-  describe AuditsController, json: true do
-    routes { Landable::Engine.routes }
+module Landable
+  module Api
+    describe AuditsController, json: true do
+      routes { Landable::Engine.routes }
 
-    let(:page)     { create :page }
-    let(:template) { create :template }
+      let(:page)     { create :page }
+      let(:template) { create :template }
 
-    describe '#index' do
-      context 'all' do
-        include_examples 'Authenticated API controller', :make_request
-
-        let(:audits) { create_list :audit, 3 }
-
-        def make_request(params = {})
-          get :index
-        end
-
-        it 'renders audits as json' do
-          make_request
-          last_json['audits'].collect { |p| p['id'] }.sort.should == Landable::Audit.all.map(&:id).sort
-        end
-      end
-
-      context 'tempalte audits' do
-        include_examples 'Authenticated API controller', :make_request
+      describe '#index' do
+        context 'all' do
+          include_examples 'Authenticated API controller', :make_request
 
-        let(:audits) { create_list :audit, 3, auditable_id: template.id, auditable_type: 'Landable::Template', approver: 'ME!!!' }
+          let(:audits) { create_list :audit, 3 }
 
-        def make_request(params = {})
-          get :index, auditable_id: template.id
-        end
+          def make_request(_params = {})
+            get :index
+          end
 
-        it 'renders audits as json' do
-          make_request
-          last_json['audits'].collect { |p| p['id'] }.sort.should == Landable::Audit.all.map(&:id).sort
+          it 'renders audits as json' do
+            make_request
+            last_json['audits'].collect { |p| p['id'] }.sort.should eq Landable::Audit.all.map(&:id).sort
+          end
         end
-      end
 
-      context 'page audits' do
-        include_examples 'Authenticated API controller', :make_request
+        context 'tempalte audits' do
+          include_examples 'Authenticated API controller', :make_request
 
-        let(:audits) { create_list :audit, 3, auditable_id: page.id, auditable_type: 'Landable::Page', approver: 'ME!!!' }
+          let(:audits) { create_list :audit, 3, auditable_id: template.id, auditable_type: 'Landable::Template', approver: 'ME!!!' }
 
-        def make_request(params = {})
-          get :index, auditable_id: page.id
-        end
+          def make_request(_params = {})
+            get :index, auditable_id: template.id
+          end
 
-        it 'renders audits as json' do
-          make_request
-          last_json['audits'].collect { |p| p['id'] }.sort.should == Landable::Audit.all.map(&:id).sort
+          it 'renders audits as json' do
+            make_request
+            last_json['audits'].collect { |p| p['id'] }.sort.should eq Landable::Audit.all.map(&:id).sort
+          end
         end
-      end
-    end
 
-    describe '#show' do
-      include_examples 'Authenticated API controller', :make_request
-      let(:audit) { create(:audit) }
+        context 'page audits' do
+          include_examples 'Authenticated API controller', :make_request
 
-      def make_request(id = audit.id)
-        get :show, id: id
-      end
+          let(:audits) { create_list :audit, 3, auditable_id: page.id, auditable_type: 'Landable::Page', approver: 'ME!!!' }
 
-      it 'renders the page as JSON' do
-        make_request
-        last_json['audit']['flags'].should == audit.flags
-      end
+          def make_request(_params = {})
+            get :index, auditable_id: page.id
+          end
 
-      context 'no such page' do
-        it 'returns 404' do
-          make_request random_uuid
-          response.status.should == 404
+          it 'renders audits as json' do
+            make_request
+            last_json['audits'].collect { |p| p['id'] }.sort.should eq Landable::Audit.all.map(&:id).sort
+          end
         end
       end
-    end
 
-    describe '#create' do
-      context 'template audit' do
+      describe '#show' do
         include_examples 'Authenticated API controller', :make_request
+        let(:audit) { create(:audit) }
 
-        let(:default_params) do
-          { audit: attributes_for(:audit).merge(auditable_id: template.id,
-                                                auditable_type: 'Landable::Template',
-                                                approver: 'Marley') }
+        def make_request(id = audit.id)
+          get :show, id: id
         end
 
-        let(:audit) do
-          Landable::Audit.where(auditable_id: default_params[:audit][:auditable_id]).first
+        it 'renders the page as JSON' do
+          make_request
+          last_json['audit']['flags'].should eq audit.flags
         end
 
-        def make_request(params = {})
-          post :create, default_params.deep_merge(audit: params, template_id: template.id)
+        context 'no such page' do
+          it 'returns 404' do
+            make_request random_uuid
+            response.status.should eq 404
+          end
         end
+      end
 
-        context 'success' do
-          it 'returns 201 Created' do
-            make_request
-            response.status.should == 201
-          end
+      describe '#create' do
+        context 'template audit' do
+          include_examples 'Authenticated API controller', :make_request
 
-          it 'returns header Location with the audit URL' do
-            make_request
-            response.headers['Location'].should == audit_url(audit)
+          let(:default_params) do
+            { audit: attributes_for(:audit).merge(auditable_id: template.id,
+                                                  auditable_type: 'Landable::Template',
+                                                  approver: 'Marley') }
           end
 
-          it 'renders the audit as JSON' do
-            make_request
-            last_json['audit']['flags'].should == audit.flags
+          let(:audit) do
+            Landable::Audit.where(auditable_id: default_params[:audit][:auditable_id]).first
           end
-        end
-      end
 
-      context 'page audit' do
-        include_examples 'Authenticated API controller', :make_request
+          def make_request(params = {})
+            post :create, default_params.deep_merge(audit: params, template_id: template.id)
+          end
 
-        let(:default_params) do
-          { audit: attributes_for(:audit).merge(auditable_id: page.id,
-                                                auditable_type: 'Landable::Page',
-                                                approver: 'Marley') }
+          context 'success' do
+            it 'returns 201 Created' do
+              make_request
+              response.status.should eq 201
+            end
+
+            it 'returns header Location with the audit URL' do
+              make_request
+              response.headers['Location'].should eq audit_url(audit)
+            end
+
+            it 'renders the audit as JSON' do
+              make_request
+              last_json['audit']['flags'].should eq audit.flags
+            end
+          end
         end
 
-        let(:audit) do
-          Landable::Audit.where(auditable_id: default_params[:audit][:auditable_id]).first
-        end
+        context 'page audit' do
+          include_examples 'Authenticated API controller', :make_request
 
-        def make_request(params = {})
-          post :create, default_params.deep_merge(page_audit: params, page_id: page.id)
-        end
+          let(:default_params) do
+            { audit: attributes_for(:audit).merge(auditable_id: page.id,
+                                                  auditable_type: 'Landable::Page',
+                                                  approver: 'Marley') }
+          end
 
-        context 'success' do
-          it 'returns 201 Created' do
-            make_request
-            response.status.should == 201
+          let(:audit) do
+            Landable::Audit.where(auditable_id: default_params[:audit][:auditable_id]).first
           end
 
-          it 'returns header Location with the audit URL' do
-            make_request
-            response.headers['Location'].should == audit_url(audit)
+          def make_request(params = {})
+            post :create, default_params.deep_merge(page_audit: params, page_id: page.id)
           end
 
-          it 'renders the audit as JSON' do
-            make_request
-            last_json['audit']['flags'].should == audit.flags
+          context 'success' do
+            it 'returns 201 Created' do
+              make_request
+              response.status.should eq 201
+            end
+
+            it 'returns header Location with the audit URL' do
+              make_request
+              response.headers['Location'].should eq audit_url(audit)
+            end
+
+            it 'renders the audit as JSON' do
+              make_request
+              last_json['audit']['flags'].should eq audit.flags
+            end
           end
         end
       end