active_aggregate 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 653177242ed87c2c3965933b6a7932644528af9ad7a5a861d950c0e5b3bd7078
-  data.tar.gz: fcb515097fb8001c7cc314e7bca0131b1ab83ea155a3d69300537b77126bff9a
+  metadata.gz: 4ea7dac3e2a7ec25fe7a0626f180c744e56997e950097def32c6d5ffa3d834bc
+  data.tar.gz: 6960dd0b37fada8e6ea18b6b1513cf285a865472349403f8411bf8a7559654a5
 SHA512:
-  metadata.gz: f086dc4d9a449ba36d25d775e85c52b2bd61299a4cedfe104b3a715917cd9e0037affc4410bfa1c2b609d8000a5410c279fe4d0dd1a15034373c0301429e17a3
-  data.tar.gz: f6d84f33cf8c04003f3436df053fd5e86932c1edb7e04217768e5863b42f693fc1a9110e53b9939c1360b2483f9130c7f7b16de37e4df8ebd7720cfaa5efe2d6
+  metadata.gz: 728e4ebf029dfe740e67d3caa5bb8eb1ba720a02c7af329baee1285a6574c6ac560b1499c105056203bd57f9d87de59eb09d70bc16b61df8a89b978b16608fa2
+  data.tar.gz: e13acc34d877094783c344a34674263d1a629d25e9e9eab73febb02dd93ec5b0596284b01afc923d98ff5075b8e187ac495e33c6f6ce9588404dd276a647dd01

data/README.md

@@ -1,10 +1,109 @@
 # active_aggregate
 
  - active_aggregate is a little helper support to queries by mongoDB aggregate more easily.
- - A toolkit for building queries like ActiveRelation. Rich support for more flexible merge conditons, states
+ - A toolkit for building queries like ActiveRelation. Rich support for more flexible merge conditions, states
 
 ## Getting started
 
 ```ruby
 gem install active_aggregate
 ```
+
+## Requirements
+ - mongoid >= 5.0.1
+
+## Usage
+
+```ruby
+# models/user.rb
+class User
+  include Mongoid::Document
+
+  belongs_to :school
+  belongs_to :branch
+
+  scope :active, -> { where(status: :active) }
+  scope :by_status, ->(status) { where(status: status) }
+end
+
+class Query
+  include ActiveAggregate::Concern
+end
+
+class UserQuery < Query
+  define_for User
+
+  # you can use `criteria.active` instead of `User.active`
+  scope :load_active_user_names, criteria: User.active,
+        project: {
+          id: '$_id',
+          name: {
+            '$concat': [
+              '$first_name',
+              ' ',
+              '$last_name',
+            ]
+          }
+        }
+
+  scope :not_deleted, criteria: User.where(deleted_at: nil)
+  scope :load_user_ids,
+        ->(status:, school_id_branch_ids:) do
+          where(status: status).pipeline(
+            '$match': {
+              'school_id_branch_id': {
+                '$in': school_id_branch_ids,
+              }
+            }
+          )
+
+          # it avaiable to use like
+          # query_criteria(User.by_status(status)).pipeline([
+          #   '$match': {
+          #     'school_id_branch_id': {
+          #       '$in': school_id_branch_ids,
+          #     }
+          #   }
+          # ])
+
+        end,
+        project: {
+          id: '$_id',
+          school_id_branch_id: {
+            '$concatArrays': [
+              ['$school_id'],
+              ['$branch_id'],
+            ]
+          }
+        }
+end
+
+# another way
+# class Query
+#   include ActiveAggregate::Concern
+
+#   # On children class it will remove [suffix] at end of class name to get model name then you can skip call define_for each all of Query class
+#   # [suffix] have default value is Query
+#   with_suffix
+#   # with_suffix suffix: :Query
+# end
+
+# class UserQuery < Query
+# end
+
+
+UserQuery.not_deleted.load_user_ids.where(:created_at.lt => Time.current)
+```
+
+- `scope` support define for:
+  - criteria: as `Mongoid::Criteria` it will place at first of pipeline if given, by default it is default scope
+  - group: as object, can be merge throw all queries.
+  - project: as object, will be replace throw merge ActiveAggregate::Relation
+  - sort, limit: as object, will be replace throw merge ActiveAggregate::Relation.
+  - pipeline: as Array will place end of pre-pipeline if given, merge with previous pipeline by concat 2 array
+`scope` will generate pipeline to use with aggregate with states order by:
+ - State 1 is `$match` use`criteria` selector if selector present
+ - state 2 is `$group` if `group` given
+ - state 3 is `$project` if `project` given
+ - state 3 is `$limit` if `limit` given
+ - pipeline will be place from here

data/lib/active_aggregate/concern.rb

@@ -2,28 +2,22 @@ module ActiveAggregate::Concern
   extend ActiveSupport::Concern
 
   class_methods do
-    attr_reader :model, :criteria
-
     delegate :query, :query_criteria, :group, :project, :pipeline, :group_by, :to_a,
-             :where, :in, :any_off, :all_of,
+             :where, :in, :where_in, :any_off, :all_of, :limit, :sort,
              to: :all
 
-    def define_for(model)
-      @model = model
-      @criteria = model.all
-    end
-
     def scope(name, *options)
