tb_cms 1.2.3 → 1.3.beta1

data/app/models/spud_page.rb

@@ -1,81 +1,77 @@
 class SpudPage < ActiveRecord::Base
-	include CmsDeprecatedMultisite
-	include TbRedirects::HasRedirects
+  include CmsDeprecatedMultisite
+  include TbRedirects::HasRedirects
 
-	spud_searchable
-	belongs_to :spud_page
-	has_many :spud_page_partial_revisions
-	has_many :spud_pages, :dependent => :nullify
-	has_many :spud_page_partials,:dependent => :destroy
-	belongs_to :created_by_user,:class_name => "SpudUser",:foreign_key => :created_by
-	belongs_to :updated_by_user,:class_name => "SpudUser",:foreign_key => :updated_by
+  spud_searchable
+  belongs_to :spud_page
+  has_many :spud_page_partial_revisions
+  has_many :spud_pages, dependent: :nullify
+  has_many :spud_page_partials, dependent: :destroy
+  belongs_to :created_by_user, class_name: 'SpudUser', foreign_key: :created_by
+  belongs_to :updated_by_user, class_name: 'SpudUser', foreign_key: :updated_by
 
-	before_validation :generate_url_name
-	validates :name, :presence => true, :uniqueness => {:scope => :spud_page_id}
-	validates :url_name, :presence => true, :uniqueness => true
-	after_update :create_redirect_if_necessary
+  before_validation :generate_url_name
+  validates :name, presence: true, uniqueness: { scope: :spud_page_id }
+  validates :url_name, presence: true, uniqueness: true
+  after_update :create_redirect_if_necessary
 
-	accepts_nested_attributes_for :spud_page_partials, :allow_destroy => true
+  accepts_nested_attributes_for :spud_page_partials, allow_destroy: true
 
-	scope :parent_pages, ->{ where(:spud_page_id => nil)}
-	scope :published_pages, ->{ where(:published => true) }
-	scope :viewable, ->{ where(:visibility => 0) }
+  scope :parent_pages, -> { where(spud_page_id: nil) }
+  scope :published_pages, -> { where(published: true) }
+  scope :viewable, -> { where(visibility: 0) }
 
-	def full_content_processed
-		self.spud_page_partials.collect{|partial| partial.content_processed }.join(' ')
-	end
+  def full_content_processed
+    spud_page_partials.collect(&:content_processed).join(' ')
+  end
 
-	def to_liquid
-		return {'name' => self.name, 'url_name' => self.url_name}
-	end
+  def to_liquid
+    return { 'name' => name, 'url_name' => url_name }
+  end
 
-	# Returns an array of pages in order of heirarchy
-	# 	:fitler Filters out a page by ID, and all of its children
-	#   :value Pick an attribute to be used in the value field, defaults to ID
-	def self.options_tree_for_page(config={})
-		collection = config[:collection] || self.all.group_by(&:spud_page_id)
-		level 		 = config[:level] 		 || 0
-		parent_id  = config[:parent_id]  || nil
-		filter 		 = config[:filter] 		 || nil
-		value      = config[:value]			 || :id
-		list 			 = []
-		if collection[parent_id]
-			collection[parent_id].each do |c|
-				if filter.blank? || c.id != filter.id
-					list << [level.times.collect{ '- ' }.join('') + c.name, c[value]]
-					list += self.options_tree_for_page({:collection => collection, :parent_id => c.id, :level => level+1, :filter => filter})
-				end
-			end
-		end
-		return list
-	end
+  # Returns an array of pages in order of heirarchy
+  # 	:fitler Filters out a page by ID, and all of its children
+  #   :value Pick an attribute to be used in the value field, defaults to ID
+  def self.options_tree_for_page(config = {})
+    collection = config[:collection] || all.group_by(&:spud_page_id)
+    level = config[:level] || 0
+    parent_id = config[:parent_id] || nil
+    filter = config[:filter] || nil
+    value = config[:value] || :id
+    list = []
+    collection[parent_id]&.each do |c|
+      if filter.blank? || c.id != filter.id
+        list << [Array.new(level) { '- ' }.join('') + c.name, c[value]]
+        list += options_tree_for_page(collection: collection, parent_id: c.id, level: level + 1, filter: filter)
+       end
+    end
+    return list
+  end
 
