landable 1.13.1 → 1.13.2

data/app/controllers/landable/public/preview/pages_controller.rb

@@ -1,4 +1,4 @@
-require_dependency "landable/application_controller"
+require_dependency 'landable/application_controller'
 
 module Landable
   module Public

data/app/controllers/landable/public/sitemap_controller.rb

@@ -1,4 +1,4 @@
-require_dependency "landable/application_controller"
+require_dependency 'landable/application_controller'
 
 module Landable
   module Public
@@ -8,7 +8,7 @@ module Landable
           host: Landable.configuration.sitemap_host || request.host,
           protocol: Landable.configuration.sitemap_protocol,
           exclude_categories: Landable.configuration.sitemap_exclude_categories,
-          sitemap_additional_paths: Landable.configuration.sitemap_additional_paths,
+          sitemap_additional_paths: Landable.configuration.sitemap_additional_paths
         )
 
         render xml: sitemap

data/app/decorators/landable/page_decorator.rb

@@ -3,7 +3,7 @@ module Landable
     include ActionView::Helpers::TagHelper
 
     def initialize(page)
-      raise TypeError.new("Use Landable::NullPageDecorator") if page.nil?
+      fail(TypeError, 'Use Landable::NullPageDecorator') if page.nil?
       @page = page
     end
 
@@ -30,9 +30,9 @@ module Landable
     def meta_tags
       return nil unless page.meta_tags?
 
-      page.meta_tags.map { |name, value|
+      page.meta_tags.map do |name, value|
         tag('meta', name: name, content: value) if value.present?
-      }.compact.join("\n").html_safe
+      end.compact.join("\n").html_safe
     end
 
     private

data/app/helpers/landable/pages_helper.rb

@@ -6,9 +6,9 @@ module Landable
     end
 
     def current_page
-      if params[:controller] == "landable/public/preview/page_revisions"
+      if params[:controller] == 'landable/public/preview/page_revisions'
         current_page = PageRevision.find(params[:id])
-      elsif params[:controller] == "landable/public/preview/pages"
+      elsif params[:controller] == 'landable/public/preview/pages'
         current_page = Page.find(params[:id])
       else
         current_page = Page.by_path(request.path)

data/app/helpers/landable/traffic_helper.rb

@@ -1,5 +1,7 @@
 module Landable
   module TrafficHelper
+    attr_reader :tracker
+
     def crawl_tracker
       @tracker if @tracker.is_a? Landable::Traffic::CrawlTracker
     end
@@ -23,9 +25,5 @@ module Landable
     def user_tracker
       @tracker if @tracker.is_a? Landable::Traffic::UserTracker
     end
-
-    def tracker
-      @tracker
-    end
   end
 end

data/app/models/concerns/landable/has_assets.rb

@@ -36,39 +36,36 @@ module Landable
       end
 
       # passthrough for body=; clears the asset_names cache in the process
-      def body= body_val
+      def body=(body_val)
         @asset_names = nil
         self[:body] = body_val
       end
 
       # this looks weird; I swear it works
       def save_assets!
-        self.assets = self.assets
+        self.assets = assets
       end
 
-
       private
 
-      def asset_names_for_node node, names = []
+      def asset_names_for_node(node, names = [])
         # set up a recursing function to search for asset tags
         if node.is_a? Landable::Liquid::AssetTag
           names << node.asset_name unless names.include? node.asset_name
         end
 
-        if node.respond_to? :nodelist and node.nodelist
-          node.nodelist.each { |node| asset_names_for_node node, names }
+        if node.respond_to?(:nodelist) && node.nodelist
+          node.nodelist.each { |n| asset_names_for_node n, names }
         end
 
         names
       end
-
     end
 
     module ClassMethods
       def assets_join_table_name
-        "#{Landable.configuration.database_schema_prefix}landable.#{self.name.underscore.split('/').last}_assets"
+        "#{Landable.configuration.database_schema_prefix}landable.#{name.underscore.split('/').last}_assets"
       end
     end
-
   end
 end

data/app/models/concerns/landable/has_templates.rb

@@ -23,7 +23,7 @@ module Landable
       end
 
       # passthrough for body=; clears the template_names cache in the process
-      def body= body_val
+      def body=(body_val)
         @template_slug = nil
         @asset_names = nil
         self[:body] = body_val
@@ -31,29 +31,28 @@ module Landable
 
       # this looks weird; I swear it works
       def save_templates!
-        self.templates = self.templates
+        self.templates = templates
       end
 
       private
 
