skimming 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c31cbb40931809f9bed74b5d90a9c30058734f50a8818d2694e16630a70c493
-  data.tar.gz: 272a1af1759927b87add863af0112d8c1ac92ca7353eb040892c58afbfefb4b3
+  metadata.gz: 26418f0331bb4b3d54054941f86629eec8f48959ef4df9dba5349f9cf61bc0eb
+  data.tar.gz: 0c7555240ff2343ee5348bad95be19a5b1ba326b4297598d0cca0c342fc4b141
 SHA512:
-  metadata.gz: 28cea3d3f6ae71f06598ddb1e35bbd6aff2a559199460af4893b9484a63ed67a59ffc24a247629a0c99a83e676f24f7cd3eab58847a61ec74c022f09140517ea
-  data.tar.gz: 71cd69780026514df89d0193a2060196d06def6f0710f253c378f96ae4c2dcf154c2f133b33b669cc2e0165bb8ccd019c612fb2083b5a9ee4ecfe75a0c7ebff1
+  metadata.gz: db658918f56316e975ec52d41776afe0f8d9693d907fb72f58b92fe3cbc99319865befe108730a0fe281dca770c4d974ac39863a71e8ffed61b0fa436df7f861
+  data.tar.gz: 0133cb9935aed599bdd3eec639276b5e1f5f7e98a76c8aa4682ce1783847ae646195fa6259f2d0d83ea6e5ba1a65a03e096fbc4bbe8751488b1964107dc633fc

data/README.md

@@ -15,12 +15,6 @@ In each model you want to have the feature, just put the following.
 
     include Skimming::Model
 
-Create `config/skimming.yml` file in your project and compile it as follows for each of the models you included the code above into (let's say for instance you included Skimming::Model into Role model).
-
-    associations:
-      roles:
-        class_name: 'Role'
-
 Once this config file is created, you can launch the following command.
 
     rails g skimming_migration
@@ -31,43 +25,36 @@ The command above will generate a migration file in your project. Now you can mi
 
 ### Use skimming filters of another model
 
-If you want, you can also allow a related model (for example User) to use Role's skimming rules. In that case the User model should have this instead.
+If you want, you can also allow a related model (for example User) to use Role's skimming rules. In that case the in the User model you should do as follows.
 
-    include Skimming::ParasiteModel
+    skim_throught :roles
 
-And the config file should have one more configuration.
+## Usage
 
-    associations:
-      roles:
-        class_name: 'Role'
-    options:
-      user:
-        skim_through:
-          - 'roles'
+Create one `Skimming::Item` for each class you want your skimmable models to skim. The name of the item has to be PascalCase.
 
-## Usage
+    item = Skimming::Item.create(name: 'Order')
+
+Create one `Skimming::Rule` for each condition you want to evaluate when you decide if the skimmable should keep the items of a certain collection.
 
-Create one `Skimming::CollectionFilter` for each class your model needs to skim and assign a rule that has to be satisfied.
+    rule = Skimming::Rule.create(statement: '@order.created_at < 1.month.ago')
 
-    role.create_collection_filter(object_name: 'order', rule: '@order.complete?')
-    role.create_collection_filter(object_name: 'pet', rule: '@pet.nice?')
-    role.create_collection_filter(object_name: 'room', rule: '@room.clean?')
+This, for example, hides all orders older than 1 month from the collection.
 
-You could also assign the same `Skimming::CollectionFilter` to multiple roles since they have a HABTM relation.
+Create one `Skimming::Filter` for each item your model needs to skim and assign the rule.
 
-If now you call `role.skim rooms_collection` only clean rooms will be returned.
+    role.create_filter(item: item, rule: rule)
 
-Also user can do that if it has the role assigned. By default the parasite model skims through all its associated models that have included `Skimming::Model` and sums all results, rejecting the records that all of the skimming models have rejected (if any of the skimming models have the record present in the filter, it will be present in the parasite model skimming result). However in some cases you may want to make the parasite model to skim only through one or some of these models. To do so, just pass one of the models or an array of those.
+If now you call `role.skim orders_collection` only orders newer than 1 month ago will be returned.
 
-    user.skim rooms_collection, through: :roles
-    user.skim rooms_collection, through: [:roles, :whatever]
+Also user can do that if it has the role assigned and you have specified `skim_through :roles` in User model.
 
 ### Rules
 
 You can store in filters rules whatever conditions you like in plain ruby and the string will be evaulated. Inside the rules, object have to be called as instance variables. These instance variables indeed need to be present and can be declared in a few ways.
 
 1. The model name of the instance you called `skim` from, like the user, will be defined automatically based on model name, so if you call `user.skim rooms_collection` you will have `@user` variable defined.
-2. Based on the skimmed collection, instance variables are defined. In the case above, `@room` variable will be present for each of the rooms to be evaluated in. The collection name is calculated based on the class of the first object in the collection and will raise an error if is not the same for all collection elements. You can override this calculation specifying the `object_name` of the collection (the skimming will look for collection_filters with that `object_name`)
+2. Based on the skimmed collection, instance variables are defined. In the case above, `@order` variable will be present for each of the orders to be evaluated in. The collection name is calculated based on the class of the first object in the collection and will raise an error if is not the same for all collection elements. You can override this calculation specifying the `item_name` of the collection (the skimming will look for collection_filters with that `item_name`). This can be necessary if you are filtering throught different classes instances having STI.
 3. You can pass as third argument an hash of objects like this `user.skim rooms_collection, time: Time.zone.now, whatever: @you_want` and you will have `@time` and `@whatever` variables defined for rule evaluation.
 
 WARNING: since the strings get evaluated, i recommend not to allow anyone except project developers to create collection_filters, in order to prevent malicious code from being executed.

data/lib/generators/skimming_migration_generator.rb

@@ -3,39 +3,41 @@ require 'rails/generators'
 class SkimmingMigrationGenerator < Rails::Generators::Base
 
   def create_migration_file
-    create_file "db/migrate/#{Time.zone.now.strftime("%Y%m%d%H%M%S")}_skimming_migration.rb", migration_data
+    create_file "db/migrate/#{Time.zone.now.strftime("%Y%m%d%H%M%S")}_skimming_migration_1_0_0.rb", migration_data
   end
 
   private
 
   def migration_data
 <<MIGRATION
-  class SkimmingMigration < ActiveRecord::Migration[5.2]
-    # 0.0.1 Release
-    def change
-      unless table_exists? :collection_filters
-        create_table :collection_filters do |t|
-          t.string :object_name
-          t.string :rule
-
-          t.timestamps
-        end
-
-        #{generate_join_tables_creation_data}
+class SkimmingMigration100 < ActiveRecord::Migration[5.2]
+  def change
+    unless table_exists? :items
+      create_table :items do |t|
+        t.string :name
+
+        t.timestamps
       end
     end
-  end
-MIGRATION
-  end
 
-  def generate_join_tables_creation_data
-    join_tables_creation_data = ""
-    associations = Skimming.configuration.associations.keys
+    unless table_exists? :filters
+      create_table :filters do |t|
+        t.bigint :item_id
+        t.bigint :skimmable_id
+        t.string :skimmable_type
 
-    associations.each do |association|
-      join_tables_creation_data += "create_join_table :collection_filters, :#{association}#{"\n        " unless association == associations.last}"
-    end
+        t.timestamps
+      end
 
-    join_tables_creation_data
+      create_table :rules do |t|
+        t.bigint :filter_id
+        t.string :statement
+
+        t.timestamps
+      end
+    end
+  end
+end
+MIGRATION
   end
 end

data/lib/models/skimming/filter.rb

@@ -0,0 +1,11 @@
+module Skimming
+  class Filter < ActiveRecord::Base
+    belongs_to :skimmable, polymorphic: true
+    belongs_to :item, class_name: 'Skimming::Item', inverse_of: :filters, foreign_key: :item_id
+    has_many :rules
+
+    validates_presence_of :rules
+
+    scope :for_item, -> (item_name) { joins(:item).where(items: { name: item_name }) }
+  end
+end

data/lib/models/skimming/item.rb

@@ -0,0 +1,15 @@
+module Skimming
+  class Item < ActiveRecord::Base
+    has_many :filters, class_name: 'Skimming::Filter', inverse_of: :item, foreign_key: :item_id
+
+    validates :name, presence: true, uniqueness: true
+
+    attr_readonly :name
+
+    before_validation :classify_name
+
+    def classify_name
+      self.name = self.name.classify
+    end
+  end
+end

data/lib/models/skimming/rule.rb

@@ -0,0 +1,7 @@
+module Skimming
+  class Rule < ActiveRecord::Base
+    belongs_to :filter, class_name: 'Skimming::Filter', inverse_of: :rule, foreign_key: :filter_id
+
+    validates_presence_of :statement
+  end
+end

data/lib/skimming.rb

@@ -1,6 +1,6 @@
-require 'skimming/configuration'
 require 'skimming/model'
-require 'skimming/parasite_model'
 require 'skimming/skimmer'
-require 'models/skimming/collection_filter'
+require 'models/skimming/filter'
+require 'models/skimming/item'
+require 'models/skimming/rule'
 require 'generators/skimming_migration_generator'

data/lib/skimming/model.rb

@@ -3,11 +3,17 @@ module Skimming
     extend ActiveSupport::Concern
 
     included do
-      has_and_belongs_to_many :collection_filters, class_name: 'Skimming::CollectionFilter'
+      has_many :filters, class_name: 'Skimming::Filter', as: :skimmable
     end
 
-    def skim(collection, object_name: nil, **skimming_instances)
-      Skimming::Skimmer.new(self, collection, object_name, skimming_instances).skim
+    module ClassMethods
+      def skim_through(association)
+        has_many :filters, through: association, class_name: 'Skimming::Filter', source: :filters
+      end
+    end
+
+    def skim(collection, item_name: nil, **skimming_instances)
+      Skimming::Skimmer.new(self, collection, item_name, skimming_instances).skim
     end
   end
 end

data/lib/skimming/skimmer.rb

@@ -1,23 +1,23 @@
 module Skimming
   class Skimmer
-    attr_reader :subject, :collection, :collection_name, :skimming_instances
+    attr_reader :subject, :collection, :item_name, :skimming_instances
 
-    def initialize(subject, collection, object_name, skimming_instances)
+    def initialize(subject, collection, item_name, skimming_instances)
       @subject = subject
       @collection = collection
-      @collection_name = object_name || calculate_collection_name
+      @item_name = calculate_item_name
       @skimming_instances = skimming_instances
     end
 
     def skim
       set_instance_variables
 
-      filters_rules = subject.collection_filters.for_object(collection_name).map(&:rule)
+      filters_rules = subject.filters.for_item(item_name).map(&:rules).flatten.map(&:statement)
 
       return collection if filters_rules.empty?
 
-      skimming_result = collection.select do |collection_object|
-        instance_variable_set("@#{collection_name}", collection_object)
+      skimming_result = collection.select do |collection_item|
+        instance_variable_set("@#{item_name.downcase}", collection_item)
 
         filters_rules.all? { |rule| eval rule }
       end
@@ -25,28 +25,16 @@ module Skimming
       skimming_result
     end
 
-    def skim_through(skimming_associations)
-      set_instance_variables
-
-      skimming_associations = Skimming.configuration.options[subject.class.name.underscore][:skim_through] if skimming_associations.blank?
-      skimming_associations = [skimming_associations] unless skimming_associations.respond_to? :each
-      skimming_result = []
-
-      skimming_associations.each do |association_name|
-        subject.send(association_name.to_sym).each do |skimming_object|
-          skimming_result += skimming_object.skim(collection, subject.class.name.downcase.to_sym => subject)
-        end
-      end
+    private
 
-      skimming_result.uniq
-    end
+    def calculate_item_name
+      return item_name.to_s.classify if item_name
 
-    private
+      items_classes = collection.map(&:class).uniq
 
-    def calculate_collection_name
-      raise 'Invalid collection: contains objects with different classes' unless collection.map(&:class).uniq.count == 1
+      raise "Invalid collection: contains items with different classes (#{items.classes.join(', ')}). Use same class items or specify their item_name." unless items_classes.count == 1
 
-      collection.first.class.name.downcase
+      items_classes.first.name.demodulize
     end
 
     def set_instance_variables

data/skimming.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'skimming'
-  s.version     = '0.0.2'
-  s.date        = '2020-04-18'
+  s.version     = '1.0.0'
+  s.date        = '2020-09-14'
   s.summary     = "Collections skimming"
   s.description = "Filter your collections with database-configurable rules"
   s.authors     = ["Valerio Bellaveglia"]

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: skimming
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Valerio Bellaveglia
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-18 00:00:00.000000000 Z
+date: 2020-09-14 00:00:00.000000000 Z
 dependencies: []
 description: Filter your collections with database-configurable rules
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -19,18 +19,18 @@ files:
 - ".gitignore"
 - README.md
 - lib/generators/skimming_migration_generator.rb
-- lib/models/skimming/collection_filter.rb
+- lib/models/skimming/filter.rb
+- lib/models/skimming/item.rb
+- lib/models/skimming/rule.rb
 - lib/skimming.rb
-- lib/skimming/configuration.rb
 - lib/skimming/model.rb
-- lib/skimming/parasite_model.rb
 - lib/skimming/skimmer.rb
 - skimming.gemspec
 homepage: https://github.com/ValerioBellaveglia/Skimming
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -45,8 +45,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Collections skimming
 test_files: []

data/lib/models/skimming/collection_filter.rb

@@ -1,11 +0,0 @@
-module Skimming
-  class CollectionFilter < ActiveRecord::Base
-    Skimming.configuration.associations.each do |association_name, association_options|
-      has_and_belongs_to_many association_name.to_sym, class_name: association_options[:class_name], inverse_of: :collection_filters, foreign_key: "#{association_name}_id".to_sym
-    end
-
-    validates_presence_of :object_name, :rule
-
-    scope :for_object, -> (object_name) { where(object_name: object_name) }
-  end
-end

data/lib/skimming/configuration.rb

@@ -1,18 +0,0 @@
-module Skimming
-  def self.configuration
-    @configuration ||= Configuration.new(configuration_hash)
-  end
-
-  def self.configuration_hash
-    @configuration_hash ||= HashWithIndifferentAccess.new(YAML.load_file('config/skimming.yml'))
-  end
-
-  class Configuration
-    attr_accessor :associations, :options
-
-    def initialize(configuration_hash)
-      @associations = configuration_hash[:associations]
-      @options = configuration_hash[:options]
-    end
-  end
-end

data/lib/skimming/parasite_model.rb

@@ -1,15 +0,0 @@
-module Skimming
-  module ParasiteModel
-    extend ActiveSupport::Concern
-
-    included do
-      Skimming.configuration.options[name.demodulize.underscore][:skim_through].each do |association_name|
-        has_many :collection_filters, through: association_name.to_sym, class_name: 'Skimming::CollectionFilter'
-      end
-    end
-
-    def skim(collection, through: nil, object_name: nil, **skimming_instances)
-      Skimming::Skimmer.new(self, collection, object_name, skimming_instances).skim_through through
-    end
-  end
-end