-	def is_private?
-		return self.visibility == 1
-	end
+  def is_private?
+    return visibility == 1
+  end
 
-private
+  private
 
-	def generate_url_name
-		if url_name.blank?
-			parts = []
-			parts << spud_page.url_name if spud_page.present?
-			parts << name.try(:parameterize)
-			self.url_name = parts.join('/')
-		end
-		return true
-	end
+  def generate_url_name
+    if url_name.blank?
+      parts = []
+      parts << spud_page.url_name if spud_page.present?
+      parts << name.try(:parameterize)
+      self.url_name = parts.join('/')
+    end
+    return true
+  end
 
-	def create_redirect_if_necessary
-		if url_name_changed?
-			TbRedirect.create_smart({
-				:source => "/#{url_name_was}",
-				:destination => "/#{url_name}",
-				:created_by => 'cms',
-				:owner => self
-			})
-		end
-		return true
-	end
+  def create_redirect_if_necessary
+    if url_name_changed?
+      TbRedirect.create_smart(source: "/#{url_name_was}",
+                              destination: "/#{url_name}",
+                              created_by: 'cms',
+                              owner: self)
+    end
+    return true
+  end
 
 end

data/app/models/spud_page_partial.rb

@@ -1,52 +1,50 @@
 class SpudPagePartial < ActiveRecord::Base
-	belongs_to :spud_page, :touch => true
-	has_many :spud_liquid_tags, :as => :attachment, :dependent => :destroy
-	validates :name,:presence => true
-	before_save :maintain_revisions
-	before_save :update_symbol_name
-	acts_as_tb_liquid_content
+  belongs_to :spud_page, touch: true
+  has_many :spud_liquid_tags, as: :attachment, dependent: :destroy
+  validates :name, presence: true
+  before_save :maintain_revisions
+  before_save :update_symbol_name
+  acts_as_tb_liquid_content
 
-	def update_symbol_name
-		self.symbol_name = self.name.parameterize.underscore
-	end
+  def update_symbol_name
+    self.symbol_name = name.parameterize.underscore
+  end
 
-	def symbol_name
-		return @symbol_name || self.name.parameterize.underscore
-	end
+  def symbol_name
+    return @symbol_name || name.parameterize.underscore
+  end
 
-	def postprocess_content
-		@_template = Liquid::Template.parse(self.content)
-		self.content_processed = @_template.render('page' => self.spud_page)
-	end
+  def postprocess_content
+    @_template = Liquid::Template.parse(content)
+    self.content_processed = @_template.render('page' => spud_page)
+  end
 
-	def content_processed=(content)
-		write_attribute(:content_processed,content)
-	end
+  def content_processed=(content)
+    self[:content_processed] = content
+  end
 
-	def content_processed
-		if read_attribute(:content_processed).blank?
-			if self.new_record?
-				self.content_processed = postprocess_content()
-			else
-				self.update_column(:content_processed, postprocess_content)
-			end
-		end
-		return read_attribute(:content_processed)
-	end
+  def content_processed
+    if self[:content_processed].blank?
+      if new_record?
+        self.content_processed = postprocess_content()
+      else
+        update_column(:content_processed, postprocess_content)
+      end
+    end
+    return self[:content_processed]
+  end
 