-      def template_names_for_node node, names = []
+      def template_names_for_node(node, names = [])
         # set up a recursing function to search for template tags
         if node.is_a? Landable::Liquid::TemplateTag
           names << node.template_slug unless names.include? node.template_slug
         end
 
-        if node.respond_to? :nodelist and node.nodelist
-          node.nodelist.each { |node| template_names_for_node node, names }
+        if node.respond_to?(:nodelist) && node.nodelist
+          node.nodelist.each { |n| template_names_for_node n, names }
         end
 
         names
       end
-
     end
 
     module ClassMethods
       def templates_join_table_name
-        "#{Landable.configuration.database_schema_prefix}landable.#{self.name.underscore.split('/').last}_templates"
+        "#{Landable.configuration.database_schema_prefix}landable.#{name.underscore.split('/').last}_templates"
       end
     end
   end

data/app/models/concerns/landable/librarian.rb

@@ -13,21 +13,21 @@ module Landable
     end
 
     # validations
-    
+
     # standard methods
     def deactivate
-      self.update_attribute(:deleted_at, Time.now)
+      update_attribute(:deleted_at, Time.now)
     end
 
     # custom methods
     def nuke!
-      self.destroy
+      destroy
     end
 
     def reactivate
-      self.update_attribute(:deleted_at, nil)
+      update_attribute(:deleted_at, nil)
     end
-    
+
     # end
   end
 

data/app/models/concerns/landable/table_name.rb

@@ -1,12 +1,12 @@
 module Landable
   module TableName
-    extend ActiveSupport::Concern 
+    extend ActiveSupport::Concern
 
     included do
       schema = "#{Landable.configuration.database_schema_prefix}landable"
       suffix = parent.name.demodulize.downcase
 
-      schema += "_#{suffix}" unless suffix == "landable"
+      schema += "_#{suffix}" unless suffix == 'landable'
       model_name = self.model_name.element.pluralize
       self.table_name = "#{schema}.#{model_name}"
     end

data/app/models/landable/access_token.rb

@@ -1,7 +1,7 @@
 module Landable
   class AccessToken < ActiveRecord::Base
     include Landable::TableName
-    
+
     belongs_to :author
     validates_presence_of :author_id
     validates_presence_of :expires_at

data/app/models/landable/asset.rb

@@ -7,10 +7,10 @@ module Landable
   class Asset < ActiveRecord::Base
     include Landable::TableName
     include Landable::Librarian
-    
+
     mount_uploader :data, Landable::AssetUploader
-    alias :file :data
-    alias :file= :data=
+    alias_method :file, :data
+    alias_method :file=, :data=
 
     # This bit of indirection allows us to generate predictable
     # URLs in the test environment.
@@ -25,11 +25,11 @@ module Landable
 
     before_validation :write_metadata, on: :create
 
-    validates_presence_of     :data, :author
-    validates_presence_of     :name, :mime_type, :md5sum, :file_size
-    validates_uniqueness_of   :md5sum
+    validates_presence_of :data, :author
+    validates_presence_of :name, :mime_type, :md5sum, :file_size
+    validates_uniqueness_of :md5sum
     validates_numericality_of :file_size, only_integer: true
-    validates_format_of       :name, :with => /^[\w\._-]+$/, :on => :create, :multiline => true, :message => 'can only contain alphanumeric characters, periods, underscores, and dashes'
+    validates_format_of :name, with: /^[\w\._-]+$/, on: :create, multiline: true, message: 'can only contain alphanumeric characters, periods, underscores, and dashes'
 
     def public_url
       self.class.url_generator.call(self)
@@ -42,7 +42,7 @@ module Landable
 
     def associated_pages
       paths = []
-      Page.where("body like ?", "%#{self.name}%").each do |page|
+      Page.where('body like ?', "%#{name}%").each do |page|
         paths.push(page.path)
       end
       paths

data/app/models/landable/asset_search_engine.rb

@@ -1,5 +1,5 @@
-require_dependency "landable/search_engine"
-require_dependency "landable/asset"
+require_dependency 'landable/search_engine'
+require_dependency 'landable/asset'
 
 module Landable
   class AssetSearchEngine < SearchEngine
@@ -8,13 +8,12 @@ module Landable
     end
 
     def filter_by!(filters)
-      if ids = as_array(filters[:ids])
-        @scope = @scope.where(asset_id: ids)
-      end
+      ids = as_array(filters[:ids])
+      @scope = @scope.where(asset_id: ids) if ids
 
-      if name = filters[:name].presence
-        @scope = @scope.where('LOWER(name) LIKE ?', "%#{name}%".downcase)
-      end
+      name = filters[:name].presence
+      return unless name
+      @scope = @scope.where('LOWER(name) LIKE ?', "%#{name}%".downcase)
     end
   end
 end

