hancock_cms_cache 1.0.2

data/lib/generators/hancock/cache/config/config_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators'
+
+module Hancock::Cache
+  class ConfigGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc 'Hancock::Cache Config generator'
+    def config
+      template 'hancock_cache.erb', "config/initializers/hancock_cache.rb"
+    end
+
+  end
+end

data/lib/generators/hancock/cache/config/templates/hancock_cache.erb

@@ -0,0 +1,14 @@
+Hancock::Cache.configure do |config|
+  ##### defaults #####
+  #
+  # config.localize = Hancock.config.localize
+  #
+  # config.runtime_cache_detector = false
+  #
+  # config.preloaded_fragments = []
+  # config.preloaded_fragments += [
+  #   {name: 'keyname', desc: 'desc', overwrite: true},
+  #   {name: 'no overwrited key', desc: 'desc', overwrite: false}
+  # ]
+  # config.preloaded_fragments << {name: 'somekey', parents: ['keyname']}
+end

data/lib/generators/hancock/cache/models/decorators_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators'
+
+module Hancock::Cache::Models
+  class DecoratorsGenerator < Rails::Generators::Base
+    source_root File.expand_path('../../../../../../app/models/concerns/hancock/cache/decorators', __FILE__)
+    argument :models, type: :array, default: []
+
+    desc 'Hancock::Cache Models decorators generator'
+    def decorators
+      copied = false
+      (models == ['all'] ? permitted_models : models & permitted_models).each do |c|
+        copied = true
+        copy_file "#{c}.rb", "app/models/concerns/hancock/cache/decorators/#{c}.rb"
+      end
+      puts "U need to set models`s name. One of this: #{permitted_models.join(", ")}." unless copied
+    end
+
+    private
+    def permitted_models
+      ['fragment']
+    end
+
+  end
+end

data/lib/generators/hancock/cache/models/fragment_generator.rb

@@ -0,0 +1,39 @@
+require 'rails/generators'
+
+module Hancock::Goto::Models
+  class TransferGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :class_name_arg, type: :string, default: ""
+
+    desc 'Hancock::Goto Transfer Model generator'
+    def transfer
+      template 'transfer.erb', "app/models/#{file_name}.rb"
+    end
+
+    private
+    def class_name
+      class_name_arg.blank? ? "SetClassForTransfer" : class_name_arg
+    end
+
+    def capitalized_class_name
+      class_name.capitalize
+    end
+
+    def camelcased_class_name
+      class_name.camelcase
+    end
+
+    def file_name
+      underscored_class_name
+    end
+
+    def underscored_class_name
+      camelcased_class_name.underscore
+    end
+
+    def underscored_pluralized_class_name
+      underscored_class_name.pluralize
+    end
+
+  end
+end

data/lib/generators/hancock/cache/models/templates/fragment.erb

@@ -0,0 +1,38 @@
+class <%= camelcased_class_name %> < Hancock::Cache::Fragment
+
+  ############ rails_admin ##############
+  def self.rails_admin_name_synonyms
+    "Кеш Кэш".freeze
+  end
+  def self.rails_admin_navigation_icon
+    ''.freeze
+  end
+
+  def self.rails_admin_add_fields
+    [] #super
+  end
+
+  def self.rails_admin_add_config(config)
+    #super(config)
+  end
+
+  def self.admin_can_user_defined_actions
+    [].freeze
+  end
+  def self.admin_cannot_user_defined_actions
+    [].freeze
+  end
+  def self.manager_can_user_defined_actions
+    [].freeze
+  end
+  def self.manager_cannot_user_defined_actions
+    [].freeze
+  end
+  def self.rails_admin_user_defined_visible_actions
+    [].freeze
+  end
+
+  rails_admin(&Hancock::Cache::Admin::Fragment.config(rails_admin_add_fields) { |config|
+    rails_admin_add_config(config)
+  })
+end

data/lib/hancock/cache/admin.rb

@@ -0,0 +1,37 @@
+module Hancock::Cache
+  module Admin
+
+    def self.caching_block(is_active = false, options = {})
+      if is_active.is_a?(Hash)
+        is_active, options = (is_active[:active] || false), is_active
+      end
+
+      Proc.new {
+        active is_active
+        label options[:label] || I18n.t('hancock.cache')
+        field :perform_caching, :toggle
+        field :cache_keys_str, :text do
+          searchable true
+        end
+        field :cache_fragments do
+          read_only true
+          formatted_value do
+            bindings and bindings[:object] and bindings[:object].cache_fragments.all.to_a.map do |_frag|
+              bindings[:view].link_to(
+                _frag.name,
+                bindings[:view].show_path(model_name: _frag.rails_admin_model, id: _frag.id),
+              )
+            end.join(", ").html_safe
+          end
+        end
+
+        Hancock::RailsAdminGroupPatch::hancock_cms_group(self, options[:fields] || {})
+
+        if block_given?
+          yield self
+        end
+      }
+    end
+
+  end
+end

data/lib/hancock/cache/admin/fragment.rb

@@ -0,0 +1,140 @@
+module Hancock::Cache
+  module Admin
+    module Fragment
+      def self.config(fields = {})
+        Proc.new {
+          navigation_label I18n.t('hancock.cache')
+
+          list do
+            field :enabled, :toggle
+            field :is_action_cache do
+              read_only true
+            end
+
+            field :name_n_desc_n_parents
+            # field :name_n_desc
+            field :name do
+              visible false
+              searchable true
+            end
+            field :desc do
+              visible false
+              searchable true
+            end
+
+            field :data do
+              pretty_value do
+                bindings[:object].data(false)
+              end
+            end
+
+            field :last_clear_data
+            field :last_clear_time do
+              visible false
+              searchable false
+            end
+            field :last_clear_user do
+              visible false
+              searchable false
+            end
+
+            field :on_ram, :toggle
+            field :is_html, :toggle
+            field :virtual_path do
+              searchable true
+            end
+
+            field :snapshot_data
+            field :snapshot do
+              visible false
+              searchable true
+              pretty_value do
+                bindings[:object].get_snapshot(false)
+              end
+              queryable true
+            end
+            field :last_dump_snapshot_time do
+              visible false
+            end
+            field :last_restore_snapshot_time do
+              visible false
+            end
+
+            scopes [nil, :is_action_cache, :on_ram]
+          end
+
+          edit do
+            field :enabled, :toggle
+            field :is_action_cache do
+              read_only true
+            end
+            field :on_ram, :toggle
+            field :name
+            field :virtual_path
+            field :is_html, :toggle
+            field :desc
+            field :parents, :hancock_multiselect
+
+            field :last_clear_time do
+              read_only true
+            end
+            field :last_clear_user do
+              read_only true
+            end
+            field :data do
+              read_only true
+            end
+
+            field :snapshot do
+              pretty_value do
+                bindings[:object].get_snapshot
+              end
+              read_only do
+                render_object = (bindings[:controller] || bindings[:view])
+                !(render_object and render_object.current_user.admin?)
+              end
+            end
+            field :last_dump_snapshot_time do
+              read_only true
+            end
+            field :last_restore_snapshot_time do
+              read_only true
+            end
+          end
+
+          show do
+            field :enabled, :toggle
+            field :is_action_cache do
+              read_only true
+            end
+            field :on_ram, :toggle
+            field :name
+            field :virtual_path
+            field :is_html
+            field :desc
+            field :parents
+            field :parent_names do
+              visible do
+                render_object = (bindings[:controller] || bindings[:view])
+                (render_object and render_object.current_user.admin?)
+              end
+            end
+            field :last_clear_time
+            field :last_clear_user
+            field :data
+
+            field :snapshot do
+              pretty_value do
+                bindings[:object].get_snapshot
+              end
+            end
+            field :last_dump_snapshot_time
+            field :last_restore_snapshot_time
+          end
+        }
+
+      end #def self.config(fields = {})
+
+    end #module Fragment
+  end #module Admin
+end #module Hancock::Cache

data/lib/hancock/cache/configuration.rb

@@ -0,0 +1,38 @@
+module Hancock::Cache
+  include Hancock::PluginConfiguration
+
+  def self.config_class
+    Configuration
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  class Configuration
+
+    attr_accessor :localize
+
+    attr_accessor :runtime_cache_detector
+
+    attr_accessor :model_settings_support
+    attr_accessor :user_abilities_support
+    attr_accessor :ra_comments_support
+
+    attr_accessor :preloaded_fragments
+
+    def initialize
+
+      @localize = Hancock.config.localize
+
+      @runtime_cache_detector = false
+
+      @model_settings_support = !!defined?(RailsAdminModelSettings)
+      @user_abilities_support = !!defined?(RailsAdminUserAbilities)
+      @ra_comments_support = !!defined?(RailsAdminComments)
+
+      @preloaded_fragments = []
+
+    end
+  end
+end

data/lib/hancock/cache/engine.rb

@@ -0,0 +1,20 @@
+module Hancock
+  module Cache
+    class Engine < ::Rails::Engine
+      # isolate_namespace Hancock::Cache
+
+      initializer "RailsAdminSettingsPatch (cache)" do
+        if defined?(RailsAdminSettings)
+          ::RailsAdminSettings::Setting.send(:include, Hancock::Cache::RailsAdminSettingsPatch)
+        end
+      end
+
+      initializer "LookupContext Patch" do
+        ActionView::LookupContext.register_detail(:hancock_cache_keys) do
+          []
+        end
+      end
+
+    end
+  end
+end

data/lib/hancock/cache/models/fragment.rb

@@ -0,0 +1,310 @@
+module Hancock::Cache
+  module Models
+    module Fragment
+      extend ActiveSupport::Concern
+      include Hancock::Model
+      include Hancock::Enableable
+
+      include Hancock::Cache::Loadable
+
+      include Hancock::Cache.orm_specific('Fragment')
+
+      included do
+
+        include Hancock::Cache::ClearedStack
+
+        def self.rails_admin_name
+          self.name.gsub("::", "~").underscore
+        end
+
+        if Hancock::Cache.config.model_settings_support
+          include RailsAdminModelSettings::ModelSettingable
+        end
+
+        # def set_last_clear_user(forced_user = nil)
+        #   self.last_clear_user = forced_user if forced_user
+        # end
+        def set_last_clear_user!(forced_user = nil)
+          self.set_last_clear_user(f_nameorced_user) and self.save
+        end
+
+        def clear_dry(forced_user = nil)
+          if self.set_last_clear_user(forced_user)
+            self.last_clear_time = Time.new
+            self
+          end
+        end
+        def clear_dry!(forced_user = nil)
+          self.clear_dry(forced_user) and self.save
+        end
+
+        def clear(forced_user = nil)
+          return nil if self.is_in_cleared_stack?
+          if self.set_last_clear_user(forced_user)
+            Rails.cache.delete(self.name)
+            self.on_ram_data = nil
+            self.last_clear_time = Time.new
+            self.add_to_cleared_stack
+            self.parents.each { |p| p.clear(forced_user) }
+            self.drop_cleared_stack_if_can
+            self
+          end
+        end
+        def clear!(forced_user = nil)
+          return nil if self.is_in_cleared_stack?
+          if self.set_last_clear_user(forced_user)
+            Rails.cache.delete(self.name)
+            self.on_ram_data = nil
+            self.last_clear_time = Time.new
+            self.add_to_cleared_stack
+            self.parents.each { |p| p.clear(forced_user) }
+            self.drop_cleared_stack_if_can
+            self.save
+          end
+        end
+
+        def name_from_view=(_name)
+          self.name = name_from_view(_name)
+        end
+        def self.name_from_view(_name)
+          if _name.is_a?(Array)
+            ret = _name.map { |n| name_from_view(n) }
+          else
+            ret = "views/#{_name}"
+            ret = "#{ret}index" if ret[-1] == "/"
+          end
+          ret
+        end
+
+        def self.create_unless_exists(_name, _desc = nil, _virtual_path = "", overwrite = :append)
+          if _name.is_a?(Hash)
+            _name, _desc, _virtual_path, overwrite, parents, on_ram, is_action_cache =
+            _name[:name], _name[:desc], (_name[:_virtual_path] || ""), _name[:overwrite], _name[:parents], _name[:on_ram], _name[:is_action_cache]
+          end
+          on_ram ||= false
+          is_action_cache ||= false
+
+          if _name.is_a?(Array)
+            return _name.map do |n|
+              create_unless_exists(n, _desc, _virtual_path, overwrite) unless n.blank?
+            end
+          end
+
+          unless _name.blank?
+            if Hancock::Cache::Fragment.where(name: _name).count == 0
+              if parents
+                if parents.first.is_a?(String)
+                  parents = Hancock::Cache::Fragment.by_name(parents).distinct(:_id)
+                else
+                  parents = parents.map(&:_id).uniq.compact
+                end
+              end
+              frag = Hancock::Cache::Fragment.create(name: _name, desc: _desc, virtual_path: _virtual_path, parent_ids: parents, on_ram: on_ram, is_action_cache: is_action_cache)
+            else
+              frag = Hancock::Cache::Fragment.where(name: _name).first
+              if overwrite.is_a?(Symbol) or overwrite.is_a?(String)
+                case overwrite.to_sym
+                when :append
+                  frag.desc = "\n#{_desc}" unless frag.desc == _desc
+                  frag.virtual_path += "\n#{_virtual_path}" unless frag.virtual_path.strip == _virtual_path.strip
+                  if parents
+                    if parents.first.is_a?(String)
+                      frag.parent_ids += Hancock::Cache::Fragment.by_name(parents).distinct(:_id)
+                    else
+                      frag.parent_ids += parents.map(&:_id).uniq.compact
+                    end
+                  end
+                  frag.on_ram = on_ram
+                  frag.is_action_cache = is_action_cache
+                  frag = frag.save and frag
+
+                when :overwrite
+                  frag.desc = _desc
+                  frag.virtual_path = _desc
+                  if parents
+                    if parents.first.is_a?(String)
+                      frag.parent_ids = Hancock::Cache::Fragment.by_name(parents).distinct(:_id)
+                    else
+                      frag.parent_ids = parents.map(&:_id)
+                    end
+                    frag.parent_ids.uniq!
+                    frag.parent_ids.compact!
+                  end
+                  frag.on_ram = on_ram
+                  frag.is_action_cache = is_action_cache
+                  frag = frag.save and frag
+                end #case overwrite.to_sym
+              else
+                if overwrite
+                  frag.desc = _desc
+                  frag.virtual_path = _desc
+                  if parents
+                    if parents.first.is_a?(String)
+                      frag.parent_ids = Hancock::Cache::Fragment.by_name(parents).distinct(:_id)
+                    else
+                      frag.parent_ids = parents.map(&:_id).uniq.compact
+                    end
+                  end
+                  frag.on_ram = on_ram
+                  frag.is_action_cache = is_action_cache
+                  frag = frag.save and frag
+                end
+              end #if overwrite.is_a?(Symbol) or overwrite.is_a?(String)
+            end #if Hancock::Cache::Fragment.where(name: _name).count == 0
+
+            frag
+          end #unless _name.blank?
+        end
+
+        def self.load_from_preloaded
+          Hancock::Cache.config.preloaded_fragments.map do |f_data|
+            Hancock::Cache::Fragment.create_unless_exists(f_data)
+          end
+        end
+
+        def self.clear_all(forced_user = nil)
+          self.all.to_a.map { |c| c.clear!(forced_user) }
+        end
+
+
+        def get_as_hash(overwrite = nil)
+          {
+            name: self.name,
+            desc: self.desc,
+            virtual_path: self.virtual_path,
+            parents: self.parents.map(&:name),
+            on_ram: self.on_ram,
+            is_action_cache: self.is_action_cache,
+            overwrite: overwrite
+          }.compact
+        end
+        def get_as_json(overwrite = nil)
+          get_as_hash(overwrite).to_json
+        end
+        def self.get_as_hash(overwrite = nil)
+          Hancock::Cache::Fragment.cutted.all.to_a.map { |f| f.get_as_hash(overwrite) }
+        end
+        def self.get_as_json(overwrite = nil)
+          Hancock::Cache::Fragment.cutted.all.to_a.map { |f| f.get_as_json(overwrite) }
+        end
+
+        # worse but working
+        def self.copy_preloaded_to_config_file(fname = "config/initializers/hancock_cache.rb")
+          File.truncate(fname, File.size(fname) - 4)
+          File.open(fname, 'a') do |file|
+            file.write "  config.preloaded_fragments = [\n    #{Hancock::Cache::Fragment.get_as_json.join(",\n    ")}\n  ]\n  # Hancock::Cache::Fragment.load_from_preloaded\n  # Hancock::MODELS.map { |m| m.respond_to?(:set_default_cache_keys!) and m.set_default_cache_keys! }\nend"
+          end
+        end
+        def self.copy_new_preloaded_to_config_file(fname = "config/initializers/hancock_cache.rb")
+          File.truncate(fname, File.size(fname) - 4)
+          _text = Hancock::Cache::Fragment.where(:name.nin => Hancock::Cache.config.preloaded_fragments.map { |f|
+            f[:name]
+          }).all.to_a.map { |f|
+            f.get_as_json(false)
+          }.join(",\n    ")
+          File.open(fname, 'a') do |file|
+            file.write "  config.preloaded_fragments += [\n    #{_text}\n  ]\n  # Hancock::Cache::Fragment.load_from_preloaded\n  # Hancock::MODELS.map { |m| m.respond_to?(:set_default_cache_keys!) and m.set_default_cache_keys! }\nend"
+          end
+        end
+
+
+        def set_for_object(obj)
+          return set_for_objects(obj) if obj.is_a?(::Array)
+          return set_for_model(obj.klass, true) if obj.is_a?(::Mongoid::Criteria)
+          obj and
+            obj.fields.keys.include?(:cache_keys_str) and obj.respond_to?(:cache_keys) and
+            !obj.cache_keys.include?(self.name) and
+            obj.class.where(id: obj.id).update(cache_keys_str: "#{obj.cache_keys_str}\n#{self.name}".strip)
+        end
+        def set_for_objects(objs)
+          if objs
+            objs.map do |obj|
+              set_for_object(obj)
+            end
+          end
+        end
+        def set_for_model(model, as_forced = false)
+          return set_for_models(model, as_forced) if model.is_a?(::Array)
+          if model
+            if as_forced and model.respond_to :add_forced_cache_key
+              model.send(:add_forced_cache_key, self.name) unless model.forced_cache_key.include?(self.name)
+            else
+              set_for_objects(model.not(cache_keys_str: /(^|\n)#{Regexp.escape self.name}(\n|$)/).all.to_a)
+            end
+          end
+          # model and set_for_objects(model.all.to_a)
+        end
+        def set_for_models(models, as_forced = false)
+          if models
+            models.map do |model|
+              set_for_model(model)
+            end
+          end
+        end
+        def set_for_setting(setting_obj)
+          if defined?(RailsAdminModelSettings)
+            if setting_obj.is_a?(Hash)
+              unless setting_obj[:keys].present?
+                if setting_obj[:key].nil?
+                  return set_for_setting({ns: setting_obj[:ns], key: nil})
+                else
+                  # setting_obj = RailsAdminSettings::Setting.where(ns: setting_obj[:ns], key: setting_obj[:key]).not(cache_keys_str: /(^|\n)#{Regexp.escape self.name}(\n|$)/).first
+                  setting_obj = Settings.ns(setting_obj[:ns]).getnc(setting_obj[:key])
+                end
+
+              else
+                # setting_obj = RailsAdminSettings::Setting.where(ns: setting_obj[:ns], :key.in => setting_obj[:keys]).not(cache_keys_str: /(^|\n)#{Regexp.escape self.name}(\n|$)/).all.to_a
+                return setting_obj[:keys].map do |k|
+                  # set_for_setting({ns: setting_obj[:ns], key: k}) unless k.blank?
+                  set_for_setting(Settings.ns(setting_obj[:ns]).getnc(k)) unless k.blank?
+                end
+              end
+
+            elsif setting_obj.is_a?(Array)
+              return setting_obj.map do |obj|
+                set_for_setting(obj) unless obj.blank?
+              end
+            end
+
+            setting_obj and set_for_object(setting_obj) and setting_obj.reload
+          end
+        end
+
+        def self.rails_admin_name_synonyms
+          "Кеш Кэш".freeze
+        end
+        def self.rails_admin_navigation_icon
+          ''.freeze
+        end
+
+
+        def self.manager_can_add_actions
+          ret = [:hancock_cache_clear, :hancock_cache_global_clear, :hancock_cache_dump_snapshot, :hancock_cache_restore_snapshot]
+          ret << :model_settings if Hancock::Cache.config.model_settings_support
+          # ret << :model_accesses if Hancock::Cache.config.user_abilities_support
+          # ret += [:comments, :model_comments] if Hancock::Cache.config.ra_comments_support
+          ret.freeze
+        end
+        def self.rails_admin_add_visible_actions
+          ret = [:hancock_cache_clear, :hancock_cache_global_clear, :hancock_cache_dump_snapshot, :hancock_cache_restore_snapshot]
+          ret << :model_settings if Hancock::Cache.config.model_settings_support
+          ret << :model_accesses if Hancock::Cache.config.user_abilities_support
+          # ret += [:comments, :model_comments] if Hancock::Cache.config.ra_comments_support
+          ret.freeze
+        end
+
+        after_touch :reload_fragments
+        after_save :reload_fragments
+        after_destroy :reload_fragments
+        protected
+        def reload_fragments
+          if ::ApplicationController.respond_to?(:reload_fragments)
+            ::ApplicationController.reload_fragments
+          end
+        end
+
+      end
+
+    end
+  end
+end