-	def maintain_revisions
-		if !self.changed.include?('content')
-			return true
-		end
-		revision = SpudPagePartialRevision.new(:spud_page_id => self.spud_page_id,:name => self.name,:format => self.format,:content => self.content)
-			revision.save
-			if Spud::Cms.max_revisions > 0
-				revision_count = SpudPagePartialRevision.where(:spud_page_id => self.spud_page_id,:name => self.name).count
-				if revision_count > Spud::Cms.max_revisions
-					revision_bye = SpudPagePartialRevision.where(:spud_page_id => self.spud_page_id,:name => self.name).order("created_at ASC").first
-					revision_bye.destroy if !revision_bye.blank?
-				end
-			end
-		return true
-	end
+  def maintain_revisions
+    return true unless changed.include?('content')
+    revision = SpudPagePartialRevision.new(spud_page_id: spud_page_id, name: name, format: format, content: content)
+    revision.save
+    if Spud::Cms.max_revisions > 0
+      revision_count = SpudPagePartialRevision.where(spud_page_id: spud_page_id, name: name).count
+      if revision_count > Spud::Cms.max_revisions
+        revision_bye = SpudPagePartialRevision.where(spud_page_id: spud_page_id, name: name).order('created_at ASC').first
+        revision_bye.destroy unless revision_bye.blank?
+      end
+      end
+    return true
+  end
 end

data/app/models/spud_page_partial_revision.rb

@@ -1,5 +1,5 @@
 class SpudPagePartialRevision < ActiveRecord::Base
-	belongs_to :spud_page
-	
-	#attr_accessible :name,:content,:format,:spud_page_id
+  belongs_to :spud_page
+
+  # attr_accessible :name,:content,:format,:spud_page_id
 end

data/app/models/spud_snippet.rb

@@ -1,25 +1,25 @@
 class SpudSnippet < ActiveRecord::Base
   include CmsDeprecatedMultisite
 
-  validates :name, :presence => true
-  validates_uniqueness_of :name
+  validates :name, presence: true
+  validates :name, uniqueness: true
 
   acts_as_tb_liquid_content
 
   def postprocess_content
-    template = Liquid::Template.parse(self.content)
+    template = Liquid::Template.parse(content)
     self.content_processed = template.render()
   end
 
   def content_processed=(content)
-    write_attribute(:content_processed,content)
+    self[:content_processed] = content
   end
 
   def content_processed
-    if read_attribute(:content_processed).blank?
-      self.update_column(:content_processed, postprocess_content)
+    if self[:content_processed].blank?
+      update_column(:content_processed, postprocess_content)
     end
-    return read_attribute(:content_processed)
+    return self[:content_processed]
   end
 
 end

data/app/views/admin/menu_items/index.html.erb

@@ -21,7 +21,7 @@
     <input type="hidden" value=<%= @menu.id %> id="menu-id">
   </div>
 <script type="text/javascript">
-  $(document).ready(function() {spud.admin.cms.menu_items.init();})
+  $(document).ready(spud.admin.cms.menu_items.init);
 </script>
 
 <% end %>

data/lib/generators/spud/cms/layout_generator.rb

@@ -1,22 +1,23 @@
 require 'rails/generators/migration'
 
 class Spud::Cms::LayoutGenerator < ::Rails::Generators::Base
-  desc "This generator creates a new spud cms layout file"
-  argument :template_name, :type => :string
-  argument :attributes, :type => :array, :default => [], :banner => "content_block content_block"
+  desc 'This generator creates a new spud cms layout file'
+  argument :template_name, type: :string
+  argument :attributes, type: :array, default: [], banner: 'content_block content_block'
 
   source_root File.expand_path('../templates', __FILE__)
 
   def create_layout
-    template "layout.html.erb", "app/views/layouts/#{template_name.downcase.underscore}.html.erb"
+    template 'layout.html.erb', "app/views/layouts/#{template_name.downcase.underscore}.html.erb"
   end
 
   def create_layout_action
     concern_path = 'app/controllers/concerns/spud_cms_layout_actions.rb'
-    if !File.exist?(File.join(Rails.root, concern_path))
+    unless File.exist?(File.join(Rails.root, concern_path))
       template 'layout_actions.rb', 'app/controllers/concerns/spud_cms_layout_actions.rb'
     end
