hancock_cms_cache 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8924cc51d91eba2c74ffdbc5653ece7445b465dd
+  data.tar.gz: 64e32fb9925538ad64d541b54130e3932ada290c
+SHA512:
+  metadata.gz: '0802fed32cfd539c32ee4d046e11b8261ebc821524a2f620c9e3a519878c8471c54a12858013e518cdc00fc13cb8b4fef9b309836c2b121e16cc61eec333679b'
+  data.tar.gz: 4db3c7530a071c6f63cb5ac17d0fb07cfb821837fef54af39805a433756429cb29aa93120886ee075b874ebc9f911e544afd16c0083230d0e3f28684364de876

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-gemset

@@ -0,0 +1 @@
+hancock_cms_cache

data/.ruby-version

@@ -0,0 +1 @@
+2.3.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hancock_cms_cache.gemspec
+gemspec

data/README.md

@@ -0,0 +1,35 @@
+# HancockCmsCache
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/hancock/cache`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hancock_cms_cache'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hancock_cms_cache
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/red-rocks/hancock_cms_cache.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/app/assets/javascripts/hancock/rails_admin/plugins/cache.coffee

@@ -0,0 +1,4 @@
+#= require_self
+#= require "hancock/rails_admin/plugins/cache/custom/ui"
+
+window.hancock.plugins.cache ||= {}

data/app/assets/stylesheets/hancock/rails_admin/plugins/cache.sass

@@ -0,0 +1,3 @@
+
+
+@import "hancock/rails_admin/plugins/cache/custom/theming"

data/app/controllers/concerns/hancock/cache/action.rb

@@ -0,0 +1,58 @@
+module Hancock::Cache::Action
+  extend ActiveSupport::Concern
+
+  included do
+    def page_cache_key
+      "pages/#{controller_name}_#{action_name}" if (params.keys - ["controller", "action", "rack.session"]).blank?
+    end
+    def page_cache_obj
+      return @page_cache_obj unless @page_cache_obj.nil?
+      _name = page_cache_key
+      _desc = <<-TEXT
+        action caching
+        controller: #{controller_name}
+        action: #{action_name}
+        params: #{params.inspect}
+      TEXT
+      @page_cache_obj = Hancock::Cache::Fragment.create_unless_exists(name: Hancock::Cache::Fragment.name_from_view(_name), desc: _desc, is_action_cache: true)
+    end
+
+    def hancock_stale?(obj, opts = {})
+      return if obj.nil?
+      if obj.is_a?(Hash)
+        return stale?(obj)
+      end
+      if obj
+        _last_time = opts[:last_modified]
+        if _last_time.nil?
+          _methods = ([:u_at, :updated_at, :c_at, :created_at] + (opts[:last_modified_methods] || [])).uniq
+          _methods.each do |m|
+            _last_time ||= obj.send(m) if obj.respond_to?(m)
+            break if _last_time
+          end
+          _last_time ||= Time.new
+        end
+        opts.reverse_merge!(last_modified: _last_time, etag: obj, public: true, template: false)
+        return stale?(obj)
+      end
+    end
+    alias_method :hancock_cache_stale?, :hancock_stale?
+
+    def hancock_cache_fragment_stale?(name, opts = {})
+      if name.is_a?(Hash)
+        name, opts = name.delete(:name), name
+      end
+      return if name.nil?
+      frag = hancock_cache_fragments[Hancock::Cache::Fragment.name_from_view(name)]
+      if frag
+        opts.reverse_merge!(last_modified: frag.last_clear_time, etag: frag, public: true, template: false)
+        hancock_stale?(frag, opts.compact)
+      else
+        true
+      end
+    end
+
+    helper_method :page_cache_key, :page_cache_obj
+  end
+
+end

data/app/controllers/concerns/hancock/cache/ajax_csrf.rb

@@ -0,0 +1,25 @@
+module Hancock::Cache::AjaxCsrf
+  extend ActiveSupport::Concern
+
+  included do
+    include Hancock::Cache::NoCache      
+    skip_before_action :find_page, only: [:csrf_meta]
+
+    def csrf_meta
+
+      set_cache_buster
+      # expires_now
+      # response.headers["Pragma"] = "no-cache"
+
+      respond_to do |format|
+        format.json do
+          render json: {
+            param: request_forgery_protection_token,
+            token: form_authenticity_token
+          }
+        end
+      end
+    end
+  end
+
+end

data/app/controllers/concerns/hancock/cache/fragments.rb

@@ -0,0 +1,34 @@
+module Hancock::Cache::Fragments
+  extend ActiveSupport::Concern
+  included do
+    @@hancock_cache_fragments = nil
+    # before_action :load_fragments
+
+    helper_method :hancock_cache_fragments
+    def hancock_cache_fragments(reload = false)
+      # @hancock_cache_fragments ||= Hancock::Cache::Fragment.cutted.all.to_a.map { |f| [f.name, f] }.to_h
+      if reload
+        Hancock::Cache::Fragment.reload!
+        @@hancock_cache_fragments = Hancock::Cache::Fragment.loaded_info
+      elsif Hancock::Cache::Fragment.loaded
+        @@hancock_cache_fragments ||= Hancock::Cache::Fragment.loaded_info
+      else
+        Hancock::Cache::Fragment.load!
+        @@hancock_cache_fragments = Hancock::Cache::Fragment.loaded_info
+      end
+      @@hancock_cache_fragments
+    end
+  end
+
+  class_methods do
+    def reload_fragments
+      Hancock::Cache::Fragment.reload!
+      @@hancock_cache_fragments = Hancock::Cache::Fragment.loaded_info
+    end
+  end
+
+  protected
+  def load_fragments
+    hancock_cache_fragments(true)
+  end
+end

data/app/controllers/concerns/hancock/cache/no_cache.rb

@@ -0,0 +1,12 @@
+module Hancock::Cache::NoCache
+  extend ActiveSupport::Concern
+  included do
+    # before_action :set_cache_buster
+  end
+
+  protected
+  def set_cache_buster
+    expires_now()
+    response.headers["Pragma"] = "no-cache"
+  end
+end

data/app/helpers/hancock/cache/cache_helper.rb

@@ -0,0 +1,167 @@
+module Hancock
+  module Cache
+    module CacheHelper
+
+      def hancock_cache_settings(key, options = {}, &block)
+        if key.is_a?(Hash)
+          key, options = key[:key], key
+        end
+
+        cache_keys = options[:cache_keys_str] || options[:cache_keys] || options[:cache_key] || []
+        if cache_keys.is_a?(::Array)
+          cache_keys = cache_keys.map { |k| k.to_s.strip }.join(" ")
+        else
+          cache_keys = cache_keys.to_s.strip
+        end
+        options.delete(:cache_keys)
+        options.delete(:cache_key)
+        options[:cache_keys_str] = [cache_keys, hancock_cache_views_keys].flatten.map { |k| k.to_s.strip }.reject(&:blank?).join(" ").strip
+
+        hancock_settings(key, options, &block)
+      end
+      alias_method :hancock_cache_setting, :hancock_cache_settings
+
+
+      def hancock_cache(obj = @virtual_path, options = {}, &block)
+        if obj.is_a?(String) or obj.is_a?(Symbol)
+          return hancock_fragment_cache obj.to_s, (options || {}).merge(skip_digest: true), &block
+
+        else
+          condition = Array(obj).map { |o|
+            !o.respond_to?(:perform_caching) or o.perform_caching
+          }
+
+          if obj.respond_to?(:cache_keys_str) and obj.respond_to?(:cache_keys) and obj.respond_to?(:cache_keys=)
+            obj.cache_keys |= hancock_cache_views_keys
+            obj.save if obj.cache_keys_str_changed?
+          end
+
+          condition = (condition.blank? or condition.uniq == [true])
+          cache_if condition, obj, options, &block
+        end
+      end
+      def hancock_cache_unless(condition, obj = [], options = {}, &block)
+        hancock_cache_if !condition, obj, options, &block
+      end
+      def hancock_cache_if(condition, obj = [], options = {}, &block)
+        if condition
+          hancock_cache obj, options, &block
+        else
+          yield
+        end
+        nil
+      end
+
+      def hancock_fragment_cache(name = @virtual_path, options = {skip_digest: true}, &block)
+        if name.is_a?(Hash)
+          name, options = name.delete(:name), name
+        end
+        name = @virtual_path if name.blank?
+        for_object  = (options and options.delete(:for_object))
+        for_objects = (options and options.delete(:for_objects))
+        for_model   = (options and options.delete(:for_model))
+        for_setting = (options and options.delete(:for_setting))
+        _on_ram     = (options and options.delete(:on_ram))
+
+        # if Hancock::Cache.config.model_settings_support
+        #   _detect_cache = !!(Hancock::Cache.config.runtime_cache_detector || Hancock::Cache::Fragment.settings.detecting)
+        # else
+        #   _detect_cache = !!(Hancock::Cache.config.runtime_cache_detector || Settings.hancock_cache_detecting)
+        # end
+        _detect_cache = true
+
+        if respond_to?(:hancock_cache_fragments)
+          frag = hancock_cache_fragments[Hancock::Cache::Fragment.name_from_view(name)]
+          # parents = hancock_cache_keys.map do |_name|
+          #   hancock_cache_fragments[Hancock::Cache::Fragment.name_from_view(_name)]
+          # end.compact
+          parent_names = hancock_cache_views_keys
+          if frag
+            frag.set_for_object(for_object) if for_object
+            frag.set_for_objects(for_objects) if for_objects
+            frag.set_for_model(for_model) if for_model
+            frag.set_for_setting(for_setting) if for_setting
+            if _detect_cache
+              frag.parent_names |= parent_names
+              if frag.parent_names_changed?
+                # frag.set_parent_ids! and hancock_cache_fragments[frag.name] = frag
+                frag.update_parent_ids! and hancock_cache_fragments[frag.name] = frag.reload
+              end
+            end
+          else
+            if _detect_cache
+              _name = Hancock::Cache::Fragment.name_from_view(name)
+              _desc = "" #"#{@virtual_path}\noptions: #{options}"
+              _virtual_path = @virtual_path
+              # Hancock::Cache::Fragment.create_unless_exists(name: _name, desc: _desc, virtual_path: _virtual_path, parents: parents)
+              Hancock::Cache::Fragment.create_unless_exists(name: _name, desc: _desc, virtual_path: _virtual_path, parent_names: parent_names, on_ram: _on_ram)
+              Hancock::Cache::Fragment.reload!
+              frag = hancock_cache_fragments[_name]
+            end
+          end
+          condition = (frag and frag.enabled)
+        else
+          if _detect_cache
+            # parents = Hancock::Cache::Fragment.by_name_from_view(hancock_cache_keys).to_a
+            # _name = Hancock::Cache::Fragment.name_from_view(name)
+            # _desc = "" #"#{@virtual_path}\noptions: #{options}"
+            # _virtual_path = @virtual_path
+            # Hancock::Cache::Fragment.create_unless_exists(name: _name, desc: _desc, virtual_path: _virtual_path, parents: parents)
+            # Hancock::Cache::Fragment.reload!
+            # frag.parent_names |= parent_names
+            # if frag.parent_names_changed?
+            #   # frag.set_parent_ids! and hancock_cache_fragments[frag.name] = frag
+            #   frag.update_parent_ids! and hancock_cache_fragments[frag.name] = frag
+            # end
+          end
+          condition = Hancock::Cache::Fragment.enabled.by_name_from_view(name).count > 0
+        end
+        if frag and frag.on_ram and !frag.on_ram_data.nil?
+          ret = frag.on_ram_data
+        else
+          lookup_context.hancock_cache_keys << name
+          ret = cache_if condition, name, options, &block
+          frag.on_ram_data = ret if frag and frag.on_ram
+          lookup_context.hancock_cache_keys.delete(name)
+        end
+        return ret
+      end
+      def hancock_fragment_cache_unless(condition, obj = [], options = {}, &block)
+        hancock_fragment_cache_if !condition, obj, options, &block
+      end
+      def hancock_fragment_cache_if(condition, obj = [], options = {}, &block)
+        if condition
+          hancock_fragment_cache obj, options, &block
+        else
+          yield
+        end
+        nil
+      end
+
+      def hancock_cache_keys
+        ret = lookup_context.hancock_cache_keys.dup
+
+        if respond_to?(:page_cache_key) and !page_cache_key.blank?
+          if (!respond_to?(:page_cache_obj) or page_cache_obj.nil?)
+            _name = page_cache_key
+            _desc = <<-TEXT
+              action caching
+              controller: #{controller_name}
+              action: #{action_name}
+              params: #{params.inspect}
+            TEXT
+            Hancock::Cache::Fragment.create_unless_exists(name: Hancock::Cache::Fragment.name_from_view(_name), desc: _desc)
+          end
+          ret.unshift page_cache_key
+        end
+
+        ret.uniq.freeze
+      end
+
+      def hancock_cache_views_keys
+        hancock_cache_keys.map { |k| Hancock::Cache::Fragment.name_from_view(k) }
+      end
+
+    end
+  end
+end

data/app/models/concerns/hancock/cache/cacheable.rb

@@ -0,0 +1,164 @@
+if Hancock.mongoid?
+
+  module Hancock::Cache::Cacheable
+    extend ActiveSupport::Concern
+
+    included do
+      field :cache_keys_str, type: String, default: -> { default_cache_keys.map(&:strip).join("\n") }
+      def self.default_cache_keys
+        []
+      end
+      def default_cache_keys
+        self.class.default_cache_keys
+      end
+      def set_default_cache_keys(strategy = :append)
+        _old_keys = cache_keys
+
+        _keys = case strategy.to_sym
+        when :append
+          (_old_keys + default_cache_keys).uniq
+        when :overwrite, :replace
+          default_cache_keys
+        else
+          _old_keys
+        end
+        self
+      end
+      def set_default_cache_keys!(strategy = :append)
+        self.set_default_cache_keys(strategy) and self.save
+      end
+      def self.set_default_cache_keys(strategy = :append)
+        self.all.to_a.map { |obj| obj.set_default_cache_keys(strategy) }
+      end
+      def self.set_default_cache_keys!(strategy = :append)
+        self.all.to_a.map { |obj| obj.set_default_cache_keys!(strategy) }
+      end
+
+      def conditional_cache_keys
+        [{}]
+      end
+      def conditional_cache_keys_names
+        conditional_cache_keys.map { |k| k[:name] }.compact
+      end
+      def selected_conditional_cache_keys
+        conditional_cache_keys and conditional_cache_keys.select { |cache_key|
+          false if cache_key[:name].blank?
+          cond_if, cond_unless = cache_key[:if], cache_key[:unless]
+
+          if cond_if
+            if cond_if.is_a?(Proc)
+              cond_if = !!cond_if.call
+            elsif cond_if.is_a?(String)
+              cond_if = !!self.instance_eval(cond_if)
+            else
+              cond_if = !!cond_if
+            end
+          else
+            cond_if = true
+          end
+
+          if cond_unless
+            if cond_unless.is_a?(Proc)
+              cond_unless = !cond_unless.call
+            elsif cond_unless.is_a?(String)
+              cond_unless = !self.instance_eval(cond_unless)
+            else
+              cond_unless = !cond_unless
+            end
+          else
+            cond_unless = true
+          end
+
+          cond_if and cond_unless
+        } or []
+      end
+      def selected_conditional_cache_keys_names
+        selected_conditional_cache_keys.map { |k| k[:name] }.compact
+      end
+
+      class_attribute :forced_cache_keys
+      self.forced_cache_keys ||= []
+
+      def self.add_forced_cache_key(key)
+        key = key.to_s
+        self.forced_cache_keys << key unless self.forced_cache_keys.include?(key)
+      end
+      def self.remove_forced_cache_key(key)
+        self.forced_cache_keys.delete(key.to_s)
+      end
+
+      def all_cache_keys(cached = true)
+        # return @all_cache_keys if @all_cache_keys
+        if cached
+          @all_cache_keys = cache_keys || []
+          @all_cache_keys += (forced_cache_keys || [])
+          @all_cache_keys += selected_conditional_cache_keys_names
+          @all_cache_keys
+        else
+          (cache_keys || []) + selected_conditional_cache_keys_names
+        end
+      end
+
+
+      def cache_keys
+        # return @cache_keys if @cache_keys
+
+        self.cache_keys_str ||= ""
+        # @cache_keys = cache_keys_str.split(/\s+/).map { |k| k.strip }.reject { |k| k.blank? }
+        self.cache_keys_str.split(/\s+/).map { |k| k.strip }.reject { |k| k.blank? }
+      end
+      def cache_keys=(_keys)
+        _keys ||= []
+        self.cache_keys_str = _keys.select { |k|
+          k and !k.strip.blank?
+        }.map(&:strip).uniq.join("\n")
+        cache_keys
+      end
+      field :perform_caching, type: Boolean, default: true
+
+      def cache_fragments
+        Hancock::Cache::Fragment.where(:name.in => cache_keys)
+      end
+      def all_cache_fragments
+        Hancock::Cache::Fragment.where(:name.in => all_cache_keys(false))
+      end
+
+      def reset_cache_keys
+        self.cache_keys = cache_fragments.distinct(:name)
+      end
+      def reset_cache_keys!
+        self.reset_cache_keys and self.save
+      end
+      def self.reset_cache_keys!
+        self.all.map(&:reset_cache_keys!)
+      end
+
+      attr_accessor :cache_cleared
+
+      after_touch :clear_cache
+      after_save :clear_cache
+      after_destroy :clear_cache
+      def clear_cache
+        if perform_caching and !cache_cleared
+          # (cache_keys and cache_keys.is_a?(Array) and cache_keys).compact.map(&:strip).uniq.each do |k|
+          (all_cache_keys and all_cache_keys.is_a?(Array) and all_cache_keys).compact.map(&:strip).uniq.each do |k|
+            unless k.blank?
+              k = k.strip
+              if _frag = Hancock::Cache::Fragment.where(name: k).first
+                _frag.clear!
+              else
+                Rails.cache.delete(k)
+              end
+            end
+          end
+          # @cache_keys = nil
+          @all_cache_keys = nil
+
+          cache_cleared = true
+        end
+      end
+
+    end
+  end
+
+end