caboose-cms 0.9.229 → 1.0.1

data/app/models/caboose/asset_manifest.rb

@@ -0,0 +1,91 @@
+module Caboose
+  class AssetManifest
+    
+    #@@bucket = nil
+    #
+    #def AssetManifest.bucket
+    #  if @@bucket.nil?        
+    #    config = YAML.load(File.read(Rails.root.join('config', 'aws.yml')))[Rails.env]                      
+    #    AWS.config({ :access_key_id => config['access_key_id'], :secret_access_key => config['secret_access_key'] })
+    #    @@bucket = AWS::S3::Bucket.new(config['bucket'])
+    #  end
+    #  return @@bucket
+    #end
+    #    
+    #def AssetManifest.save_asset(path, str, reset = true)
+    #
+    #  file = self.bucket.objects[path]      
+    #  return { :error => "Can't find file." } if file.nil?
+    #                        
+    #  # Save the contents into the source file
+    #  return { :error => "Can't write to file." } if !file.write(str)
+    #  
+    #  # Compile the file
+    #  str_compiled = ''
+    #  begin
+    #    str_compiled = Uglifier.compile(str)
+    #  rescue Exception => e
+    #    return { :error => e.message }
+    #  end
+    #  
+    #  # Compute the digest for the compiled file
+    #  # Note: digest must be generated with environment set to 'production' (sprockets changes digests per environment) 
+    #  digest = Rails.application.assets.file_digest('/Users/william/Sites/caboosecms.com/sites/benttree/images/icons/loading.gif')
+    #  digest = Rails.application.assets.digest.hexdigest(str_compiled)      
+    #  digest = Digest::SHA2.hexdigest(str_compiled)
+    #  
+    #  # See if the digest file for the compiled file exists
+    #  digest_path = self.path_with_digest(path, digest)
+    #  if self.bucket.objects[digest_path].exists?
+    #    digest_file = bucket.objects[digest_path]
+    #    digest_file.write(str_compiled)
+    #  end
+    #  
+    #  # See if the digest is in the manifest
+    #  manifest = self.bucket.objects['assets/manifest.yml']
+    #  exists = false
+    #  changed = false      
+    #  new_lines = []
+    #  manifest.read.split("\n").each do|line|
+    #    if line.starts_with?("#{path}: ")
+    #      exists = true
+    #      changed = true if line != "#{path}: #{digest_path}"            
+    #      new_lines << "#{path}: #{digest_path}"
+    #    else
+    #      new_lines << line
+    #    end
+    #  end
+    #  if !exists
+    #    new_lines << "#{path}: #{digest_path}"
+    #    changed = true
+    #  end
+    #
+    #  # If the digest has changed, update the manifest and set the app asset digests
+    #  if changed
+    #    manifest.write(new_lines.join("\n"))        
+    #    self.reset_asset_digests(new_lines) if reset
+    #  end
+    #  
+    #  return { :sucess => true }
+    #end
+    #
+    #def AssetManifest.reset_asset_digests(lines = nil)
+    #  lines = self.bucket.objects['assets/manifest.yml'].read.split("\n") if lines.nil?       
+    #  lines.each do|line|                  
+    #    arr = line.split(": ")                    
+    #    Rails.application.config.assets.digests[arr[0]] = arr[1]                
+    #  end            
+    #end
+    #
+    #def AssetManifest.path_with_digest(path, digest)
+    #  arr = path.split('/')
+    #  filename = arr.pop
+    #  filename = filename.split('.')
+    #  ext = filename.pop
+    #  filename = "#{filename.join('.')}-#{digest}.#{ext}"
+    #  return filename if arr.count == 0
+    #  return "#{arr.join('/')}/#{filename}"
+    #end
+
+  end
+end

data/app/models/caboose/block.rb

@@ -9,8 +9,8 @@ class Caboose::Block < ActiveRecord::Base
   belongs_to :page
   belongs_to :media
   belongs_to :block_type
-  belongs_to :parent, :foreign_key => 'parent_id', :class_name => 'Caboose::Block'   
-  has_many :children, :foreign_key => 'parent_id', :class_name => 'Caboose::Block', :order => 'sort_order, id' # :dependent => :delete_all
+  belongs_to :parent, :foreign_key => 'parent_id', :class_name => 'Caboose::Block'
+  has_many :children, -> { order(:sort_order) }, :foreign_key => 'parent_id', :class_name => 'Caboose::Block', :dependent => :delete_all  
   has_attached_file :file, :path => ':caboose_prefixuploads/:block_file_upload_name.:extension'
   do_not_validate_attachment_file_type :file  
   has_attached_file :image,
