smart_collection 0.2.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56a4ff13fb4cef1bbf08e862e2711100b2bbb05a
-  data.tar.gz: 40968d63c36783863e4ed8801d4aaac52361e5a4
+  metadata.gz: 7106929dd8e41780fb988dd9aeb82d4b82e115cb
+  data.tar.gz: 689310ec89a9971a06ac74df1eaa8f27a7aef3a3
 SHA512:
-  metadata.gz: f8041e8ae524fbd3fbcba902a6c89ea1fab57e52eef225550c4503bbb2d86a7c2c2bc747fd1b9d774ecc63b255213c0591ea07ac3606c59003b553d287f56cb7
-  data.tar.gz: 44ae938e8924e69507bc49de2a91081304fc2b9da2ddebe77a9c1138946d424788f3dce2535825cb1f98ba39398d61e97e161161ebde51d9706fa425d447217d
+  metadata.gz: 560c1d306060f3ce682bb362d3c9131541c6e461c577f03d0a800448c6c4b7995204c19429317e26c80a0a3eaa28220e4a6a68622053e2154dac0a85d80d1d39
+  data.tar.gz: cb777ac82a0aad678235a4f67dda300d92e44d25ec80c0c370034760d57b7a11e700ab627e6615c888bdf5141d9446f4c8e2af69c8c9ce1bae9e283ce637ff17

data/lib/smart_collection/cache_manager.rb

@@ -1,34 +1,46 @@
 module SmartCollection
   class CacheManager
-
-    def self.determine_class config
-      case
-      when config.dig(:cached_by, :table)
-        SmartCollection::CacheManager::Table
-      when config.dig(:cached_by, :cache_store)
-        SmartCollection::CacheManager::CacheStore
-      end
-    end
-
     def initialize model:, config:
       @model = model
       @config = config
+      define_cache_association_for model
+    end
+
+    def define_cache_association_for model
+      config = @config
+      cached_item_model = nil
+      model.class_eval do
+        cached_item_model = Class.new ActiveRecord::Base do
+          self.table_name = config.cache_table_name
+          belongs_to config.item_name, class_name: config.item_class_name, foreign_key: :item_id
+        end
+        const_set("CachedItem", cached_item_model)
+
+        has_many :cached_items, class_name: cached_item_model.name, foreign_key: :collection_id
+        has_many "cached_#{config.items_name}".to_sym, class_name: config.item_class_name, through: :cached_items, source: config.item_name
+      end
+      @cache_model = cached_item_model
     end
 
     def update owner
-      raise NotImplementedError
+      scopes = @config.scopes_proc.(owner)
+      @cache_model.where(collection_id: owner.id).delete_all
+      #scopes.each do |scope|
+      #  sql = scope.select(owner.id, :id).to_sql
+      #  @cache_model.connection.execute "INSERT INTO #{@cache_model.table_name} (collection_id, item_id) #{sql}"
+      #end
+      @cache_model.connection.execute "INSERT INTO #{@cache_model.table_name} (collection_id, item_id) #{owner.smart_collection_mixin.uncached_scope(owner).select(owner.id, :id).to_sql}"
+      owner.update_column(:cache_expires_at, Time.now + @config.cache_expires_in_proc.(owner))
     end
 
     def read_scope owner
-      raise NotImplementedError
+      cache_association = owner.association("cached_#{@config.items_name}")
+      cache_association.scope
     end
 
     def cache_exists? owner
-      raise NotImplementedError
+      owner.cache_expires_at && owner.cache_expires_at > Time.now
     end
 
-    def expires_in
-      @config.cache_config[:expires_in] || 1.hour
-    end
   end
 end

data/lib/smart_collection/config.rb

@@ -5,10 +5,11 @@ module SmartCollection
 
     def initialize raw_config
       @raw_config = raw_config
+      check_config
     end
 
     def items_name
-      @raw_config[:items]
+      @raw_config[:item_association]
     end
 
     def item_name
@@ -16,7 +17,7 @@ module SmartCollection
     end
 
     def item_class_name
-      @raw_config[:class_name]
+      @raw_config[:item_class_name]
     end
 
     def item_class
@@ -26,5 +27,49 @@ module SmartCollection
     def cache_config
       @raw_config[:cached_by]
     end
+
+    def scopes_proc
+      case @raw_config[:scopes]
+      when Proc
+        @raw_config[:scopes]
+      when Symbol
+        -> (owner) { owner.send(@raw_config[:scopes]) }
+      else
+        raise "scopes option only accepts a Proc / Symbol"
+      end
+    end
+
+    def inverse_association
+      @raw_config[:inverse_association]
+    end
+
+    def cache_table_name
+      if @raw_config[:cache_table] == :default
+        :smart_collection_cached_items
+      else
+        @raw_config[:cache_table]
+      end
+    end
+
+    def cache_expires_in_proc
+      case @raw_config[:cache_expires_in]
+      when Proc
+        @raw_config[:cache_expires_in]
+      when ActiveSupport::Duration
+        -> (owner) { @raw_config[:cache_expires_in] }
+      when Symbol
+        -> (owner) { owner.send(@raw_config[:cache_expires_in]) }
+      else
+        raise "cache_expires_in option only accepts a Proc / ActiveSupport::Duration / Symbol"
+      end
+    end
+
+    def check_config
+      raise "items option must be provided" if items_name.nil?
+      raise "item_class option must be provided" if item_class_name.nil?
+      raise "scopes option must be provided" if @raw_config[:scopes].nil?
+      raise "cache_table option must be provided" if @raw_config[:cache_table].nil?
+      raise "cache_expires_in option must be provided" if @raw_config[:cache_expires_in].nil?
+    end
   end
 end

data/lib/smart_collection/instance_methods.rb

@@ -0,0 +1,19 @@
+module SmartCollection
+  module InstanceMethods
+    def update_cache
+      smart_collection_mixin.config.cache_manager.update self
+    end
+
+    def expire_cache
+      update_column(:cache_expires_at, Time.now - 1)
+    end
+
+    def cache_exists?
+      smart_collection_mixin.config.cache_manager.cache_exists? self
+    end
+
+    def smart_collection_mixin
+      self.class.smart_collection_mixin
+    end
+  end
+end

data/lib/smart_collection/mixin.rb

@@ -1,23 +1,5 @@
 module SmartCollection
   class Mixin < Module
-    module InstanceMethods
-      def update_cache
-        smart_collection_mixin.config.cache_manager.update self
-      end
-
-      def expire_cache
-        update_column(:cache_expires_at, nil)
-      end
-
-      def cache_exists?
-        smart_collection_mixin.config.cache_manager.cache_exists? self
-      end
-
-      def smart_collection_mixin
-        self.class.smart_collection_mixin
-      end
-    end
-
     module ClassMethods
       def smart_collection_mixin
         @__smart_collection_mixin ||= ancestors.find do |x|
@@ -33,27 +15,31 @@ module SmartCollection
     end
 
     def uncached_scope owner
-      SmartCollection::ScopeBuilder.new(owner.rule, @config.item_class).build
+      scopes = @config.scopes_proc.(owner)
+      raise unless scopes.all?{|x| x.klass == @config.item_class}
+      if scopes.empty?
+        @config.item_class.where('1 = 0')
+      else
+        scopes = scopes.map do |scope|
+          if !scope.select_values.empty?
+            new_scope = scope.dup
+            new_scope.select_values = []
+            new_scope
+          else
+            scope
+          end
+        end
+        @config.item_class.from("(#{scopes.map{|x| "#{x.to_sql}"}.join(' UNION ')}) as #{@config.item_class.table_name}")
+      end
     end
 
     def cached_scope owner
       @config.cache_manager.read_scope owner
     end
 
-    def included base
-      @config = config = SmartCollection::Config.new(@raw_config)
-
-      reflection_options = {smart_collection: config}
-      if config.item_class_name
-        reflection_options[:class_name] = config.item_class_name
-      end
-
-      base.include(InstanceMethods)
-      base.extend(ClassMethods)
-
-      if cache_class = CacheManager.determine_class(@raw_config)
-        config.cache_manager = cache_class.new(model: base, config: config)
-      end
+    def define_association base
+      config = @config
+      config.cache_manager = CacheManager.new(model: base, config: config)
 
       mixin_options = {
         name: config.items_name,
@@ -61,47 +47,55 @@ module SmartCollection
           if owner.new_record?
             uncached_scope(owner)
           else
-            if cache_manager = config.cache_manager
-              unless cache_manager.cache_exists? owner
-                owner.update_cache
-              end
-              cached_scope(owner)
-            else
-              uncached_scope(owner)
+            cache_manager = config.cache_manager
+            unless cache_manager.cache_exists? owner
+              owner.update_cache
             end
+            cached_scope(owner)
           end
         },
         type: :collection
       }
 
-      case
-      when cache_class == SmartCollection::CacheManager::CacheStore
-        mixin_options[:preloader] = -> owners {
-          owners.reject(&:cache_exists?).each(&:update_cache)
-          loaded = config.cache_manager.read_multi(owners)
-          records = config.item_class.where(id: loaded.values.flatten.uniq).map{|x| [x.id, x]}.to_h
-          loaded.map do |owner, ids|
-            [owner, ids.map{|x| records[x]}]
-          end.to_h
-        }
-      when cache_class == SmartCollection::CacheManager::Table
-        cached_name = "cached_#{config.items_name}".to_sym
-        mixin_options[:preloader] = -> owners {
-          owners.reject(&:cache_exists?).each(&:update_cache)
-          Associationist.preload(owners, cached_items: config.item_name)
-          owners.map do |owner|
-            [owner, owner.cached_items.map{|item| item.send(config.item_name)}]
-          end.to_h
-        }
-      else
-        mixin_options[:preloader] = -> _ {
-          raise RuntimeError, "Turn on cache to enable preloading."
-        }
-      end
+      cached_name = "cached_#{config.items_name}".to_sym
+      mixin_options[:preloader] = -> owners {
+        owners.reject(&:cache_exists?).each(&:update_cache)
+        Associationist.preload(owners, cached_items: config.item_name)
+        owners.map do |owner|
+          [owner, owner.cached_items.map{|item| item.send(config.item_name)}]
+        end.to_h
+      }
+
       base.include Associationist::Mixin.new(mixin_options)
+    end
+
+    def expired_scope base
+      base.where(base.arel_table[:cache_expires_at].lt(Time.now))
+    end
+
+    def define_inverse_association base
+      return unless @config.inverse_association
+
+      mixin_options = {
+        name: @config.inverse_association,
+        scope: -> owner {
+          expired = base.joins(:cached_items).where(@config.cache_table_name => {item_id: owner.id}).merge(expired_scope base)
+          expired.each(&:update_cache)
+          base.joins(:cached_items).where(@config.cache_table_name => {item_id: owner.id})
+        },
+        type: :collection
+      }
+      @config.item_class.include Associationist::Mixin.new(mixin_options)
+    end
 
-      base.validates_with SmartCollection::Validator
+    def included base
+      @config = config = SmartCollection::Config.new(@raw_config)
+
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
 
+      define_association base
+      define_inverse_association base
     end
   end
 end

data/lib/smart_collection/version.rb

@@ -1,3 +1,3 @@
 module SmartCollection
-  VERSION = '0.2.2'
+  VERSION = '0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_collection
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: '0.3'
 platform: ruby
 authors:
 - CicholGricenchos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-11 00:00:00.000000000 Z
+date: 2019-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: associationist
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -89,12 +89,9 @@ extra_rdoc_files: []
 files:
 - lib/smart_collection.rb
 - lib/smart_collection/cache_manager.rb
-- lib/smart_collection/cache_manager/cache_store.rb
-- lib/smart_collection/cache_manager/table.rb
 - lib/smart_collection/config.rb
+- lib/smart_collection/instance_methods.rb
 - lib/smart_collection/mixin.rb
-- lib/smart_collection/scope_builder.rb
-- lib/smart_collection/validator.rb
 - lib/smart_collection/version.rb
 homepage: https://github.com/CicholGricenchos/smart_collection
 licenses:

data/lib/smart_collection/cache_manager/cache_store.rb

@@ -1,42 +0,0 @@
-module SmartCollection
-  class CacheManager
-    class CacheStore < CacheManager
-
-      def initialize model:, config:
-        super
-
-        @cache_key_proc = @config.cache_config[:cache_key_proc] || -> (owner) { "_smart_collection_#{owner.class.name}_#{owner.id}" }
-      end
-
-      def cache_store
-        @config.cache_config[:cache_store]
-      end
-
-      def cache_key owner
-        @cache_key_proc.(owner)
-      end
-
-      def update owner
-        cache_store.write(cache_key(owner), Marshal.dump(owner.smart_collection_mixin.uncached_scope(owner).pluck(:id)))
-        owner.update(cache_expires_at: Time.now + expires_in)
-      end
-
-      def read_scope owner
-        @config.item_class.where(id: Marshal.load(cache_store.read(cache_key owner)))
-      end
-
-      def read_multi owners
-        cache_keys = owners.map{|owner| cache_key owner}
-        loaded = cache_store.read_multi(*cache_keys)
-        owners.map.with_index do |owner, index|
-          [owner, Marshal.load(loaded[cache_keys[index]])]
-        end.to_h
-      end
-
-      def cache_exists? owner
-        owner.cache_expires_at && owner.cache_expires_at > Time.now && cache_store.exist?(cache_key owner)
-      end
-
-    end
-  end
-end

data/lib/smart_collection/cache_manager/table.rb

@@ -1,44 +0,0 @@
-module SmartCollection
-  class CacheManager
-    class Table < CacheManager
-
-      def initialize model:, config:
-        super
-
-        define_cache_association_for model
-      end
-
-      def define_cache_association_for model
-        config = @config
-        cached_item_model = nil
-        model.class_eval do
-          cached_item_model = Class.new ActiveRecord::Base do
-            self.table_name = 'smart_collection_cached_items'
-            belongs_to config.item_name, class_name: config.item_class_name, foreign_key: :item_id
-          end
-          const_set("CachedItem", cached_item_model)
-
-          has_many :cached_items, class_name: cached_item_model.name, foreign_key: :collection_id
-          has_many "cached_#{config.items_name}".to_sym, class_name: config.item_class_name, through: :cached_items, source: config.item_name
-        end
-        @cache_model = cached_item_model
-      end
-
-      def update owner
-        @cache_model.where(collection_id: owner.id).delete_all
-        @cache_model.connection.execute "INSERT INTO #{@cache_model.table_name} (collection_id, item_id) #{owner.smart_collection_mixin.uncached_scope(owner).select(owner.id, :id).to_sql}"
-        owner.update_column(:cache_expires_at, Time.now + expires_in)
-      end
-
-      def read_scope owner
-        cache_association = owner.association("cached_#{@config.items_name}")
-        cache_association.scope
-      end
-
-      def cache_exists? owner
-        owner.cache_expires_at && owner.cache_expires_at > Time.now
-      end
-
-    end
-  end
-end

data/lib/smart_collection/scope_builder.rb

@@ -1,46 +0,0 @@
-module SmartCollection
-  class ScopeBuilder
-    def initialize rule, klass
-      @rule = rule
-      @klass = klass
-      @klass_hash = {}
-    end
-
-    def build
-      rule_to_bulk_queries @rule
-      bulk_load
-      rule_to_scope @rule
-    end
-
-    def bulk_load
-      @klass_hash = @klass_hash.map do |klass_name, ids|
-        [klass_name, Object.const_get(klass_name).where(id: ids).map{|x| [x.id, x]}.to_h]
-      end.to_h
-    end
-
-    def rule_to_bulk_queries rule
-      case
-      when arr = (rule['or'] || rule['and'])
-        arr.each{|x| rule_to_bulk_queries x}
-      when assoc = rule['association']
-        ids = @klass_hash[assoc['class_name']] ||= []
-        ids << assoc['id']
-      end
-    end
-
-    def rule_to_scope rule
-      case
-      when ors = rule['or']
-        ors.map{|x| rule_to_scope x}.inject(:or)
-      when ands = rule['and']
-        ands.map{|x| rule_to_scope x}.inject(:merge)
-      when assoc = rule['association']
-        @klass_hash[assoc['class_name']][assoc['id']].association(assoc['source']).scope
-      when cond = rule['condition']
-        scope = @klass
-        scope = scope.joins(cond['joins'].to_sym) if cond['joins']
-        scope.where(cond['where'])
-      end
-    end
-  end
-end

data/lib/smart_collection/validator.rb

@@ -1,10 +0,0 @@
-module SmartCollection
-  class Validator < ActiveModel::Validator
-    def validate record
-      # try to build scope
-      record.association(record.smart_collection_mixin.config.items_name).scope
-    rescue Exception => e
-      record.errors.add(:failed_to_build_scope, e)
-    end
-  end
-end