-      raise TypeError, 'set defined scope for model first' unless model
+      required_model!
       scope_name = name.to_sym
-      scopes[scope_name] = ActiveAggregate::Relation.new(self, *options)
+      scopes[scope_name] = ActiveAggregate::Relation.new(self, *options).tap { |relation| relation.cacheable = false }
       singleton_class.send(:define_method, scope_name) do |*args|
+        scopes[scope_name] = ActiveAggregate::Relation.new(self, *options)
         return scopes[scope_name].generate(*args)
       end
     end
 
     def all
-      raise TypeError, 'set defined scope for model first' unless model
+      required_model!
       ActiveAggregate::Relation.new(self).generate
     end
 
@@ -51,5 +45,40 @@ module ActiveAggregate::Concern
     def scopes
       @scopes ||= {}
     end
+
+    def model
+      @model ||= load_model
+    end
+
+    def criteria
+      @criteria ||= load_model.all
+    end
+
+    private
+
+    def define_for(model)
+      @criteria = model.all
+      @model = model
+    end
+
+    def with_suffix(suffix: :Query)
+      singleton_class.send(:define_method, :suffix) do
+        suffix
+      end
+    end
+
+    def load_model
+      @model || define_for_model_by_remove_suffix
+    end
+
+    def define_for_model_by_remove_suffix
+      return if !defined?(suffix) || suffix.nil?
+      model_name = name[0..(name.length - suffix.length - 1)]
+      define_for(model_name.constantize)
+    end
+
+    def required_model!
+      raise TypeError, 'set defined scope for model first' unless model
+    end
   end
 end

data/lib/active_aggregate/relation.rb

@@ -2,9 +2,11 @@ class ActiveAggregate::Relation
   include ActiveSupport::Concern
 
   attr_reader :scope_class, :body
+  attr_accessor :cacheable
 
   def initialize(scope_class, body = nil, options = {})
     @scope_class = scope_class
+    @cacheable = true
     if body.respond_to?(:call)
       init_default_value(options)
       @body = body
@@ -15,9 +17,9 @@ class ActiveAggregate::Relation
 
   delegate :scope?, :scope_names, :model, to: :scope_class
   delegate :selector, to: :criteria
-  delegate :to_a, :count, :first, to: :aggregate
+  delegate :count, :first, to: :aggregate
   delegate :select, :find, :last, :group_by, :each_with_object, :each,
-           :map, :reduce, :reject,
+           :map, :reduce, :reject, :to_json,
            to: :to_a
 
   def query(options)
@@ -80,10 +82,10 @@ class ActiveAggregate::Relation
   def generate_execute_pipeline(select_all: false, aggregate: {})
     merge(aggregate) if aggregate.present?
     [].tap do |execute_pipeline|
-      execute_pipeline << { '$match': @criteria.selector } if @criteria
+      execute_pipeline << { '$match': selector } if selector.present?
       execute_pipeline << { '$group': @group } if @group.present?
       execute_pipeline << { '$sort': @sort } if @sort.present?
-      execute_pipeline << { '$project': project_selector } if select_all || @project.present?
+      execute_pipeline << { '$project': generate_project } if select_all || @project.present?
       execute_pipeline << { '$limit': @limit } if @limit.present?
       execute_pipeline.push(*@pipeline)
     end
@@ -107,6 +109,13 @@ class ActiveAggregate::Relation
     model.collection.aggregate(generate_execute_pipeline(options), *args)
   end
 
+  def to_a
+    return @as_array if cacheable && @as_array
+    aggregate.to_a.tap { |array| @as_array ||= array if cacheable }
+  end
+
+  alias load to_a
+
   def add_pipeline(*stages)
     @pipeline.push(*stages.flatten)
   end
@@ -136,6 +145,20 @@ class ActiveAggregate::Relation
     query_criteria(model.in(*args))
   end
 
+  def pluck(*fields)
+    fields = Array.wrap(fields).map(&:to_s)
+    to_a.each_with_object([]) do |doc, result|
+      record = if fields.size == 1
+                 doc[fields.first]
+               else
+                 doc.slice(*fields).values
+               end
+      result << record unless record.nil?
+    end
+  end
+
+  alias where_in in
+
   def any_of(*args)
     query_criteria(model.any_of(*args))
   end
@@ -164,7 +187,7 @@ class ActiveAggregate::Relation
 
   private
 
-  def init_default_value(criteria: nil, pipeline: [], group: nil, project: nil, sort: nil, limit: nil)
+  def init_default_value(criteria: model.all, pipeline: [], group: nil, project: nil, sort: nil, limit: nil)
     @criteria = format_criteria(criteria)
     @pipeline = pipeline.present? ? pipeline : []
     @group = group.present? ? group : {}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_aggregate
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Phan Quang Tien
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-25 00:00:00.000000000 Z
+date: 2020-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 5.0.1
 description: A toolkit for building queries like ActiveRelation. Rich support for
-  more flexible merge conditons, states
+  more flexible merge conditions, states
 email: 
 executables: []
 extensions: []
@@ -56,5 +56,5 @@ rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: active_aggregate is a little helper support to queries by mongoDB aggregate
-  more easily
+  more easily.
 test_files: []