3d_cache 0.0.01a

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f45725b17348a1882662ca8d39411362eea45a60
+  data.tar.gz: 722924ec576169736f54aaa44859a2e608fcd5cb
+SHA512:
+  metadata.gz: 480cfb10842db53c1fa0cf23bf544d16f599178739a76e68f1f6fb4234b0caf07a1d4895432647374f69acb9de677b602510024a63cab264439e0499e56bc4a7
+  data.tar.gz: 71c086fdcdaf2497a8ad422f3a72e2c3db2623476c0affcc35ce710eab17fcec7350ad7f97853d612da612e42c9e50e89f4497341a684d086cdbf90c826c4ce5

data/lib/3d_cache.rb

@@ -0,0 +1,32 @@
+#= Loading Components
+
+# Create Logger
+ThreeDCachingLog = Logger.new(STDOUT)
+
+#== ModelFragments
+# add desc here
+require "three_d/model_fragments"
+ActiveRecord::Base.send(:include, ThreeD::ModelFragments)
+ThreeDCachingLog.info "Loaded 3D::ModelFragments"
+
+#== Once!
+# Define which methods of a instance only should be computed once
+require "three_d/once"
+ActiveRecord::Base.send(:include, ThreeD::Once)
+ThreeDCachingLog.info "Loaded 3D::Once!"
+
+#== ClassMethodCache
+# Not finished yet, memcache support required
+# require "three_d/class_method_cache"
+# ActiveRecord::Base.send(:include, ThreeD::ClassMethodCache)
+
+
+
+
+# Fix the Cache File path so ist dont use crazy hashed file- and folder names
+ActiveSupport::Cache::FileStore.module_eval do
+  def key_file_path(key)
+    File.join(cache_path, key.to_s) + '.cache'
+  end
+end
+ThreeDCachingLog.info "Fixed ActiveSupport::Cache::FileStore#key_file_path"

data/lib/three_d/class_method_cache.rb

@@ -0,0 +1,217 @@
+# -*- encoding : utf-8 -*-
+module ThreeD
+module ClassMethodCache
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+
+  module ClassMethods
+
+    def activate_method_cache(methods_list = {})
+
+      if !self.method_cache_enabled?
+
+        cattr_accessor  :cached_methods
+        cattr_accessor  :cache_storage
+
+        # Setting up Cache Storage Variable
+        cache_storage_name = "$#{self.name.underscore.upcase}_METHOD_CACHE"
+        eval("#{cache_storage_name} = {}") 
+        self.cache_storage = eval(cache_storage_name)
+
+
+        self.add_cache_methods(methods_list)
+
+
+        # Instanzmethoden für den User laden
+        self.send :include,  InstanceMethods
+
+      end    
+    end  
+
+
+    def add_cache_methods(methods_list = {})
+      # Check cached methods list
+      if methods_list.is_a?(Array)
+        methods_list = {:default => methods_list}
+      end
+
+      if methods_list.is_a?(Hash)
+
+        self.cached_methods ||= {}
+
+        methods_list.each do |group, methods|
+          if self.cached_methods[group.to_sym].nil?
+            self.cached_methods[group.to_sym] = methods
+          else
+            self.cached_methods[group.to_sym] << methods
+            self.cached_methods[group.to_sym] = self.cached_methods[group.to_sym].flatten
+          end    
+        end  
+      else
+        raise ArgumentError, "Wrong definition for cached methods: Use either an array (self.cached_methods will become {:default => array}) or a hash"
+      end
+
+      setup_cache_method_aliasing
+    end  
+
+    def setup_cache_method_aliasing
+      # Setup des MethodAliasing
+      self.instance_eval do
+        self.cached_methods.each do |method_stack, methods|
+          methods.each_with_index do |method, i|
+            puts [self.name, method, self.instance_methods.include?(method.to_sym)].inspect
+              
+            # Methodennamen mit ?/!  am ende fixen - Alias anlegen
+            needs_alias = false
+            if method.to_s.last == "?"
+              fixed_name = method.to_s.gsub("?","_with_soi")
+              needs_alias = true
+            elsif method.to_s.last == "!"
+              fixed_name = method.to_s.gsub("?","_with_bang")
+              needs_alias = true
+            end
+              
+            if needs_alias
+              alias_method fixed_name, method    
+              
+              method = fixed_name
+            end
+              
+            define_method("#{method}_with_caching") do |*args|
+              #begin
+              start = Time.now
+              # Key für den Cache erzeugen - Alle Parameter mit ablegen
+              args_list = *args.flatten.map {|a| a.is_a?(ActiveRecord::Base) ? "#{a.class.name}-#{a.id}" : a}
+              meth_name = [method,args_list].inspect.parameterize.to_s
+              
+              
+              if cached?(meth_name)
+                x = self.cached_attribute(meth_name)
+              
+                # => ActiveRecordArray disabled (03.08.2013, 18:54, Florian Eck)
+                # if x.is_a?(ActiveRecordArray)
+                #                    x = x.parse_record_data
+                #                  end  
+                CachingLog.info "  ... CALL cache_data #{meth_name} (#{Time.now-start})"
+                return x
+              else
+                # Hier wird die Originalfunction aufgerufen
+                orig = self.send("#{method}_without_caching", *args)
+              
+                # => ActiveRecordArray disabled
+                #if orig.is_active_record_array?
+                #parse = orig.parse_active_record_array
+                #CachingLog.info "save ActiveRecordArray"
+                #else
+                parse = orig
+                #end    
+              
+                v = cache_attribute!(meth_name, parse)
+                CachingLog.info "  ... CREATE cache_data #{meth_name} (#{Time.now-start})"
+                    
+                return orig
+                    
+                    
+              end
+              #rescue Exception => e
+              #  self.method_cache = {:last_error => e.backtrace, :last_error_class => e.class.inspect, :last_error_message => e.message}
+              #  return nil #self.send("#{method}_without_caching", *args)
+              #end     
+              #__send__("#{method}_without_caching", *args)   
+            end
+              
+            alias_method_chain method, :caching
+          
+          end
+        end
+      end
+    end  
+
+    def method_cache_enabled?
+      self.included_modules.include?(InstanceMethods)
+    end  
+    
+  end
+
+
+  module InstanceMethods
+    def method_cache
+      m = self.class.cache_storage[self.id]
+      if m.nil?
+        # Wenn neue nutzer angelegt werden
+        CachingLog.info "Create cache for #{self.class.name}(#{self.id})"
+        self.class.cache_storage.merge!(self.id => {})
+        self.class.cache_storage[self.id]
+        return {}
+      else
+        return m
+      end    
+    end
+
+    def method_cache=(val)
+      self.class.cache_storage.merge!(self.id => val)
+    end    
+
+    def cached?(att)
+      !self.method_cache[att.to_s].nil?  
+    end
+
+    def cached_attribute(att)
+      self.method_cache[att.to_s]
+    end
+
+    def cache_attribute!(att, value)
+      m = self.method_cache.merge!(att.to_s => value)
+      #self.personal_status.update_attributes(:method_cache => m)
+      # => not using DB anymore
+      return value
+    end
+
+    # Clear methods.
+    # Kann ein Methodenname, ein Array von Namen oder ein Regexp sein
+    def clear_method_cache(meths = [], options = {})
+      if meths.is_a?(Regexp)   
+        meths = self.method_cache.keys.select {|k| !k.match(meths).nil? }
+      elsif meths.is_a?(Symbol) || meths.is_a?(String)
+        meths = self.class.cached_methods[meths.to_sym]  
+      elsif !meths.is_a?(Array)
+        meths = meths.to_a
+      end  
+
+      begin 
+        c = self.method_cache
+        meths_all = c.keys
+        meths_valid = []
+        meths.each do |m|
+          meths_all.each do |mv|
+            meths_valid << mv if mv.match(m)
+          end  
+        end  
+        CachingLog.info meths_valid.inspect
+        meths_valid.each do |m|
+          CachingLog.info "DELETE cache data: #{m}"
+          CachingLog.info  "   for #{self.personal_data.first_name} #{self.personal_data.last_name}"
+          c.delete(m)
+        end
+      rescue
+        # wenn was schief läuft: $user_method_caching für den user auf {} setzen
+        CachingLog.info "RESET CACHE (forced): #{self.full_name} / #{self.id}"
+        self.class.cache_storage[self.id] = {}
+      end  
+    end
+    
+    def reset_cache
+      self.class.cache_storage[self.id] = {}
+    end  
+
+  end    
+
+
+end  
+end
+
+
+

data/lib/three_d/model_fragments.rb

@@ -0,0 +1,53 @@
+# -*- encoding : utf-8 -*-
+module ThreeD
+  module ModelFragments
+  
+    def self.included(base)
+      base.extend ClassMethods
+    end  
+  
+    module ClassMethods
+      def model_fragments
+        unless has_model_fragments?
+          
+          if ActionController::Base.cache_store.inspect.match("FileStore")
+          
+            self.send :include, InstanceMethods
+            cattr_accessor :caching_path
+      
+            self.caching_path = ActionController::Base.cache_store.cache_path
+            self.after_save :clear_view_cache
+            self.after_destroy :clear_view_cache
+          else
+            raise "Currently, ModelFragments only support FileStore\nPlease set 'ActionController::Base.cache_store = :file_store, /path/to/cache'"
+          end    
+        end
+      end  
+    
+      def has_model_fragments?
+        self.included_modules.include?(InstanceMethods)
+      end
+    end  
+  
+    module InstanceMethods
+    
+      def cache_name(data, scope_data=nil)  
+        data = data.to_s
+        x = "#{self.class.name.parameterize}_#{self.id}_cache_#{data}"
+        x << "_#{scope_data.to_s}" if scope_data
+        return x
+      end
+    
+      def clear_view_cache(data="")
+        %x(rm #{self.full_cache_path(data)})
+      end
+    
+      def full_cache_path(data="")
+        "#{self.class.caching_path}/views/#{self.class.name.parameterize}_#{self.id}_#{data}*"
+      end  
+    
+    end  
+    
+
+  end
+end

data/lib/three_d/once.rb

@@ -0,0 +1,42 @@
+module ThreeD
+  module Once
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+    
+      def once(*ids)
+        # Auch Array kann übergeben werde
+        ids = ids.first if ids.first.is_a?(Array)
+      
+        ids.each do |id|
+          id = id.to_s
+          self.instance_eval do
+            
+            alias_method "__#{id}", id 
+            
+            define_method(id) do |*args|
+              ident_name = *args.hash.to_i
+            
+              # Use @once_cache[]
+              key_name = "#{id}_#{ident_name}_#{self.id}".gsub(/[^a-zA-Z0-9_@]/, '')
+            
+              @once_cache ||= {}
+            
+              if @once_cache[key_name].nil?
+                @once_cache[key_name] = self.send("__#{id}", *args)
+              end
+            
+              return @once_cache[key_name]
+        
+            end  
+          end  
+        end 
+      end
+    
+    end
+    
+  end
+end    

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: 3d_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.01a
+platform: ruby
+authors:
+- Florian Eck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-18 00:00:00.000000000 Z
+dependencies: []
+description: Cache results of method calls for a class in RAM
+email:
+- it-support@friends-systems.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/3d_cache.rb
+- lib/three_d/class_method_cache.rb
+- lib/three_d/model_fragments.rb
+- lib/three_d/once.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Caching shizznit
+test_files: []