data/app/models/landable/author.rb

@@ -4,7 +4,8 @@ module Landable
     has_many :access_tokens
 
     def self.authenticate!(username, token_id)
-      return unless author = where(username: username).first
+      author = where(username: username).first
+      return unless author
       return unless author.access_tokens.fresh.exists?(token_id)
       author
     end

data/app/models/landable/category.rb

@@ -12,16 +12,14 @@ module Landable
     def to_liquid
       {
         'name' => name,
-        'pages' => pages.published,
+        'pages' => pages.published
       }
     end
 
-
     protected
 
     def set_slug
       self.slug = name.downcase.gsub(/[^\w]/, '_').gsub(/_{2,}/, '_')
     end
-
   end
 end

data/app/models/landable/directory.rb

@@ -3,11 +3,11 @@ module Landable
     include ActiveModel::SerializerSupport
 
     def self.listing(parent)
-      parent_with_slash = parent.gsub(/^(.*?)\/?$/, '\1/')
+      parent_with_slash = parent.gsub(%r{^(.*?)\/?$}, '\1/')
       pages   = Page.where('path LIKE ?', "#{parent_with_slash}%").to_a
       subdirs = pages.group_by { |page| page.directory_after(parent_with_slash) }
       notdirs = subdirs.delete(nil) || []
-      subdirs = subdirs.map { |name, contents| Directory.new("#{parent}/#{name}") }
+      subdirs = subdirs.map { |name, _contents| Directory.new("#{parent}/#{name}") }
       Directory.new(parent, subdirs.sort_by(&:path), notdirs.sort_by(&:path))
     end
 

data/app/models/landable/page.rb

@@ -13,10 +13,10 @@ module Landable
     include Landable::TableName
     include Landable::Librarian
 
-    validates_presence_of   :path, :status_code
-    validates_presence_of   :redirect_url, if: -> page { page.redirect? }
+    validates_presence_of :path, :status_code
+    validates_presence_of :redirect_url, if: -> page { page.redirect? }
 
-    validates_inclusion_of  :status_code, in: [200, 301, 302, 410]
+    validates_inclusion_of :status_code, in: [200, 301, 302, 410]
 
     validates_with PathValidator, fields: [:path]
     validates_uniqueness_of :path
@@ -35,21 +35,23 @@ module Landable
     belongs_to :category,             class_name: 'Landable::Category'
     belongs_to :updated_by_author,    class_name: 'Landable::Author'
     belongs_to :hero_asset,           class_name: 'Landable::Asset'
-    has_many   :revisions,            class_name: 'Landable::PageRevision'
-    has_many   :screenshots,          class_name: 'Landable::Screenshot',   as: :screenshotable
-    has_many   :audits,               class_name: 'Landable::Audit',        as: :auditable
+    has_many :revisions,            class_name: 'Landable::PageRevision'
+    has_many :screenshots,          class_name: 'Landable::Screenshot',   as: :screenshotable
+    has_many :audits,               class_name: 'Landable::Audit',        as: :auditable
 
     delegate :republish!, to: :published_revision
 
-    scope :imported, -> { where("imported_at IS NOT NULL") }
-    scope :sitemappable, -> { where("COALESCE(meta_tags -> 'robots' NOT LIKE '%noindex%', TRUE)")
-                              .where("published_revision_id is NOT NULL")
-                              .where(status_code: 200)}
-    scope :published, -> { where("published_revision_id is NOT NULL") }
+    scope :imported, -> { where('imported_at IS NOT NULL') }
+    scope :sitemappable, lambda {
+      where("COALESCE(meta_tags -> 'robots' NOT LIKE '%noindex%', TRUE)")
+        .where('published_revision_id is NOT NULL')
+        .where(status_code: 200)
+    }
+    scope :published, -> { where('published_revision_id is NOT NULL') }
 
     before_validation :downcase_path!
 