-    inject_into_file concern_path, :after => "extend ActiveSupport::Concern\n" do <<-HEREDOC
+    inject_into_file concern_path, after: "extend ActiveSupport::Concern\n" do
+      <<-HEREDOC
 
   def #{template_name.downcase.underscore}_action(method)
     # this action is called when the #{template_name} cms layout is used
@@ -25,10 +26,9 @@ HEREDOC
     end
   end
 
-private
+  private
 
   def concern_content
-
   end
 
 end

data/lib/spud_cms/configuration.rb

@@ -2,25 +2,25 @@ module Spud
   module Cms
     include ActiveSupport::Configurable
 
-    config_accessor :menus_enabled,:root_page_name,:yield_body_as_content_block,:default_page_layout,:enable_sitemap,:multisite_config,:max_revisions,:template_404, :cache_mode, :snippets_enabled
+    config_accessor :menus_enabled, :root_page_name, :yield_body_as_content_block, :default_page_layout, :enable_sitemap, :multisite_config, :max_revisions, :template_404, :cache_mode, :snippets_enabled
     self.menus_enabled = true
     self.snippets_enabled = false
-    self.root_page_name = "home"
+    self.root_page_name = 'home'
     self.default_page_layout = 'application'
-  	self.yield_body_as_content_block = false
-    self.cache_mode = nil #Options :full_page, :action
+    self.yield_body_as_content_block = false
+    self.cache_mode = nil # Options :full_page, :action
 
     self.enable_sitemap = true
     self.max_revisions = 10
     self.template_404 = 'not_found'
     self.multisite_config = []
     def self.site_config_for_short_name(short_name)
-        configs = Spud::Cms.multisite_config.select{|p| p[:short_name].to_s == short_name.to_s}
-        if configs.blank?
-          return nil
-        else
-          return configs[0]
-        end
+      configs = Spud::Cms.multisite_config.select { |p| p[:short_name].to_s == short_name.to_s }
+      if configs.blank?
+        return nil
+      else
+        return configs[0]
+      end
     end
 
   end

data/lib/spud_cms/engine.rb

@@ -8,49 +8,49 @@ module Spud
       engine_name :tb_cms
 
       config.generators do |g|
-        g.test_framework :rspec, :view_specs => false
+        g.test_framework :rspec, view_specs: false
       end
 
-    initializer :admin do
-      Spud::Core.configure do |config|
-          config.admin_applications += [{:name => "Pages",:thumbnail => "admin/pages_thumb.png",:url => "/admin/pages",:order => 0}]
+      initializer :admin do
+        Spud::Core.configure do |config|
+          config.admin_applications += [{ name: 'Pages', thumbnail: 'admin/pages_thumb.png', url: '/admin/pages', order: 0 }]
           if Spud::Cms.menus_enabled
-            config.admin_applications += [{:name => "Menus",:thumbnail => "admin/menus_thumb.png",:url => "/admin/menus",:order => 2}]
+            config.admin_applications += [{ name: 'Menus', thumbnail: 'admin/menus_thumb.png', url: '/admin/menus', order: 2 }]
           end
 
           if Spud::Cms.snippets_enabled
-            config.admin_applications += [{:name => "Snippets",:thumbnail => "admin/snippets_thumb.png",:url => "/admin/snippets",:order => 3}]
+            config.admin_applications += [{ name: 'Snippets', thumbnail: 'admin/snippets_thumb.png', url: '/admin/snippets', order: 3 }]
           end
+        end
       end
-    end
 
-    initializer :model_overrides_cms do |config|
-      ActiveRecord::Base.class_eval do
-        include Spud::Searchable
+      initializer :model_overrides_cms do |_config|
+        ActiveRecord::Base.class_eval do
+          include Spud::Searchable
+        end
       end
-     end
 
-     initializer :spud_cms_routes do |config|
-      config.routes_reloader.paths << File.expand_path('../page_route.rb', __FILE__)
-     end
+      initializer :spud_cms_routes do |config|
+        config.routes_reloader.paths << File.expand_path('../page_route.rb', __FILE__)
+      end
 