@@ -39,11 +39,7 @@ class Caboose::Block < ActiveRecord::Base
     :new_parent_id,
     :new_sort_order,
     :new_value,
-    :new_media_id,
-    :cached_value,
-    :cached_css,
-    :cached_js,
-    :use_cache
+    :new_media_id
         
   after_initialize :caste_value
   before_save :caste_value
@@ -62,82 +58,6 @@ class Caboose::Block < ActiveRecord::Base
     return self.name if parent_id.nil?
     return "#{parent.full_name}_#{self.name}"
   end
-
-  def cached_ancestor
-    begin
-      page_or_post = self.page ? self.page : self.post
-      content = page_or_post.block.child('content')
-      index_page = Caboose::Page.index_page(page_or_post.site_id)
-      footer = index_page.block.child('footer')
-      return Caboose::Block.cached_ancestor_helper(self, content.id, footer.id)
-    rescue
-     return nil
-    end
-  end
-
-  def self.cached_ancestor_helper(b, content_id, footer_id)
-    if b.block_type && b.name.nil? && !b.block_type.is_dynamic && (b.parent_id == content_id || b.parent_id == footer_id)
-      return b.id
-    elsif b.parent
-      return cached_ancestor_helper(b.parent, content_id, footer_id)
-    else
-      return nil
-    end
-  end
-
-  def has_dynamic_descendant
-    return Caboose::Block.descendant_helper(self)
-  end
-
-  def self.descendant_helper(block)
-    return true if block.block_type.nil? || block.block_type.is_dynamic
-    is_dynamic = false
-    block.children.where("name is null OR name ILIKE ?","%_column").each do |b|
-      is_dynamic = Caboose::Block.descendant_helper(b)
-      return true if is_dynamic == true
-    end
-    return is_dynamic
-  end
-
-  def update_cache
-    par = self.parent
-    hdd = self.has_dynamic_descendant
-    if par && self.block_type && self.name.blank? && !self.block_type.is_dynamic && !hdd
-      opts = {
-        :view => nil,
-        :controller_view_content => nil,
-        :modal => false,
-        :empty_text => '',
-        :editing => false,
-        :css => nil,
-        :js => nil,
-        :csrf_meta_tags => nil,
-        :csrf_meta_tags2 => nil,    
-        :logged_in_user => nil,
-        :page => self.page,
-        :post => self.post,
-        :site => self.page ? self.page.site : self.post.site,
-        :is_cache => true,
-        :protocol => "https://"
-      }
-      str = par.render(self, opts)
-      host = Rails.env.production? ? "https://#{ActionController::Base.asset_host}" : ""
-      self.cached_value = str.blank? ? '' : str.gsub('"/assets/',"\"#{host}/assets/")
-      self.use_cache = true
-    elsif self.block_type && !self.block_type.is_dynamic && self.children && self.children.count > 0 && hdd # Try caching the children
-      self.cached_value = nil
-      self.cached_css = nil
-      self.cached_js = nil
-      self.children.where(:name => nil).each do |child|
-        child.delay(:queue => 'caching', :priority => 6).update_cache
-      end
-    elsif hdd
-      self.cached_value = nil
-      self.cached_css = nil
-      self.cached_js = nil
-    end
-    self.save
-  end
   
   def child_value(name)
     b = self.child(name)
@@ -150,6 +70,8 @@ class Caboose::Block < ActiveRecord::Base
       return b.media.file if b.media
       return b.file
     end
+    #return b.image if b.block_type.field_type == 'image'
+    #return b.file  if b.block_type.field_type == 'file'
     return b.value
   end
 
@@ -231,8 +153,11 @@ class Caboose::Block < ActiveRecord::Base
     end
   end
                                             
-  def render(block, options)             
+  def render(block, options)
+    #Caboose.log("block.full_name = #{block.full_name}")
+    #Caboose.log("block.render\nself.id = #{self.id}\nblock = #{block}\nblock.full_name = #{block.full_name}\noptions.class = #{options.class}\noptions = #{options}")                
     if block && block.is_a?(String)
+      #Caboose.log("Block #{block} is a string, finding block object... self.id = #{self.id}")                                          
       b = self.child(block)        
       if b.nil?
         self.create_children
@@ -256,14 +181,14 @@ class Caboose::Block < ActiveRecord::Base
       :js => nil,
       :csrf_meta_tags => nil,
       :csrf_meta_tags2 => nil,    
-      :logged_in_user => nil,
-      :is_cache => false
+      :logged_in_user => nil
     }    
-
+    #defaults = { :modal => false, :empty_text => '', :editing => false, :css => nil, :js => nil, :block => block }
     options2 = nil
     if options.is_a?(Hash)
       options2 = defaults.merge(options)
     else
+      #options2 = { :modal => options.modal, :empty_text => options.empty_text, :editing => options.editing, :css => options.css, :js => options.js }
       options2 = {
         :view                    => options.view                    ? options.view                    : nil,
         :controller_view_content => options.controller_view_content ? options.controller_view_content : nil,
@@ -274,15 +199,11 @@ class Caboose::Block < ActiveRecord::Base
         :js                      => options.js                      ? options.js                      : nil,
         :csrf_meta_tags          => options.csrf_meta_tags          ? options.csrf_meta_tags          : nil,
         :csrf_meta_tags2         => options.csrf_meta_tags2         ? options.csrf_meta_tags2         : nil,
-        :logged_in_user          => options.logged_in_user          ? options.logged_in_user          : nil,
-        :is_cache                => options.is_cache                ? options.is_cache                : nil
+        :logged_in_user          => options.logged_in_user          ? options.logged_in_user          : nil
       }
     end
     options2[:block] = block
 
-    pop = block.page ? block.page : block.post
-    return block.cached_value if block && pop && pop.site && pop.site.use_caching && block.use_cache && !block.cached_value.blank? && block.block_type && !block.block_type.is_dynamic && !options2[:is_cache] && (options2[:editing] == false || (pop && pop.is_published))
-
     view = options2[:view]     
     view = ActionView::Base.new(ActionController::Base.view_paths) if view.nil?
 
@@ -306,7 +227,7 @@ class Caboose::Block < ActiveRecord::Base
           block.block_type.latest_error = "#{msg}#{ex.message}\n#{ex.backtrace.join("\n")}"
           block.block_type.save
         end
-      end         
+      end            
     else
       
       full_name = block.block_type.full_name
@@ -356,9 +277,12 @@ class Caboose::Block < ActiveRecord::Base
     return "<p class='note error'>Could not find block view anywhere.</p>" if i > arr.count
     begin
       str = view.render(:partial => arr[i], :locals => options)
-      rescue ActionView::MissingTemplate => ex     
+   #   Caboose.log("Level #{i+1} for #{full_name}: Found partial #{arr[i]}") 
+      rescue ActionView::MissingTemplate => ex        
+   #     Caboose.log("Level #{i+1} for #{full_name}: #{ex.message}")        
         str = render_helper(view, options, block, full_name, arr, i+1)
-      rescue Exception => ex
+      rescue Exception => ex 
+   #     Caboose.log("Level #{i+1} for #{full_name}: #{ex.message}")
         str = "<p class='note error'>#{self.block_message(block, ex)}</p>"
     end
     return str      
@@ -375,7 +299,8 @@ class Caboose::Block < ActiveRecord::Base
   end
                   
   def render_from_function(options)
-    self.create_children
+    self.create_children    
+    #locals = OpenStruct.new(:block => self, :empty_text => empty_text, :editing => editing)
     locals = OpenStruct.new(options)
     erb = ERB.new(block_type.render_function)
     return erb.result(locals.instance_eval { binding })
@@ -392,13 +317,13 @@ class Caboose::Block < ActiveRecord::Base
       :js => nil,
       :csrf_meta_tags => nil,
       :csrf_meta_tags2 => nil,    
-      :logged_in_user => nil,
-      :is_cache => false
+      :logged_in_user => nil
     }
     options2 = nil        
     if options.is_a?(Hash)
       options2 = defaults.merge(options)
     else
+      #options2 = { :modal => options.modal, :empty_text => options.empty_text, :editing => options.editing, :css => options.css, :js => options.js }
       options2 = {
         :view                    => options.view                    ? options.view                    : nil,
         :controller_view_content => options.controller_view_content ? options.controller_view_content : nil,
@@ -409,8 +334,7 @@ class Caboose::Block < ActiveRecord::Base
         :js                      => options.js                      ? options.js                      : nil,
         :csrf_meta_tags          => options.csrf_meta_tags          ? options.csrf_meta_tags          : nil,
         :csrf_meta_tags2         => options.csrf_meta_tags2         ? options.csrf_meta_tags2         : nil,
-        :logged_in_user          => options.logged_in_user          ? options.logged_in_user          : nil,
-        :is_cache                => options.is_cache                ? options.is_cache                : nil
+        :logged_in_user          => options.logged_in_user          ? options.logged_in_user          : nil
       }
     end
     options2[:block] = self

data/app/models/caboose/block_cache.rb

@@ -0,0 +1,105 @@
+module Caboose
+  class BlockCache
+    
+    attr_accessor :id,
+      :page_id, 
+      :parent_id,
+      :block_type_id,
+      :block_type_field_type,
+      :sort_order,
+      :name,
+      :value,
+      :file,
+      :image,
+      :children        
+    
+    def child_value(name)
+      b = self.child(name)
+      return nil if b.nil? 
+      return b.image if b.block_type_field_type == 'image'
+      return b.file  if b.block_type_field_type == 'file'
+      return b.value
+    end
+    
+    def child(name)
+      self.children.each do |kid|
+        return kid if kid.name == name
+      end
+      return nil    
+    end
+    
+    def children_where(h)
+      arr = []      
+      self.children.each do |b|
+        matches = true
+        h.each do |k,v|
+          if b.send(k) != v
+            matches = false
+            break
+          end
+        end
+        arr << b if matches
+      end
+      return nil if arr.count == 0
+      return arr
+    end
+                                              
+    #def render(block, options = nil)                    
+    #  block = self.child(block) if block && block.is_a?(String)
+    #  eval("CabooseBlockRendering::render_block_type_#{block.block_type_id}(block)")
+    #end
+     
+    def initialize(b)
+      self.id                     = b.id                    
+      self.page_id                = b.page_id
+      self.parent_id              = b.parent_id 
+      self.block_type_id          = b.block_type_id
+      self.block_type_field_type  = b.block_type ? b.block_type.field_type : nil
+      self.sort_order             = b.sort_order
+      self.name                   = b.name
+      self.value                  = b.value
+      self.file                   = BlockCacheFile.new(b.file)
+      self.image                  = BlockCacheImage.new(b.image)
+      self.children = b.children.collect{ |b2| BlockCache.new(b2) }
+    end
+    
+    def page            
+      return $page
+    end
+    
+    def marshal_dump
+      [
+        self.id,
+        self.page_id, 
+        self.parent_id,
+        self.block_type_id,
+        self.block_type_field_type,
+        self.sort_order,
+        self.name,
+        self.value,
+        Marshal.dump(self.file),
+        Marshal.dump(self.image),
+        self.children.collect{ |b| Marshal.dump(b) }
+      ]      
+    end
+
+    def marshal_load array
+      self.id,
+      self.page_id, 
+      self.parent_id,
+      self.block_type_id,
+      self.block_type_field_type,
+      self.sort_order,
+      self.name,
+      self.value,
+      self.file,
+      self.image,
+      self.children = array
+      
+      self.file = Marshal.load(self.file)
+      self.image = Marshal.load(self.image)
+      self.children = self.children.collect{ |kid| Marshal.load(kid) }
+    end
+    
+  end
+end

data/app/models/caboose/block_cache_file.rb

@@ -0,0 +1,22 @@
+
+module Caboose
+  class BlockCacheFile
+        
+    def initialize(file)
+      @_url = file.url
+    end
+    
+    def url(style = nil)
+      return @_url      
+    end
+    
+    def marshal_dump
+      [@_url]
+    end
+    
+    def marshal_load array
+      @url = array.first
+    end
+    
+  end
+end

data/app/models/caboose/block_cache_image.rb

@@ -0,0 +1,53 @@
+
+module Caboose
+  class BlockCacheImage
+        
+    def initialize(image)
+      @urls = {}
+      image.styles.each do |style|                  
+        @urls[style[0].to_s] = image.url(style[0])
+      end      
+      #puts "--------------------------------------------"
+      #puts "Caboose::BlockCacheImage.initialize"
+      #puts "urls = #{@urls.inspect}"
+      #puts "--------------------------------------------"
+    end
+    
+    def url(style = nil)
+      #puts "--------------------------------------------"
+      #puts "Caboose::BlockCacheImage.url"
+      #puts "urls = #{@urls.inspect}"
+      #puts "--------------------------------------------"
+      
+      return @urls['thumb'] if style.nil?
+      return @urls[style.to_s]
+    end
+    
+    def marshal_dump
+      arr = []
+      if @urls && @urls.count > 0
+        @urls.each do |k,v|                    
+          arr << k
+          arr << v
+        end
+      end      
+      return arr
+    end
+    
+    def marshal_load arr
+      @urls = {}
+      i = 0
+      count = arr.count
+      while i<count
+        k = arr[i]
+        @urls[k] = arr[i+1]
+        i = i + 2        
+      end      
+      #puts "--------------------------------------------"
+      #puts "Caboose::BlockCacheImage.marshal_load"
+      #puts "urls = #{@urls.inspect}"
+      #puts "--------------------------------------------"
+    end
+    
+  end
+end