-    before_save -> page {
+    before_save lambda  { |page|
       page.lock_version ||= 0
       page.is_publishable = true unless page.published_revision_id_changed?
     }
@@ -68,9 +70,9 @@ module Landable
       end
 
       def with_fuzzy_path(path)
-        select("*, similarity(path, #{Page.sanitize path}) _sml").
-          where('path LIKE ?', "%#{path}%").
-          order('_sml DESC, path ASC')
+        select("*, similarity(path, #{Page.sanitize path}) _sml")
+          .where('path LIKE ?', "%#{path}%")
+          .order('_sml DESC, path ASC')
       end
 
       def example(attrs)
@@ -82,15 +84,14 @@ module Landable
         new defaults.merge(attrs)
       end
 
-
       def generate_sitemap(options = {})
         pages = Landable::Page.sitemappable
-        xml = Builder::XmlMarkup.new( :indent => 2 )
-        xml.instruct! :xml, encoding: "UTF-8"
-        xml.urlset(xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9") do |xml|
+        xml = Builder::XmlMarkup.new(indent: 2)
+        xml.instruct! :xml, encoding: 'UTF-8'
+        xml.urlset(xmlns: 'http://www.sitemaps.org/schemas/sitemap/0.9') do |markup|
           pages.each do |page|
             next if options[:exclude_categories].to_a.include? page.category.try(:name)
-            xml.url do |p|
+            markup.url do |p|
               p.loc "#{options[:protocol]}://#{options[:host]}#{page.path}"
               p.lastmod page.updated_at.to_time.iso8601
               p.changefreq 'weekly'
@@ -100,7 +101,7 @@ module Landable
 
           if options[:sitemap_additional_paths].present?
             options[:sitemap_additional_paths].each do |page|
-              xml.url do |p|
+              markup.url do |p|
                 p.loc "#{options[:protocol]}://#{options[:host]}#{page}"
                 p.changefreq 'weekly'
                 p.priority '1'
@@ -133,9 +134,9 @@ module Landable
     end
 
     def deactivate
-      self.update_attribute(:status_code, 410)
-      
-      publish!(author_id: updated_by_author.id, notes: "This page has been trashed")
+      update_attribute(:status_code, 410)
+
+      publish!(author_id: updated_by_author.id, notes: 'This page has been trashed')
 
       super
     end
@@ -145,7 +146,7 @@ module Landable
     end
 
     def directory_after(prefix)
-      remainder = path.gsub(/^#{prefix}\/?/, '')
+      remainder = path.gsub(%r{^#{prefix}\/?}, '')
       segments  = remainder.split('/', 2)
       if segments.length == 1
         nil
@@ -160,15 +161,13 @@ module Landable
 
     def path=(name)
       # if not present, add a leading slash for a non-empty path
-      if name and not name.empty?
-        name = name.gsub(/^\/?(.*)/, '/\1')
-      end
+      name = name.gsub(%r{^\/?(.*)}, '/\1') if name && !name.empty?
 
       self[:path] = name
     end
 
     def hero_asset_name
-      self.hero_asset.try(:name)
+      hero_asset.try(:name)
     end
 
     def hero_asset_name=(name)
@@ -178,7 +177,7 @@ module Landable
     end
 
     def hero_asset_url
-      self.hero_asset.try(:public_url)
+      hero_asset.try(:public_url)
     end
 
     def publish!(options)
@@ -216,39 +215,35 @@ module Landable
     end
 
     def forbid_changing_path
-      errors[:path] = "can not be changed!" if self.path_changed?
+      errors[:path] = 'can not be changed!' if self.path_changed?
     end
 
     def body_strip_search
-      begin
-        RenderService.call(self)
-      rescue ::Liquid::Error => error
-        errors[:body] = 'contains a Liquid syntax error'
-      rescue StandardError => error
-        errors[:body] = 'had a problem: ' + error.message
-      end
+      RenderService.call(self)
+    rescue ::Liquid::Error
+      errors[:body] = 'contains a Liquid syntax error'
+    rescue StandardError => error
+      errors[:body] = 'had a problem: ' + error.message
     end
 
     def page_name_byte_size
-      if page_name.present? && page_name.bytesize > 100
-        errors[:page_name] = 'Invalid PageName, bytesize is too big!'
-      end
+      return unless page_name.present? && page_name.bytesize > 100
+      errors[:page_name] = 'Invalid PageName, bytesize is too big!'
     end
 
     def hero_asset_existence
       return true if @hero_asset_name.blank?
-      unless Asset.find_by_name(@hero_asset_name)
-        errors[:hero_asset_name] = "System can't find an asset with this name"
-      end
+      return if Asset.find_by_name(@hero_asset_name)
+      errors[:hero_asset_name] = "System can't find an asset with this name"
     end
 
     def to_liquid
       {
-        "title" => title,
-        "url" => path,
-        "hero_asset" => hero_asset ? true : false,
-        "hero_asset_url" => hero_asset_url,
-        "abstract" => abstract
+        'title' => title,
+        'url' => path,
+        'hero_asset' => hero_asset ? true : false,
+        'hero_asset_url' => hero_asset_url,
+        'abstract' => abstract
       }
     end
 
@@ -276,6 +271,5 @@ module Landable
     end
 
     include Errors
-
   end
 end