queryable 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f519477ea7a61d9e99c9cff819433102ac236bcd
+  data.tar.gz: 47402fda61136b8ceaae98d9c214b12ffb586df1
+SHA512:
+  metadata.gz: 632bbebc1ce1e6765892f2ac67d56fd91b0a71f57bc00dc057f502075095ec090298b00f7a7f174360dfda8cea8978c16595208f705f6a8955f0052fe662c63b
+  data.tar.gz: 2b7d37a7463b29fbd5c81fb27bf948f914fff896cc286320eae3ba12686609a268c83d26dcd9dd5993a304ecaee5448d6913f8bf78665d2dd409c4024655cd18

data/README.md

@@ -0,0 +1,10 @@
+Queryable
+=====================
+[![Coverage Status](https://coveralls.io/repos/ElMassimo/queryable/badge.png)](https://coveralls.io/r/ElMassimo/queryable)
+
+
+Allows you to easily define query objects with chainable scopes.
+
+## Usage
+
+## Background

data/lib/queryable.rb

@@ -0,0 +1,113 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+
+# Public: Mixin that adds Queryable functionality to a plain ruby object.
+# A Queryable manages an internal query object, and defines chainable methods
+# that interact with the query object, modifying its value.
+# It's designed to work well with both Mongoid and ActiveRecord.
+#
+# Examples
+#
+#   class PersonQuery
+#     include Queryable
+#     scope(:too_damn_high) { where(:level.gt => 9000) }
+#   end
+#
+module Queryable
+  extend ActiveSupport::Concern
+
+  included do
+    # Public: Gets/Sets the internal query.
+    attr_accessor :query
+
+    delegate *delegated_methods, to: :query
+  end
+
+  # Public: Initialize a Queryable with a query.
+  #
+  # query - The internal query to build upon.
+  def initialize(query)
+    @query = query.all
+  end
+
+  # Public: Convenience setter for the internal query that returns self. The
+  # query is set to the value returned by the block. Useful when you need to
+  # access the context of the Queryable in addition to the query.
+  #
+  # block - A block that returns the new value of the internal query.
+  #
+  # Yields the internal query, which can be used to build upon.
+  #  def search(query)
+  #
+  # Examples
+  #
+  #   # Accessing a constant in the Queryable object context.
+  #   LATEST_COUNT = 10
+  #   def latest
+  #     define_query {|query| query.limit(LATEST_COUNT) }
+  #   end
+  #
+  #   # We use it because the last method we chain does not return self.
+  #   def recent_by_name
+  #     define_query { recent.order(:name) }
+  #   end
+  #
+  #   # Extracted from a scope for clarity.
+  #   def search(field_values)
+  #     define_query do |user|
+  #       field_values.inject(user) { |user, (field, value)|
+  #         user.where(field => /#{value}/i)
+  #       }
+  #     end
+  #   end
+  #
+  # Returns the Queryable object itself (self).
+  def define_query
+    @query = yield(query)
+    self
+  end
+
+  # Internal: Contains the Queryable class methods.
+  module ClassMethods
+    # Public: Defines a new method that executes the passed proc or block in
+    # the context of the internal query object, and returns self.
+    #
+    # name - Name of the scope to define for this Queryable.
+    #
+    # proc - An optional proc or lambda to be executed in the context of the
+    #        the current query.
+    #
+    # block - An optional block to be executed in the context of the current
+    #         query.
+    #
+    # Yields the arguments given to the scope when invoked, generally none.
+    #
+    # Examples
+    #
+    #   scope :active, ->{ where(status: 'active') }
+    #
+    #   scope(:recent) { desc(:created_at) }
+    #
+    #   scope :of_brand do |brand|
+    #     where(_type: "#{brand}ExtremelyFastRacingCar")
+    #   end
+    #
+    # Returns nothing.
+    def scope(name, proc=nil, &block)
+      define_method(name) do |*args|
+        @query = query.instance_exec *args, &(proc || block)
+        self
+      end
+    end
+
+    # Internal: Methods to be delegated to the internal query. Method
+    # can be safely overriden to add or remove methods to delegate.
+    #
+    # Returns an Array with the name of the methods to delegate.
+    def delegated_methods
+      Array.instance_methods - Object.instance_methods +
+      [:all, :where, :distinct, :group, :having, :includes, :joins, :limit, :offset, :order, :reverse_order] +
+      [:==, :as_json, :cache_key, :decorate]
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: queryable
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Máximo Mussini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Queryable is a module that encapsulates query building so you don't have
+  to tuck scopes inside your models.
+email:
+- maximomussini@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/queryable.rb
+homepage: https://github.com/ElMassimo/queryable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Keep your scopes and queries flexible by using Ruby
+test_files: []
+has_rdoc: