active_aggregate 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 653177242ed87c2c3965933b6a7932644528af9ad7a5a861d950c0e5b3bd7078
+  data.tar.gz: fcb515097fb8001c7cc314e7bca0131b1ab83ea155a3d69300537b77126bff9a
+SHA512:
+  metadata.gz: f086dc4d9a449ba36d25d775e85c52b2bd61299a4cedfe104b3a715917cd9e0037affc4410bfa1c2b609d8000a5410c279fe4d0dd1a15034373c0301429e17a3
+  data.tar.gz: f6d84f33cf8c04003f3436df053fd5e86932c1edb7e04217768e5863b42f693fc1a9110e53b9939c1360b2483f9130c7f7b16de37e4df8ebd7720cfaa5efe2d6

data/README.md

@@ -0,0 +1,10 @@
+# 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
+
+## Getting started
+
+```ruby
+gem install active_aggregate
+```

data/lib/active_aggregate/concern.rb

@@ -0,0 +1,55 @@
+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,
+             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
+      scope_name = name.to_sym
+      scopes[scope_name] = ActiveAggregate::Relation.new(self, *options)
+      singleton_class.send(:define_method, scope_name) do |*args|
+        return scopes[scope_name].generate(*args)
+      end
+    end
+
+    def all
+      raise TypeError, 'set defined scope for model first' unless model
+      ActiveAggregate::Relation.new(self).generate
+    end
+
+    def scope_names
+      scopes.keys
+    end
+
+    def scope?(scope_name)
+      scopes.key?(scope_name.to_sym)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      scope?(method_name) || super
+    end
+
+    def method_missing(scope_name, *args, &block)
+      name = scope_name.to_sym
+      if scope?(name)
+        merge(public_send(name, *args, &block))
+      else
+        super
+      end
+    end
+
+    def scopes
+      @scopes ||= {}
+    end
+  end
+end

data/lib/active_aggregate/relation.rb

@@ -0,0 +1,184 @@
+class ActiveAggregate::Relation
+  include ActiveSupport::Concern
+
+  attr_reader :scope_class, :body
+
+  def initialize(scope_class, body = nil, options = {})
+    @scope_class = scope_class
+    if body.respond_to?(:call)
+      init_default_value(options)
+      @body = body
+    else
+      init_default_value(body.nil? ? options : body)
+    end
+  end
+
+  delegate :scope?, :scope_names, :model, to: :scope_class
+  delegate :selector, to: :criteria
+  delegate :to_a, :count, :first, to: :aggregate
+  delegate :select, :find, :last, :group_by, :each_with_object, :each,
+           :map, :reduce, :reject,
+           to: :to_a
+
+  def query(options)
+    case options
+    when Hash
+      merge(self.class.new(scope_class, options))
+    when self.class
+      merge(options)
+    else
+      self
+    end
+  end
+
+  def query_criteria(options)
+    query(criteria: options)
+  end
+
+  def group(options)
+    query(group: options)
+  end
+
+  def pipeline(options)
+    query(pipeline: options)
+  end
+
+  def project(options)
+    query(project: options)
+  end
+
+  def sort(options)
+    @sort = options
+    self
+  end
+
+  def limit(options)
+    @limit = options
+    self
+  end
+
+  def expose
+    {
+      pipeline: @pipeline,
+      criteria: @criteria,
+      group: @group,
+      project: @project,
+      sort: @sort,
+      limit: @limit
+    }
+  end
+
+  def generate_project
+    return @project if @project.present?
+    selector.keys.each_with_object({}) { |con, hashes| hashes[con] = "$#{con}" }
+  end
+
+  def selector
+    @criteria ? @criteria.selector : {}
+  end
+
+  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 << { '$group': @group } if @group.present?
+      execute_pipeline << { '$sort': @sort } if @sort.present?
+      execute_pipeline << { '$project': project_selector } if select_all || @project.present?
+      execute_pipeline << { '$limit': @limit } if @limit.present?
+      execute_pipeline.push(*@pipeline)
+    end
+  end
+
+  def generate(*args)
+    return self if body.nil?
+    result = scope_class.instance_exec(*args, &body)
+    case result
+    when Hash
+      init_default_value(merge_exposed(result))
+      self
+    when self.class
+      merge(result)
+    else
+      self
+    end
+  end
+
+  def aggregate(options = {}, *args)
+    model.collection.aggregate(generate_execute_pipeline(options), *args)
+  end
+
+  def add_pipeline(*stages)
+    @pipeline.push(*stages.flatten)
+  end
+
+  def override(*stages)
+    @pipeline = stages.flatten
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    scope?(scope_name) || super
+  end
+
+  def method_missing(scope_name, *args, &block)
+    name = scope_name.to_sym
+    if scope?(scope_name)
+      merge(scope_class.public_send(name, *args, &block))
+    else
+      super
+    end
+  end
+
+  def where(*args)
+    query_criteria(model.where(*args))
+  end
+
+  def in(*args)
+    query_criteria(model.in(*args))
+  end
+
+  def any_of(*args)
+    query_criteria(model.any_of(*args))
+  end
+
+  def all_of(*args)
+    query_criteria(model.all_of(*args))
+  end
+
+  def merge(relation)
+    if !relation.is_a?(ActiveAggregate::Relation) || relation.scope_class != scope_class
+      raise TypeError, "#relation much be an ActiveAggregate::Relation of #{scope_class}"
+    end
+    self.class.new(scope_class, merge_exposed(relation.expose))
+  end
+
+  def merge_exposed(exposed)
+    {
+      pipeline: @pipeline + (exposed[:pipeline] || []),
+      criteria: [@criteria, format_criteria(exposed[:criteria])].compact.reduce(&:merge),
+      group: [@group, exposed[:group]].compact.reduce(&:deep_merge),
+      project: [@project, exposed[:project]].compact.reduce(&:deep_merge),
+      sort: exposed[:sort] || nil,
+      limit: exposed[:limit] || nil
+    }
+  end
+
+  private
+
+  def init_default_value(criteria: nil, pipeline: [], group: nil, project: nil, sort: nil, limit: nil)
+    @criteria = format_criteria(criteria)
+    @pipeline = pipeline.present? ? pipeline : []
+    @group = group.present? ? group : {}
+    @project = project.present? ? project : {}
+    @sort = sort
+    @limit = limit
+  end
+
+  def format_criteria(criteria)
+    case criteria
+    when Mongoid::Criteria
+      criteria
+    when self.class
+      format_criteria(criteria.expose[:criteria])
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: active_aggregate
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Phan Quang Tien
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.1
+description: A toolkit for building queries like ActiveRelation. Rich support for
+  more flexible merge conditons, states
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/active_aggregate/concern.rb
+- lib/active_aggregate/relation.rb
+homepage: https://github.com/phantien133/active_aggregate
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+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
+test_files: []