smart_collection 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 206884a5b82cfb9a32a8084b9e28602e0d06aef1
+  data.tar.gz: 4cfc1bd05e9b4e49d026e3388bb1409b9b92f1db
+SHA512:
+  metadata.gz: e8f54ca5265ded99d18f0a41036fde1fb2052d6c1c26662482b409ecb7c9689bf14bd08f09fa9e10a7fa1cec331c979f88165e79d4fd1d7db0c52b7da5843599
+  data.tar.gz: de95c2aabb00d01f30fc5f60b826d2b8071d9ecd04e76a245466845a3d9f0a31a927bfc0db9d602ea12b100c8a81e916ad25044684e352c6423032c63ef461a7

data/lib/smart_collection/associations/preloader/smart_collection.rb

@@ -0,0 +1,63 @@
+module SmartCollection
+  module Associations
+    module Preloader
+      class SmartCollectionCachedByTable < ActiveRecord::Associations::Preloader::HasManyThrough
+        def through_reflection
+          owners.first.class.reflect_on_association(:cached_items)
+        end
+
+        def source_reflection
+          association_name = reflection.options[:smart_collection].items_name.to_s.singularize.to_sym
+          through_reflection.klass.reflect_on_association(association_name)
+        end
+
+        def associated_records_by_owner preloader
+          owners.reject(&:cache_exists?).each(&:update_cache)
+          super
+        end
+
+        private
+
+      end
+
+      class SmartCollectionCachedByCacheStore < ActiveRecord::Associations::Preloader::CollectionAssociation
+        def associated_records_by_owner preloader
+          owners.reject(&:cache_exists?).each(&:update_cache)
+          loaded = reflection.options[:smart_collection].cache_manager.read_multi(owners)
+          records = reflection.options[:smart_collection].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
+        end
+
+        def preload(preloader)
+          associated_records_by_owner(preloader).each do |owner, records|
+            association = owner.association(reflection.name)
+            association.loaded!
+            association.target.concat(records)
+          end
+        end
+      end
+    end
+  end
+
+  module ActiveRecordPreloaderPatch
+    def preloader_for(reflection, owners, rhs_klass)
+      if reflection.options[:smart_collection]
+        unless reflection.options[:smart_collection].cache_manager
+          raise RuntimeError, "Turn on cache to enable preloading."
+        end
+        case reflection.options[:smart_collection].cache_manager
+        when SmartCollection::CacheManager::CacheStore
+          SmartCollection::Associations::Preloader::SmartCollectionCachedByCacheStore
+        when SmartCollection::CacheManager::Table
+          SmartCollection::Associations::Preloader::SmartCollectionCachedByTable
+        end
+      else
+        super
+      end
+    end
+  end
+
+  ActiveRecord::Associations::Preloader.prepend ActiveRecordPreloaderPatch
+end

data/lib/smart_collection/associations/smart_collection_association.rb

@@ -0,0 +1,75 @@
+module SmartCollection
+  module Associations
+    class SmartCollectionAssociation < ::ActiveRecord::Associations::HasManyAssociation
+
+      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
+
+      def association_scope
+        if cache_manager = reflection.options[:smart_collection].cache_manager
+          unless cache_manager.cache_exists? owner
+            owner.update_cache
+          end
+          cached_scope
+        else
+          uncached_scope
+        end
+      end
+
+      def skip_statement_cache?
+        true
+      end
+
+      def uncached_scope
+        ScopeBuilder.new(owner.rule, reflection.klass).build
+      end
+
+      def cached_scope
+        reflection.options[:smart_collection].cache_manager.read owner
+      end
+
+    end
+  end
+end

data/lib/smart_collection/builder/smart_collection_association.rb

@@ -0,0 +1,26 @@
+module SmartCollection
+  module Builder
+    class SmartCollectionAssociation < ::ActiveRecord::Associations::Builder::CollectionAssociation
+      def self.macro
+        :has_many
+      end
+
+      def self.valid_options(options)
+        super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache, :join_table, :foreign_type, :index_errors, :smart_collection]
+      end
+
+      def self.valid_dependent_options
+        [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception]
+      end
+
+      def self.create_reflection(model, name, scope, options, extension = nil)
+        raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+        validate_options(options)
+
+        scope = build_scope(scope, extension)
+        Reflection::SmartCollectionReflection.new(name, scope, options, model)
+      end
+    end
+  end
+end

data/lib/smart_collection/cache_manager/cache_store.rb

@@ -0,0 +1,38 @@
+module SmartCollection
+  class CacheManager
+    class CacheStore < CacheManager
+
+      def cache_store
+        @config.cache_config[:cache_store]
+      end
+
+      def cache_key owner
+        "_smart_collection_#{owner.class.name}_#{owner.id}"
+      end
+
+      def update owner
+        association = owner.association(@config.items_name)
+
+        cache_store.write(cache_key(owner), Marshal.dump(association.uncached_scope.pluck(:id)))
+        owner.update(cache_expires_at: Time.now + expires_in)
+      end
+
+      def read 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.nil? || owner.cache_expires_at < Time.now) && cache_store.exist?(cache_key owner)
+      end
+
+    end
+  end
+end

data/lib/smart_collection/cache_manager/table.rb

@@ -0,0 +1,46 @@
+module SmartCollection
+  class CacheManager
+    class Table < CacheManager
+
+      def initialize model:, config:
+        super
+
+        define_cache_association_for model
+      end
+
+      def define_cache_association_for model
+        options = @config.raw_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 options[:items].to_s.singularize.to_sym, class_name: options[: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_#{options[:items]}".to_sym, class_name: options[:class_name], through: :cached_items, source: options[:items].to_s.singularize.to_sym
+        end
+        @cache_model = cached_item_model
+      end
+
+      def update owner
+        association = owner.association(@config.items_name)
+
+        @cache_model.where(collection_id: owner.id).delete_all
+        @cache_model.connection.execute "INSERT INTO #{@cache_model.table_name} (collection_id, item_id) #{association.uncached_scope.select(owner.id, :id).to_sql}"
+        owner.update(cache_expires_at: Time.now + expires_in)
+      end
+
+      def read owner
+        cache_association = owner.association("cached_#{@config.items_name}")
+        cache_association.scope
+      end
+
+      def cache_exists? owner
+        !(owner.cache_expires_at.nil? || owner.cache_expires_at < Time.now)
+      end
+
+    end
+  end
+end

data/lib/smart_collection/cache_manager.rb

@@ -0,0 +1,30 @@
+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
+    end
+
+    def update owner
+      raise NotImplementedError
+    end
+
+    def read owner
+      raise NotImplementedError
+    end
+
+    def expires_in
+      @config.cache_config[:expires_in] || 1.hour
+    end
+  end
+end

data/lib/smart_collection/config.rb

@@ -0,0 +1,26 @@
+module SmartCollection
+  class Config
+    attr_accessor :cache_manager
+    attr_reader :raw_config
+
+    def initialize raw_config
+      @raw_config = raw_config
+    end
+
+    def items_name
+      @raw_config[:items]
+    end
+
+    def item_class_name
+      @raw_config[:item_class]
+    end
+
+    def item_class
+      item_class_name.constantize
+    end
+
+    def cache_config
+      @raw_config[:cached_by]
+    end
+  end
+end

data/lib/smart_collection/mixin.rb

@@ -0,0 +1,50 @@
+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
+        @__smart_collection_mixin ||= self.class.ancestors.find do |x|
+          x.instance_of? Mixin
+        end
+      end
+    end
+
+    attr_reader :config
+
+    def initialize items:, item_class: nil, cached_by: nil
+      @raw_config = {
+        items: items,
+        item_class: item_class,
+        cached_by: cached_by
+      }
+    end
+
+    def included base
+      COLLECTIONS[base] = true
+      @config = config = SmartCollection::Config.new(@raw_config)
+      name = config.items_name
+
+      options = {smart_collection: config}
+      options[:class_name] = config.item_class_name if config.item_class_name
+      reflection = Builder::SmartCollectionAssociation.build(base, name, nil, options)
+      ::ActiveRecord::Reflection.add_reflection base, name, reflection
+      base.include(InstanceMethods)
+
+      if cache_class = CacheManager.determine_class(@raw_config)
+        config.cache_manager = cache_class.new(model: base, config: config)
+      end
+
+    end
+  end
+end

data/lib/smart_collection/reflection/smart_collection_reflection.rb

@@ -0,0 +1,13 @@
+module SmartCollection
+  module Reflection
+    class SmartCollectionReflection < ::ActiveRecord::Reflection::HasManyReflection
+      def association_class
+        Associations::SmartCollectionAssociation
+      end
+
+      def check_eager_loadable!
+        raise RuntimeError, 'eager_load is not supported by now.'
+      end
+    end
+  end
+end

data/lib/smart_collection.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+
+module SmartCollection
+  COLLECTIONS = {}
+end
+
+Dir.glob("#{File.dirname(__FILE__)}/**/*.rb").each do |file|
+  require file
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: smart_collection
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- CicholGricenchos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- cichol@live.cn
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/smart_collection.rb
+- lib/smart_collection/associations/preloader/smart_collection.rb
+- lib/smart_collection/associations/smart_collection_association.rb
+- lib/smart_collection/builder/smart_collection_association.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/mixin.rb
+- lib/smart_collection/reflection/smart_collection_reflection.rb
+homepage: https://github.com/CicholGricenchos/smart_collection
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []