ripple_searchable 0.0.1 → 0.0.2

data/README.md

@@ -1,9 +1,9 @@
 # RippleSearchable
 
 Mongoid / Active Record style query criteria DSL and Scoping for Ripple
-using RIAK's solr search interface.
+using RIAK's solr search interface. (riak_search must be enabled)
 
-RippleSearchable adds chainable Criteria methods such as :where, :lt, :lte, :gt, :gte, :between
+RippleSearchable adds named scopes, and chainable Criteria methods such as :where, :lt, :lte, :gt, :gte, :between
 along with :sort, :skip, :limit options to your Ripple::Document models.
 
 ## Installation
@@ -31,15 +31,19 @@ Any of the following criteria can be chained:
 === Example:
 
 ```ruby
-  Product.where(tags: "nerd", name: "joe", something: 2).or({can_sell:
-1}, {can_sell: 3}).between(availibility: 1..3, price: [3,
-12]).gte(quantity: 0, ratings: 5).sort(created_at, :desc).limit(5)
+  Product.where(tags: "nerd", name: "joe", something: 2).
+    or({can_sell:1}, {can_sell: 3}).
+    between(availibility: 1..3, price: [3, 12]).
+    gte(quantity: 0, ratings: 5).
+    sort(:created_at, :desc).limit(5)
 ```
 
 ### Scoping
 
 Mongoid / Active Record style named scopes:
 
+Use 'scope' class method to create a named scope that can be accessed from the class level or chained to criteria by the provided name.
+
 === Example:
 
 ```ruby
@@ -52,9 +56,12 @@ Mongoid / Active Record style named scopes:
   end
 ```
 
-See docs for method details.
+See [docs](http://rubydoc.info/github/computadude/ripple_searchable/master/frames) for method details.
+
+TODO: 
 
-TODO: Write better docs.
+Ability to bypass default scopes when using named scopes
+Write better docs.
 
 ## Contributing
 

data/lib/ripple_searchable/criteria.rb

@@ -27,13 +27,14 @@ module Ripple
     # will append this selector:
     # "(tags:nerd AND name:Joe AND something:2)"
     def where(selector = nil)
-      case selector
-      when String
-        add_restriction selector
-      when Hash
-        add_restriction to_lucene_pair(selector)
+      clone.tap do |crit|
+        case selector
+        when String
+          crit.add_restriction selector
+        when Hash
+          crit.add_restriction to_lucene_pair(selector)
+        end
       end
-      self
     end
 
     # Add an OR selector
@@ -45,12 +46,13 @@ module Ripple
     # will append this selector:
     # "((name:Pants) OR (name:Shirt))"
     def or(*criterion)
-      add_restriction do
-        criterion.each do |crit|
-          add_restriction(to_lucene_pair(crit, operator: "OR"), operator: "OR" )
+      clone.tap do |crit|
+        crit.add_restriction do
+          criterion.each do |c|
+            crit.add_restriction(to_lucene_pair(c, operator: "OR"), operator: "OR" )
+          end
         end
       end
-      self
     end
 
     alias :any_of :or
@@ -66,12 +68,13 @@ module Ripple
     # will append this selector:
     # "((availibility:[1 TO 3] AND price:[12 TO 20]))"
     def between(*criterion)
-      add_restriction do
-        criterion.each do |crit|
-          add_restriction(to_lucene_pair(crit, operator: "BETWEEN"))
+      clone.tap do |crit|
+        crit.add_restriction do
+          criterion.each do |c|
+            crit.add_restriction(to_lucene_pair(c, operator: "BETWEEN"))
+          end
         end
       end
-      self
     end
 
     # Add a 'less or equal than' selector
@@ -83,13 +86,14 @@ module Ripple
     # will append this selector:
     # "((quantity:[* TO 10] AND ratings:[* TO 5]))"
     def lte(*criterion)
-      add_restriction do
-        criterion.each do |crit|
-          crit.each {|k,v| crit[k]=Array.wrap(v).unshift(10**20)}
-          add_restriction(to_lucene_pair(crit, operator: "BETWEEN"))
+      clone.tap do |crit|
+        crit.add_restriction do
+          crit.criterion.each do |c|
+            c.each {|k,v| c[k]=Array.wrap(v).unshift(10**20)}
+            crit.add_restriction(to_lucene_pair(c, operator: "BETWEEN"))
+          end
         end
       end
-      self
     end
 
     # Add a 'greater or equal than' selector
@@ -101,13 +105,14 @@ module Ripple
     # will append this selector:
     # "((quantity:[0 TO *] AND ratings:[5 TO *]))"
     def gte(*criterion)
-      add_restriction do
-        criterion.each do |crit|
-          crit.each {|k,v| crit[k]=Array.wrap(v).push(10**20)}
-          add_restriction(to_lucene_pair(crit, operator: "BETWEEN"))
+      clone.tap do |crit|
+        crit.add_restriction do
+          crit.criterion.each do |c|
+            c.each {|k,v| c[k]=Array.wrap(v).push(10**20)}
+            crit.add_restriction(to_lucene_pair(c, operator: "BETWEEN"))
+          end
         end
       end
-      self
     end
 
     # Add a 'less than' selector
@@ -119,13 +124,14 @@ module Ripple
     # will append this selector:
     # "((quantity:{* TO 10} AND ratings:{* TO 5}))"
     def lt(*criterion)
-      add_restriction do
-        criterion.each do |crit|
-          crit.each {|k,v| crit[k]=Array.wrap(v).unshift("*")}
-          add_restriction(to_lucene_pair(crit, operator: "BETWEEN", exclusive: true))
+      clone.tap do |crit|
+        crit.add_restriction do
+          criterion.each do |c|
+            c.each {|k,v| c[k]=Array.wrap(v).unshift("*")}
+            crit.add_restriction(to_lucene_pair(c, operator: "BETWEEN", exclusive: true))
+          end
         end
       end
-      self
     end
 
     # Add a 'greater than' selector
@@ -137,13 +143,14 @@ module Ripple
     # will append this selector:
     # "((quantity:{0 TO *} AND ratings:{5 TO *}))"
     def gt(*criterion)
-      add_restriction do
-        criterion.each do |crit|
-          crit.each {|k,v| crit[k]=Array.wrap(v).push("*")}
-          add_restriction(to_lucene_pair(crit, operator: "BETWEEN", exclusive: true))
+      clone.tap do |crit|
+        crit.add_restriction do
+          criterion.each do |c|
+            c.each {|k,v| c[k]=Array.wrap(v).push("*")}
+            crit.add_restriction(to_lucene_pair(c, operator: "BETWEEN", exclusive: true))
+          end
         end
       end
-      self
     end
 
     # Add sort options to criteria
@@ -155,13 +162,14 @@ module Ripple
     # will append this sort option:
     # "availibility asc, created_at desc"
     def sort(sort_options)
-      case sort_options
-      when String
-        add_sort_option sort_options
-      when Hash
-        sort_options.each {|k,v| add_sort_option "#{k} #{v.downcase}"}
+      clone.tap do |crit|
+        case sort_options
+        when String
+          crit.add_sort_option sort_options
+        when Hash
+          sort_options.each {|k,v| crit.add_sort_option "#{k} #{v.downcase}"}
+        end
       end
-      self
     end
 
     alias :order_by :sort
@@ -175,9 +183,10 @@ module Ripple
     #
     # will limit the number of returned documetns to 10
     def limit(limit)
-      clear_cache
-      self.options[:rows] = limit
-      self
+      clone.tap do |crit|
+        crit.clear_cache
+        crit.options[:rows] = limit
+      end
     end
 
     alias :rows :limit
@@ -189,9 +198,10 @@ module Ripple
     #   Product.between(availibility:[1,3]).skip(10)
     #
     def skip(skip)
-      clear_cache
-      self.options[:start] = skip
-      self
+      clone.tap do |crit|
+        crit.clear_cache
+        crit.options[:start] = skip
+      end
     end
 
     alias :start :skip
@@ -231,20 +241,48 @@ module Ripple
     end
 
     def merge(criteria)
+      crit = clone
+      crit.merge!(criteria)
+      crit
+    end
+
+    def merge!(criteria)
       add_restriction criteria.selector
       self.options.merge!(criteria.options)
       self
     end
 
+    def to_proc
+      ->{ self }
+    end
+
+    def ==(other)
+      self.klass == other.klass && self.selector == other.selector && self.options == other.options
+    end
+
+    def initialize_copy(other)
+      @selector = other.selector.dup
+      @options = other.options.dup
+      if other.response.present?
+        @response = other.response.dup
+        @documents = other.documents.dup
+        @docs = other.docs.dup
+        @document_ids = other.document_ids.dup
+      end
+      super
+    end
+
     def method_missing(name, *args, &block)
       if klass.respond_to?(name)
         klass.send(:with_scope, self) do
           klass.send(name, *args, &block)
         end
+      else
+        super
       end
     end
 
-  private
+  protected
 
     def clear_cache
       @documents, @cached, @response, @total, @docs, @document_ids = [], false

data/lib/ripple_searchable/loggable.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Ripple
+  module Loggable
+
+    def logger
+      return @logger if defined?(@logger)
+      @logger = rails_logger || default_logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+  private
+
+    def default_logger
+      logger = Logger.new($stdout)
+      logger.level = Logger::INFO
+      logger
+    end
+
+    def rails_logger
+      defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+    end
+  end
+end

data/lib/ripple_searchable/scoping.rb

@@ -12,9 +12,26 @@ module Ripple
 
     module ClassMethods
 
+
+      # Create a scope that can be accessed from the class level or chained to
+      # criteria by the provided name.
+      #
+      # === Example
+      #
+      #   class Product
+      #     include Ripple::Document
+      #
+      #     scope :active, where(active: true)
+      #     scope :avail, ->(count){ where(quantity: count)}
+      #   end
+      #
+      #   Product.active.where(name: "peter")
+      #
+      # sets the selector to:
+      # "((active:true)) AND (name:peter)"
       def scope(name, value, &block)
         name = name.to_sym
-        #valid_scope_name?(name)
+        valid_scope_name?(name)
         scopes[name] = {
           scope: strip_default_scope(value),
           extension: Module.new(&block)
@@ -22,12 +39,29 @@ module Ripple
         define_scope_method(name)
       end
 
+      def default_scope(value)
+        self.default_scoping = if default_scoping
+          ->{ default_scoping.call.merge(value.to_proc.call) } unless default_scoping.call == value
+        else
+          value.to_proc
+        end
+      end
+
       def scope_stack
         Thread.current[:"#{self.bucket_name}_scope_stack"] ||= []
       end
 
       def with_default_scope
-        default_scoping || scope_stack.last || Criteria.new(self)
+        default_scoping.try(:call) || without_default_scope
+      end
+
+      def without_default_scope
+        Thread.current[:"#{self.bucket_name}_without_default_scope"] = true
+        scope_stack.last || Criteria.new(self)
+      end
+
+      def without_default_scope?
+        Thread.current[:"#{self.bucket_name}_without_default_scope"]
       end
 
       def with_scope(criteria)
@@ -42,8 +76,8 @@ module Ripple
     protected
 
       def valid_scope_name?(name)
-        if logger && respond_to?(name, true)
-          logger.warn "Creating scope :#{name}. " \
+        if Ripple.logger && respond_to?(name, true)
+          Ripple.logger.warn "Creating scope :#{name}. " \
                       "Overwriting existing method #{self.name}.#{name}."
         end
       end
@@ -62,7 +96,7 @@ module Ripple
 
       def strip_default_scope(value)
         if value.is_a?(Criteria)
-          ->{ value}
+          value.to_proc
         else
           value
         end

data/lib/ripple_searchable/searchable.rb

@@ -27,7 +27,7 @@ module Ripple
       end
 
       def criteria
-        @criteria = Criteria.new(self)
+        @criteria = default_scoping.try(:call) || Criteria.new(self)
       end
     end
 

data/lib/ripple_searchable/version.rb

@@ -1,3 +1,3 @@
 module RippleSearchable
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/ripple_searchable.rb

@@ -4,8 +4,13 @@ require 'active_support/concern'
 require 'ripple_searchable/version'
 require 'ripple_searchable/searchable'
 require 'ripple_searchable/criteria'
+require 'ripple_searchable/loggable'
 require 'ripple_searchable/scoping'
 
+Ripple.class_eval do
+  extend Ripple::Loggable
+end
+
 Ripple::Document.class_eval do
   include Ripple::Searchable
   include Ripple::Scoping

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ripple_searchable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-17 00:00:00.000000000 Z
+date: 2012-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -101,6 +101,7 @@ files:
 - Rakefile
 - lib/ripple_searchable.rb
 - lib/ripple_searchable/criteria.rb
+- lib/ripple_searchable/loggable.rb
 - lib/ripple_searchable/scoping.rb
 - lib/ripple_searchable/searchable.rb
 - lib/ripple_searchable/version.rb