-    initializer 'tb_cms.assets' do |config|
-      Spud::Core.append_admin_javascripts('admin/cms/application')
-      Spud::Core.append_admin_stylesheets('admin/cms/application')
-      Rails.application.config.assets.precompile += ['admin/pages_thumb.png', 'admin/snippets_thumb.png', 'admin/menus_thumb.png']
-  	end
+      initializer 'tb_cms.assets' do |_config|
+        Spud::Core.append_admin_javascripts('admin/cms/application')
+        Spud::Core.append_admin_stylesheets('admin/cms/application')
+        Rails.application.config.assets.precompile += ['admin/pages_thumb.png', 'admin/snippets_thumb.png', 'admin/menus_thumb.png']
+      end
 
-     initializer :liquid do |config|
-      Liquid::Template.register_tag('snippet', Spud::Cms::LiquidSnippet)
-     end
+      initializer :liquid do |_config|
+        Liquid::Template.register_tag('snippet', Spud::Cms::LiquidSnippet)
+      end
 
-     initializer :template_parser do |config|
-      @template_parser = Spud::Cms::TemplateParser.new()
-     end
+      initializer :template_parser do |_config|
+        @template_parser = Spud::Cms::TemplateParser.new()
+      end
 
-     def template_parser
-      return @template_parser
-     end
+      def template_parser
+        return @template_parser
+      end
 
     end
   end

data/lib/spud_cms/liquid_snippet.rb

@@ -2,27 +2,25 @@ require 'liquid'
 module Spud
   module Cms
     class LiquidSnippet < Liquid::Tag
-      def initialize(tag_name, snippet_name, tokens)
+      def initialize(_tag_name, snippet_name, _tokens)
         @snippet_name = snippet_name
-        @snippet = SpudSnippet.where(:name => snippet_name).first
-
+        @snippet = SpudSnippet.where(name: snippet_name).first
       end
 
       def tag_name
-        return "snippet"
+        return 'snippet'
       end
+
       def tag_value
         return @snippet_name
       end
 
-      def render(context)
-
+      def render(_context)
         if !@snippet.blank?
           return @snippet.content_processed.html_safe
         else
           return ''
         end
-
       end
     end
   end

data/lib/spud_cms/page_route.rb

@@ -1,3 +1,3 @@
 Rails.application.routes.draw do
-	match "*id", :controller => "pages", :action => "show", :as => "page", :via => [:get, :post]
+  match '*id', controller: 'pages', action: 'show', as: 'page', via: [:get, :post]
 end

data/lib/spud_cms/template_parser.rb

@@ -2,30 +2,27 @@ module Spud
   module Cms
     class TemplateParser
 
-
       def layouts
-        if @layouts && Rails.env != 'development'
-          return @layouts
-        end
+        return @layouts if @layouts && Rails.env != 'development'
         @layouts = {}
         engines.each do |engine|
-          @layouts.merge! process_layouts(engine.root.join('app','views','layouts'))
+          @layouts.merge! process_layouts(engine.root.join('app', 'views', 'layouts'))
         end
-        @layouts.merge! process_layouts(Rails.application.root.join('app','views','layouts'))
+        @layouts.merge! process_layouts(Rails.application.root.join('app', 'views', 'layouts'))
 
         check_for_defaults(@layouts)
 
         return @layouts
       end
 
-  private
+      private
 
       def process_layouts(filepath)
         layouts = {}
-        Dir.glob(filepath.join("**","*.html.*")) do |template|
+        Dir.glob(filepath.join('**', '*.html.*')) do |template|
 
           layout = process_layout(template)
-          layouts[layout_path(template)] = layout if !layout.blank?
+          layouts[layout_path(template)] = layout unless layout.blank?
 
         end
         return layouts
@@ -33,35 +30,35 @@ module Spud
 
       def process_layout(template)
         f = File.open(template)
-          header = []
-          f.each_line do |line|
-            header << line
-            break if line.blank?
-          end
-          f.close
-          # puts header
-          if header.blank? == false
-            layout = {:partials => []}
+        header = []
+        f.each_line do |line|
+          header << line
+          break if line.blank?
+        end
+        f.close
+        # puts header
+        if header.blank? == false
+          layout = { partials: [] }
 
-            header.each do |header_line|
-              process_directive(header_line, layout)
-            end
-            layout[:partials] = ["Body"] if layout[:partials].blank?
-            layout[:sites] = [Spud::Core.config.short_name.downcase] if layout[:sites].blank?
-            if layout[:template_name].blank? == false
-              return layout
-            else
-              return nil
-            end
+          header.each do |header_line|
+            process_directive(header_line, layout)
           end
-          return nil
+          layout[:partials] = ['Body'] if layout[:partials].blank?
+          layout[:sites] = [Spud::Core.config.short_name.downcase] if layout[:sites].blank?
+          if layout[:template_name].blank? == false
+            return layout
+          else
+            return nil
+          end
+        end
+        return nil
       end
 
       def check_for_defaults(layouts)
-        default_layout_path = layout_path(Rails.application.root.join('app','views','layouts',Spud::Cms.default_page_layout))
-        #puts(layouts)
+        default_layout_path = layout_path(Rails.application.root.join('app', 'views', 'layouts', Spud::Cms.default_page_layout))
+        # puts(layouts)
         if layouts[default_layout_path].blank?
-          layouts[default_layout_path] = {:template_name => "Default", :partials => ["Body"], :sites => [Spud::Core.short_name.downcase], :default => true}
+          layouts[default_layout_path] = { template_name: 'Default', partials: ['Body'], sites: [Spud::Core.short_name.downcase], default: true }
         else
           layouts[default_layout_path][:default] = true
         end
@@ -69,16 +66,14 @@ module Spud
 
       def layout_path(template)
         dir, base = File.split(template)
-        path_components = dir.split("/")
+        path_components = dir.split('/')
         component = path_components.shift
-        while component != "layouts" do
-          component = path_components.shift
-        end
-        path_components << base.downcase.split(".")[0]
-        return "#{path_components.join("/")}"
+        component = path_components.shift while component != 'layouts'
+        path_components << base.downcase.split('.')[0]
+        return path_components.join('/').to_s
       end
 
-      def process_directive(line,layout)
+      def process_directive(line, layout)
         if template_matcher = line.match(/\-?\#template\_name\:(.*)/)
           layout[:template_name] = template_matcher[1].strip
         end
@@ -86,7 +81,7 @@ module Spud
           layout[:partials] << template_matcher[1].strip
         end
         if template_matcher = line.match(/\-?\#site_name\:(.*)/)
-          layout[:sites] = template_matcher[1].split(",").collect {|s| s.strip.downcase}
+          layout[:sites] = template_matcher[1].split(',').collect { |s| s.strip.downcase }
         end
       end
 

data/lib/spud_cms/test_files.rb

@@ -7,17 +7,17 @@ module Spud
           load_factories
           load_support
         end
-        
+
         def load_specs
-          Dir[File.join(File.expand_path('../../../', __FILE__), "spec/**/*_spec.rb")].each {|f| require f}
+          Dir[File.join(File.expand_path('../../../', __FILE__), 'spec/**/*_spec.rb')].each { |f| require f }
         end
-          
+
         def load_factories
-          Dir[File.join(File.expand_path('../../../', __FILE__), "factories/*")].each {|f| require f}
+          Dir[File.join(File.expand_path('../../../', __FILE__), 'factories/*')].each { |f| require f }
         end
-        
+
         def load_support
-          Dir[File.join(File.expand_path('../../../', __FILE__), "spec/support/**/*.rb")].each {|f| require f}
+          Dir[File.join(File.expand_path('../../../', __FILE__), 'spec/support/**/*.rb')].each { |f| require f }
         end
       end
     end