redis-search 0.9.7 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 715f373324e8d649a86d38d05ce25e044b4ebacc
-  data.tar.gz: bc32f91272a550a62f697366df1c807d2b7c58c2
+  metadata.gz: c3db9e3cf11d6d82edb9366ec887db853a684468
+  data.tar.gz: 349c2ad7333803b7f868cabd5ee4053f216b9e14
 SHA512:
-  metadata.gz: dc3272074ff70fd82998bd46d7b566a6072ceb7c3820411e8169386f395cecf98896100934edae3e15e1bf50406a7e3556de1c15f0f32e402deb01d548f882ad
-  data.tar.gz: c115f7733556b42db81f707d0a857697e9881cf78b5e7dabbd3b2d67dd3d72d953e84a4b04a98af23190aae3546287abaf9c8902f36c93b0a19ec82d0a5385fe
+  metadata.gz: e1d2dcf8826e6c4e0e3a9414fdc0a8f1b11fc9d0cf024f5c6d5ab27e56e7da3c436f5ab20d1c487f6e2feab09d24462de24cee03209ecccf5c4ce7c51a56d423
+  data.tar.gz: 9389c3f640c4ff76719507d681fb0d8ba4bc24cb7d36544617c76c4d209709121ec87e052e2ae4e6d52ecbb9cba3e09b212aafc1fa07e025c1dbc0a840dffbf1

data/README.md

@@ -4,17 +4,10 @@ High performance real-time search (Support Chinese), index in Redis for Rails ap
 
 [中文介绍和使用说明](https://github.com/huacnlee/redis-search/wiki/Usage-in-Chinese)
 
-## Demo
-
-![](http://l.ruby-china.org/photo/34368688ee1c1928c2841eb2f41306ec.png)
-
-You can try the search feature in [`IMAX.im`](http://imax.im) | [`shu.im`](http://shu.im)
-
-And there is an  [Example App](https://github.com/huacnlee/redis-search-example) to show you how to use redis-search.
-
 ## Master Status
 
-[![CI Status](https://secure.travis-ci.org/huacnlee/redis-search.png)](http://travis-ci.org/huacnlee/redis-search)
+[![Gem Version](https://badge.fury.io/rb/redis-search.svg)](https://badge.fury.io/rb/redis-search) [![CI Status](https://secure.travis-ci.org/huacnlee/redis-search.svg)](http://travis-ci.org/huacnlee/redis-search) [![CodeCov](https://codecov.io/gh/huacnlee/redis-search/branch/master/graph/badge.svg)](https://codecov.io/gh/huacnlee/redis-search)
+
 
 ## Features
 
@@ -34,99 +27,87 @@ And there is an  [Example App](https://github.com/huacnlee/redis-search-example)
 
 ## Install
 
-1. In Rails application Gemfile
-
-    ```ruby
-    gem 'ruby-pinyin', '0.3.0'
-    gem 'redis-search', '0.9.6'
-    ```
+```ruby
+gem 'redis-search'
+```
 
-    ```bash
-    $ bundle install
-    ```
+```bash
+$ bundle install
+```
 
 ## Configure
 
-* Create file in: config/initializers/redis_search.rb
-
-    ```ruby
-    require "redis"
-    require "redis-namespace"
-    require "redis-search"
-    # don't forget change namespace
-    redis = Redis.new(:host => "127.0.0.1",:port => "6379")
-    # We suggest you use a special db in Redis, when you need to clear all data, you can use flushdb command to clear them.
-    redis.select(3)
-    # Give a special namespace as prefix for Redis key, when your have more than one project used redis-search, this config will make them work fine.
-    redis = Redis::Namespace.new("your_app_name:redis_search", :redis => redis)
-    Redis::Search.configure do |config|
-      config.redis = redis
-      config.complete_max_length = 100
-      config.pinyin_match = true
-      # use rmmseg, true to disable it, it can save memroy
-      config.disable_rmmseg = false
-    end
-    ```
+* Create file in: config/initializers/redis-search.rb
+
+```ruby
+require "redis"
+require "redis-namespace"
+require "redis-search"
+
+# don't forget change namespace
+redis = Redis.new(host: '127.0.0.1', port: '6379')
+# We suggest you use a special db in Redis, when you need to clear all data, you can use `flushdb` command to cleanup.
+redis.select(3)
+# Give a special namespace as prefix for Redis key, when your have more than one project used redis-search, this config will make them work fine.
+redis = Redis::Namespace.new("your_app_name:redis_search", redis: redis)
+Redis::Search.configure do |config|
+  config.redis = redis
+  config.complete_max_length = 100
+  config.pinyin_match = true
+  # use rmmseg, true to disable it, it can save memroy
+  config.disable_rmmseg = false
+end
+```
 
 ## Usage
 
-* Bind Redis::Search callback event, it will to rebuild search indices when data create or update.
-
-    ```ruby
-    class Post
-      include Mongoid::Document
-      include Redis::Search
-
-      field :title
-      field :body
-      field :hits
-
-      belongs_to :user
-      belongs_to :category
-
-      redis_search_index(:title_field => :title,
-                         :score_field => :hits,
-                         :condition_fields => [:user_id, :category_id],
-                         :ext_fields => [:category_name])
-
-      def category_name
-        self.category.name
-      end
-    end
-    ```
-
-    ```ruby
-    class User
-      include Mongoid::Document
-      include Redis::Search
-
-      field :name
-      field :alias_names, :type => Array
-      field :tagline
-      field :email
-      field :followers_count
-
-      redis_search_index(:title_field => :name,
-                         :alias_field => :alias_names,
-                         :prefix_index_enable => true,
-                         :score_field => :followers_count,
-                         :ext_fields => [:email,:tagline])
-    end
-    ```
-
-    ```ruby
-    class SearchController < ApplicationController
-      # GET /searchs?q=title
-      def index
-        Redis::Search.query("Post", params[:q], :conditions => {:user_id => 12})
-      end
-
-      # GET /search_users?q=j
-      def search_users
-        Redis::Search.complete("Post", params[:q], :conditions => {:user_id => 12, :category_id => 4})
-      end
-    end
-    ```
+* Bind `Redis::Search` callback event, it will to rebuild search indices when data create or update.
+
+```ruby
+class Post < ActiveRecord::Base
+  include Redis::Search
+
+  belongs_to :user
+  belongs_to :category
+
+  redis_search_index(title_field: :title,
+                     score_field: :hits,
+                     condition_fields: [:user_id, :category_id],
+                     ext_fields: [:category_name])
+
+  def category_name
+    self.category.name
+  end
+end
+```
+
+```ruby
+class User < ActiveRecord::Base
+  include Redis::Search
+
+  serialize :alias_names, Array
+
+  redis_search_index(title_field: :name,
+                     alias_field: :alias_names,
+                     prefix_index_enable: true,
+                     score_field: :followers_count,
+                     ext_fields: [:email, :tagline])
+end
+```
+
+```ruby
+class SearchController < ApplicationController
+  # GET /searchs?q=title
+  def index
+    Redis::Search.query("Post", params[:q], conditions: { user_id: 12 })
+  end
+
+  # GET /search_users?q=j
+  def search_users
+    Redis::Search.complete("Post", params[:q], conditions: { user_id: 12, category_id: 4 })
+  end
+end
+```
 
 ## Index data to Redis
 
@@ -135,13 +116,13 @@ And there is an  [Example App](https://github.com/huacnlee/redis-search-example)
 Redis-Search index data to Redis from your model (pass name as CLASS environment variable).
 
 ```bash
-$ rake redis_search:index:model CLASS='MyModel'
+$ rake redis_search:index:model CLASS='User'
 ```
 
 Customize the batch size:
 
 ```bash
-$ rake redis_search:index:model CLASS='MyModel' BATCH=100
+$ rake redis_search:index:model CLASS='User' BATCH=100
 ```
 
 ### All Models
@@ -170,6 +151,15 @@ There is my performance test result.
 
 * [https://gist.github.com/1150933](https://gist.github.com/1150933)
 
+## Demo
+
+![](http://l.ruby-china.org/photo/34368688ee1c1928c2841eb2f41306ec.png)
+
+Projects used redis-search:
+
+- [redis-search-example](https://github.com/huacnlee/redis-search-example) - An example for show you how to use redis-search.
+- [IMAX.im](https://github.com/huacnlee/imax.im)
+
 ## License
 
 * MIT

data/lib/redis-search.rb

@@ -1,6 +1,6 @@
-# coding: utf-8
-require "redis/search/base"
-require "redis/search/finder"
-require "redis/search/index"
-require "redis/search/config"
-require 'redis/search/railtie' if defined?(Rails)
+require 'redis-search/base'
+require 'redis-search/finder'
+require 'redis-search/index'
+require 'redis-search/config'
+require 'redis-search/version'
+require 'redis-search/railtie' if defined?(Rails)

data/lib/{redis/search → redis-search}/base.rb

@@ -1,9 +1,9 @@
-# coding: utf-8
 class Redis
+  # nodoc
   module Search
     autoload :PinYin, 'ruby-pinyin'
 
-    extend ::ActiveSupport::Concern
+    extend ActiveSupport::Concern
 
     included do
       cattr_reader :redis_search_options
@@ -22,28 +22,28 @@ class Redis
     end
 
     def redis_search_alias_value(field)
-      return [] if field.blank? || field == "_was".freeze
-      val = (instance_eval("self.#{field}") || "".freeze).clone
-      return [] if !val.class.in?([String,Array])
-      if val.is_a?(String)
-        val = val.to_s.split(",")
-      end
+      return [] if field.blank? || field == '_was'.freeze
+      val = (instance_eval("self.#{field}") || ''.freeze).clone
+      return [] unless val.class.in?([String, Array])
+      val = val.to_s.split(',') if val.is_a?(String)
       val
     end
 
     # Rebuild search index with create
     def redis_search_index_create
-      s = Search::Index.new(title: self.send(self.redis_search_options[:title_field]),
-                            aliases: self.redis_search_alias_value(self.redis_search_options[:alias_field]),
-                            id: self.id,
-                            exts: self.redis_search_fields_to_hash(self.redis_search_options[:ext_fields]),
-                            type: self.redis_search_options[:class_name] || self.class.name,
-                            condition_fields: self.redis_search_options[:condition_fields],
-                            score: self.send(self.redis_search_options[:score_field]).to_i,
-                            prefix_index_enable: self.redis_search_options[:prefix_index_enable])
+      opts = {
+        title: send(redis_search_options[:title_field]),
+        aliases: redis_search_alias_value(redis_search_options[:alias_field]),
+        id: id,
+        exts: redis_search_fields_to_hash(redis_search_options[:ext_fields]),
+        type: redis_search_options[:class_name] || self.class.name,
+        condition_fields: redis_search_options[:condition_fields],
+        score: send(redis_search_options[:score_field]).to_i,
+        prefix_index_enable: redis_search_options[:prefix_index_enable]
+      }
+
+      s = Search::Index.new(opts)
       s.save
-      # release s
-      s = nil
       true
     end
 
@@ -51,15 +51,14 @@ class Redis
       titles.uniq!
       titles.each do |title|
         next if title.blank?
-        Search::Index.remove(id: self.id, title: title, type: self.class.name)
+        Search::Index.remove(id: id, title: title, type: self.class.name)
       end
       true
     end
 
     def redis_search_index_before_destroy
-      titles = []
-      titles = redis_search_alias_value(self.redis_search_options[:alias_field])
-      titles << self.send(self.redis_search_options[:title_field])
+      titles = redis_search_alias_value(redis_search_options[:alias_field])
+      titles << send(redis_search_options[:title_field])
 
       redis_search_index_delete(titles)
       true
@@ -67,10 +66,10 @@ class Redis
 
     def redis_search_index_need_reindex
       index_fields_changed = false
-      self.redis_search_options[:ext_fields].each do |f|
-        next if f.to_s == "id".freeze
+      redis_search_options[:ext_fields].each do |f|
+        next if f.to_s == 'id'.freeze
         field_method = "#{f}_changed?"
-        if self.methods.index(field_method.to_sym) == nil
+        if methods.index(field_method.to_sym).nil?
           Redis::Search.warn("#{self.class.name} model reindex on update need #{field_method} method.")
           next
         end
@@ -79,24 +78,24 @@ class Redis
       end
 
       begin
-        if self.send("#{self.redis_search_options[:title_field]}_changed?")
+        if send("#{redis_search_options[:title_field]}_changed?")
           index_fields_changed = true
         end
 
-        if self.send(self.redis_search_options[:alias_field]) || self.send("#{self.redis_search_options[:title_field]}_changed?")
+        if send(redis_search_options[:alias_field]) ||
+           send("#{redis_search_options[:title_field]}_changed?")
           index_fields_changed = true
         end
       rescue
       end
 
-      return index_fields_changed
+      index_fields_changed
     end
 
     def redis_search_index_after_update
-      if self.redis_search_index_need_reindex
-        titles = []
-        titles = redis_search_alias_value("#{self.redis_search_options[:alias_field]}_was")
-        titles << self.send("#{self.redis_search_options[:title_field]}_was")
+      if redis_search_index_need_reindex
+        titles = redis_search_alias_value("#{redis_search_options[:alias_field]}_was")
+        titles << send("#{redis_search_options[:title_field]}_was")
         redis_search_index_delete(titles)
       end
 
@@ -104,8 +103,8 @@ class Redis
     end
 
     def redis_search_index_after_save
-      if self.redis_search_index_need_reindex || self.new_record?
-        self.redis_search_index_create
+      if redis_search_index_need_reindex || new_record?
+        redis_search_index_create
       end
       true
     end
@@ -134,32 +133,32 @@ class Redis
         opts[:ext_fields] += opts[:condition_fields] if opts[:condition_fields].is_a?(Array)
 
         # store Model name to indexed_models for Rake tasks
-        Search.indexed_models = [] if Search.indexed_models == nil
+        Search.indexed_models = [] if Search.indexed_models.nil?
         Search.indexed_models << self
 
-        class_variable_set("@@redis_search_options".freeze, opts)
+        class_variable_set('@@redis_search_options'.freeze, opts)
       end
 
       def redis_search_index_batch_create(batch_size = 1000, progressbar = false)
         count = 0
-        if self.ancestors.collect { |klass| klass.to_s }.include?("ActiveRecord::Base".freeze)
-          find_in_batches(:batch_size => batch_size) do |items|
+        if ancestors.collect(&:to_s).include?('ActiveRecord::Base'.freeze)
+          find_in_batches(batch_size: batch_size) do |items|
             items.each do |item|
               item.redis_search_index_create
               count += 1
-              print "." if progressbar
+              print '.' if progressbar
             end
           end
-        elsif self.included_modules.collect { |m| m.to_s }.include?("Mongoid::Document".freeze)
+        elsif included_modules.collect(&:to_s).include?('Mongoid::Document'.freeze)
           all.each_slice(batch_size) do |items|
             items.each do |item|
               item.redis_search_index_create
               count += 1
-              print "." if progressbar
+              print '.' if progressbar
             end
           end
         else
-          puts "skiped, not support this ORM in current."
+          puts 'skiped, not support this ORM in current.'
         end
 
         count

data/lib/{redis/search → redis-search}/config.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 class Redis
   module Search
     class << self
@@ -7,8 +6,8 @@ class Redis
       def configure
         yield @config ||= Config.new
 
-        if not @config.disable_rmmseg
-          require "rmmseg"
+        unless @config.disable_rmmseg
+          require 'rmmseg'
           # loading RMMSeg chinese word dicts.
           RMMSeg::Dictionary.load_dictionaries
         end

data/lib/{redis/search → redis-search}/finder.rb

@@ -13,7 +13,9 @@ class Redis
       #   type      model name
       #   w         search char
       #   :limit    result limit
+      #
       # h3. usage:
+      #
       # * Redis::Search.complete("Tag","r") => ["Ruby","Rails", "REST", "Redis", "Redmine"]
       # * Redis::Search.complete("Tag","re") => ["Redis", "Redmine"]
       # * Redis::Search.complete("Tag","red") => ["Redis", "Redmine"]
@@ -25,24 +27,24 @@ class Redis
 
         prefix_matchs = []
         # This is not random, try to get replies < MTU size
-        rangelen = self.config.complete_max_length
+        rangelen = config.complete_max_length
         prefix = w.downcase
-        key = self.mk_complete_key(type)
+        key = mk_complete_key(type)
 
-        if start = self.config.redis.zrank(key,prefix)
+        if start = config.redis.zrank(key, prefix)
           count = limit
           max_range = start + (rangelen * limit) - 1
-          range = self.config.redis.zrange(key,start,max_range)
+          range = config.redis.zrange(key, start, max_range)
           while prefix_matchs.length <= count
             start += rangelen
-            break if !range || range.length == 0
+            break if !range || range.empty?
             range.each do |entry|
-              minlen = [entry.length,prefix.length].min
+              minlen = [entry.length, prefix.length].min
               if entry[0...minlen] != prefix[0...minlen]
                 count = prefix_matchs.count
                 break
               end
-              if entry[-1..-1] == "*" && prefix_matchs.length != count
+              if entry[-1..-1] == '*' && prefix_matchs.length != count
                 prefix_matchs << entry[0...-1]
               end
             end
@@ -53,25 +55,25 @@ class Redis
         prefix_matchs.uniq!
 
         # 组合 words 的特别 key 名
-        words = prefix_matchs.collect { |w| self.mk_sets_key(type,w) }
+        words = prefix_matchs.collect { |w| mk_sets_key(type, w) }
 
         # 组合特别 key ,但这里不会像 query 那样放入 words， 因为在 complete 里面 words 是用 union 取的，condition_keys 和 words 应该取交集
         condition_keys = []
-        if !conditions.blank?
+        unless conditions.blank?
           conditions = conditions[0] if conditions.is_a?(Array)
           conditions.keys.each do |c|
-            condition_keys << self.mk_condition_key(type,c,conditions[c])
+            condition_keys << mk_condition_key(type, c, conditions[c])
           end
         end
 
         # 按词语搜索
-        temp_store_key = "tmpsunionstore:#{words.join("+")}"
+        temp_store_key = "tmpsunionstore:#{words.join('+')}"
         if words.length > 1
-          if !self.config.redis.exists(temp_store_key)
+          unless config.redis.exists(temp_store_key)
             # 将多个词语组合对比，得到并集，并存入临时区域
-            self.config.redis.sunionstore(temp_store_key,*words)
+            config.redis.sunionstore(temp_store_key, *words)
             # 将临时搜索设为1天后自动清除
-            self.config.redis.expire(temp_store_key,86400)
+            config.redis.expire(temp_store_key, 86_400)
           end
           # 根据需要的数量取出 ids
         else
@@ -79,21 +81,21 @@ class Redis
         end
 
         # 如果有条件，这里再次组合一下
-        if !condition_keys.blank?
-          condition_keys << temp_store_key if !words.blank?
+        unless condition_keys.blank?
+          condition_keys << temp_store_key unless words.blank?
           temp_store_key = "tmpsinterstore:#{condition_keys.join('+')}"
-          if !self.config.redis.exists(temp_store_key)
-            self.config.redis.sinterstore(temp_store_key,*condition_keys)
-            self.config.redis.expire(temp_store_key,86400)
+          unless config.redis.exists(temp_store_key)
+            config.redis.sinterstore(temp_store_key, *condition_keys)
+            config.redis.expire(temp_store_key, 86_400)
           end
         end
 
-        ids = self.config.redis.sort(temp_store_key,
-                                     limit: [0,limit],
-                                     by: self.mk_score_key(type,"*"),
-                                     order: "desc")
+        ids = config.redis.sort(temp_store_key,
+                                limit: [0, limit],
+                                by: mk_score_key(type, '*'),
+                                order: 'desc')
         return [] if ids.blank?
-        self.hmget(type,ids)
+        hmget(type, ids)
       end
 
       # Search items, this will split words by Libmmseg
@@ -102,26 +104,28 @@ class Redis
       #   type      model name
       #   text         search text
       #   :limit    result limit
+      #
       # h3. usage:
       # * Redis::Search.query("Tag","Ruby vs Python")
+      #
       def query(type, text, options = {})
         tm         = Time.now
         result     = []
         limit      = options[:limit] || 10
-        sort_field = options[:sort_field] || "id"
+        sort_field = options[:sort_field] || 'id'
         conditions = options[:conditions] || []
 
         # 如果搜索文本和查询条件均没有，那就直接返回 []
         return result if text.strip.blank? && conditions.blank?
 
-        words = self.split(text)
-        words = words.collect { |w| self.mk_sets_key(type,w) }
+        words = split(text)
+        words = words.collect { |w| mk_sets_key(type, w) }
 
         condition_keys = []
-        if !conditions.blank?
+        unless conditions.blank?
           conditions = conditions[0] if conditions.is_a?(Array)
           conditions.keys.each do |c|
-            condition_keys << self.mk_condition_key(type,c,conditions[c])
+            condition_keys << mk_condition_key(type, c, conditions[c])
           end
           # 将条件的 key 放入关键词搜索集合内，用于 sinterstore 搜索
           words += condition_keys
@@ -129,30 +133,30 @@ class Redis
 
         return result if words.blank?
 
-        temp_store_key = "tmpinterstore:#{words.join("+")}"
+        temp_store_key = "tmpinterstore:#{words.join('+')}"
 
         if words.length > 1
-          if !self.config.redis.exists(temp_store_key)
-            self.config.redis.pipelined do
+          unless config.redis.exists(temp_store_key)
+            config.redis.pipelined do
               # 将多个词语组合对比，得到交集，并存入临时区域
-              self.config.redis.sinterstore(temp_store_key,*words)
+              config.redis.sinterstore(temp_store_key, *words)
               # 将临时搜索设为1天后自动清除
-              self.config.redis.expire(temp_store_key,86400)
+              config.redis.expire(temp_store_key, 86_400)
 
               # 拼音搜索
-              if self.config.pinyin_match
-                pinyin_words = self.split_pinyin(text)
-                pinyin_words = pinyin_words.collect { |w| self.mk_sets_key(type,w) }
+              if config.pinyin_match
+                pinyin_words = split_pinyin(text)
+                pinyin_words = pinyin_words.collect { |w| mk_sets_key(type, w) }
                 pinyin_words += condition_keys
-                temp_sunion_key = "tmpsunionstore:#{words.join("+")}"
-                temp_pinyin_store_key = "tmpinterstore:#{pinyin_words.join("+")}"
+                temp_sunion_key = "tmpsunionstore:#{words.join('+')}"
+                temp_pinyin_store_key = "tmpinterstore:#{pinyin_words.join('+')}"
                 # 找出拼音的
-                self.config.redis.sinterstore(temp_pinyin_store_key,*pinyin_words)
+                config.redis.sinterstore(temp_pinyin_store_key, *pinyin_words)
                 # 合并中文和拼音的搜索结果
-                self.config.redis.sunionstore(temp_sunion_key,*[temp_store_key,temp_pinyin_store_key])
+                config.redis.sunionstore(temp_sunion_key, *[temp_store_key, temp_pinyin_store_key])
                 # 将临时搜索设为1天后自动清除
-                self.config.redis.expire(temp_pinyin_store_key,86400)
-                self.config.redis.expire(temp_sunion_key,86400)
+                config.redis.expire(temp_pinyin_store_key, 86_400)
+                config.redis.expire(temp_sunion_key, 86_400)
               end
               temp_store_key = temp_sunion_key
             end
@@ -162,27 +166,29 @@ class Redis
         end
 
         # 根据需要的数量取出 ids
-        ids = self.config.redis.sort(temp_store_key,
-                                     limit: [0,limit],
-                                     by: self.mk_score_key(type,"*"),
-                                     order: "desc")
-        result = self.hmget(type, ids, sort_field: sort_field)
-        self.info("{#{type} : \"#{text}\"} | Time spend: #{Time.now - tm}s")
+        ids = config.redis.sort(temp_store_key,
+                                limit: [0, limit],
+                                by: mk_score_key(type, '*'),
+                                order: 'desc')
+        result = hmget(type, ids, sort_field: sort_field)
+        info("{#{type} : \"#{text}\"} | Time spend: #{Time.now - tm}s")
         result
       end
     end # end class << self
 
     protected
+
     def self.split_pinyin(text)
       # Pinyin search split as pinyin again
       _split(PinYin.sentence(text))
     end
 
     private
+
     def self._split(text)
       return [] if text.blank?
       # return chars if disabled rmmseg
-      return text.split("") if Search.config.disable_rmmseg
+      return text.split('') if Search.config.disable_rmmseg
 
       algor = RMMSeg::Algorithm.new(text)
       words = []
@@ -195,8 +201,8 @@ class Redis
     end
 
     def self.warn(msg)
-      return if not Redis::Search.config.debug
-      msg = "\e[33m[Redis::Search] #{msg}\e[0m"
+      return unless Redis::Search.config.debug
+      msg = "\e[33m[redis-search] #{msg}\e[0m"
       if defined?(Rails) == 'constant' && Rails.class == Class
         ::Rails.logger.warn(msg)
       else
@@ -205,8 +211,8 @@ class Redis
     end
 
     def self.info(msg)
-      return if not Redis::Search.config.debug
-      msg = "\e[32m[Redis::Search] #{msg}\e[0m"
+      return unless Redis::Search.config.debug
+      msg = "\e[32m[redis-search] #{msg}\e[0m"
       if defined?(Rails) == 'constant' && Rails.class == Class
         ::Rails.logger.debug(msg)
       else
@@ -233,13 +239,12 @@ class Redis
 
     def self.hmget(type, ids, options = {})
       result = []
-      sort_field = options[:sort_field] || "id"
       return result if ids.blank?
-      self.config.redis.hmget(type,*ids).each do |r|
+      config.redis.hmget(type, *ids).each do |r|
         begin
-          result << JSON.parse(r) if !r.blank?
+          result << JSON.parse(r) unless r.blank?
         rescue => e
-          self.warn("Search.query failed: #{e}")
+          warn("Search.query failed: #{e}")
         end
       end
       result

data/lib/{redis/search → redis-search}/index.rb

@@ -2,7 +2,8 @@
 class Redis
   module Search
     class Index
-      attr_accessor :type, :title, :id, :score, :aliases, :exts, :condition_fields, :prefix_index_enable
+      attr_accessor :type, :title, :id, :score, :aliases, :exts,
+                    :condition_fields, :prefix_index_enable
 
       class << self
         def redis
@@ -12,17 +13,17 @@ class Redis
         def remove(options = {})
           type = options[:type]
 
-          self.redis.pipelined do
-            self.redis.hdel(type,options[:id])
-            self.redis.del(Search.mk_score_key(type,options[:id]))
+          redis.pipelined do
+            redis.hdel(type, options[:id])
+            redis.del(Search.mk_score_key(type, options[:id]))
 
-            words = self.split_words_for_index(options[:title])
+            words = split_words_for_index(options[:title])
             words.each do |word|
-              self.redis.srem(Search.mk_sets_key(type,word), options[:id])
+              redis.srem(Search.mk_sets_key(type, word), options[:id])
             end
 
             # remove set for prefix index key
-            self.redis.srem(Search.mk_sets_key(type,options[:title]),options[:id])
+            redis.srem(Search.mk_sets_key(type, options[:title]), options[:id])
           end
         end
 
@@ -31,7 +32,7 @@ class Redis
           if Search.config.pinyin_match
             # covert Chinese to pinyin to as an index
             pinyin_full = Search.split_pinyin(title)
-            pinyin_first = pinyin_full.collect { |p| p[0] }.join("")
+            pinyin_first = pinyin_full.collect { |p| p[0] }.join('')
             words += pinyin_full
             words << pinyin_first
             pinyin_full = nil
@@ -61,38 +62,38 @@ class Redis
 
         # set attributes value from params
         options.keys.each do |k|
-          self.send("#{k}=", options[k])
+          send("#{k}=", options[k])
         end
-        @aliases << self.title
+        @aliases << title
         @aliases.uniq!
       end
 
       def save
         return if @title.blank?
 
-        self.redis.pipelined do
-          data = {title: @title, id: @id, type: @type}
-          self.exts.each do |f|
+        redis.pipelined do
+          data = { title: @title, id: @id, type: @type }
+          exts.each do |f|
             data[f[0]] = f[1]
           end
 
           # 将原始数据存入 hashes
-          res = self.redis.hset(@type, @id, data.to_json)
+          res = redis.hset(@type, @id, data.to_json)
 
           # 将目前的编号保存到条件(conditions)字段所创立的索引上面
-          self.condition_fields.each do |field|
-            self.redis.sadd(Search.mk_condition_key(@type,field,data[field.to_sym]), @id)
+          condition_fields.each do |field|
+            redis.sadd(Search.mk_condition_key(@type, field, data[field.to_sym]), @id)
           end
 
           # score for search sort
-          self.redis.set(Search.mk_score_key(@type,@id),@score)
+          redis.set(Search.mk_score_key(@type, @id), @score)
 
           # 保存 sets 索引，以分词的单词为key，用于后面搜索，里面存储 ids
-          self.aliases.each do |val|
+          aliases.each do |val|
             words = Search::Index.split_words_for_index(val)
             next if words.blank?
             words.each do |word|
-              self.redis.sadd(Search.mk_sets_key(@type,word), @id)
+              redis.sadd(Search.mk_sets_key(@type, word), @id)
             end
           end
 
@@ -102,25 +103,26 @@ class Redis
       end
 
       private
+
       def save_prefix_index
         sorted_set_key = Search.mk_complete_key(@type)
         sorted_vals = []
 
-        self.aliases.each do |val|
+        aliases.each do |val|
           words = []
           words << val.downcase
 
-          self.redis.sadd(Search.mk_sets_key(@type,val), @id)
+          redis.sadd(Search.mk_sets_key(@type, val), @id)
 
           if Search.config.pinyin_match
             pinyin_full = Search.split_pinyin(val.downcase)
-            pinyin_first = pinyin_full.collect { |p| p[0] }.join("")
-            pinyin = pinyin_full.join("")
+            pinyin_first = pinyin_full.collect { |p| p[0] }.join('')
+            pinyin = pinyin_full.join('')
 
             words << pinyin
             words << pinyin_first
 
-            self.redis.sadd(Search.mk_sets_key(@type,pinyin), @id)
+            redis.sadd(Search.mk_sets_key(@type, pinyin), @id)
 
             pinyin_full = nil
             pinyin_first = nil
@@ -136,9 +138,8 @@ class Redis
           end
         end
 
-        self.redis.zadd(sorted_set_key, sorted_vals)
+        redis.zadd(sorted_set_key, sorted_vals)
       end
-
     end # end Index
   end
 end

data/lib/{redis/search → redis-search}/tasks.rb

@@ -1,5 +1,5 @@
-# coding: utf-8
-require "redis-search"
+require 'redis-search'
+
 namespace :redis_search do
   task index: 'index:all'
 
@@ -27,18 +27,18 @@ namespace :redis_search do
     desc index_model_desc
     task model: :environment do
       if ENV['CLASS'].to_s == ''
-        puts '='*90, 'USAGE', '='*90, index_model_desc, ""
+        puts '=' * 90, 'USAGE', '=' * 90, index_model_desc, ''
         exit(1)
       end
 
       klass = eval(ENV['CLASS'].to_s)
       batch = ENV['BATCH'].to_i > 0 ? ENV['BATCH'].to_i : 1000
       tm    = Time.now
-      puts "Redis-Search index data to Redis from [#{klass.to_s}]"
+      puts "Redis-Search index data to Redis from [#{klass}]"
       count = klass.redis_search_index_batch_create(batch, true)
-      puts ""
+      puts ''
       puts "Indexed #{count} rows  |  Time spend: #{(Time.now - tm)}s"
-      puts "Rebuild Index done."
+      puts 'Rebuild Index done.'
     end
 
     desc index_all_desc
@@ -51,23 +51,23 @@ namespace :redis_search do
       Dir.glob(File.join("#{dir}/**/*.rb")).each do |path|
         model_filename = path[/#{Regexp.escape(dir.to_s)}\/([^\.]+).rb/, 1]
 
-        next if model_filename.match(/^concerns\//i) # Skip concerns/ folder
+        next if model_filename =~ /^concerns\//i # Skip concerns/ folder
 
         begin
           klass = model_filename.camelize.constantize
         rescue NameError
-          require(path) ? retry : raise(RuntimeError, "Cannot load class '#{klass}'")
+          require(path) ? retry : raise("Cannot load class '#{klass}'")
         end
       end
 
       puts "Redis-Search index data to Redis from [#{dir}]"
       Redis::Search.indexed_models.each do |klass|
-        puts "[#{klass.to_s}]"
+        puts "[#{klass}]"
         count += klass.redis_search_index_batch_create(batch, true)
-        puts ""
+        puts ''
       end
       puts "Indexed #{count} rows  |  Time spend: #{(Time.now - tm)}s"
-      puts "Rebuild Index done."
+      puts 'Rebuild Index done.'
     end
   end
 end

data/lib/redis-search/version.rb

@@ -0,0 +1,5 @@
+class Redis
+  module Search
+    VERSION = '1.0.0.beta1'
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-search
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Jason Lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-08 00:00:00.000000000 Z
+date: 2016-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-pinyin
@@ -69,12 +69,13 @@ files:
 - LICENSE
 - README.md
 - lib/redis-search.rb
-- lib/redis/search/base.rb
-- lib/redis/search/config.rb
-- lib/redis/search/finder.rb
-- lib/redis/search/index.rb
-- lib/redis/search/railtie.rb
-- lib/redis/search/tasks.rb
+- lib/redis-search/base.rb
+- lib/redis-search/config.rb
+- lib/redis-search/finder.rb
+- lib/redis-search/index.rb
+- lib/redis-search/railtie.rb
+- lib/redis-search/tasks.rb
+- lib/redis-search/version.rb
 homepage: http://github.com/huacnlee/redis-search
 licenses:
 - MIT
@@ -95,10 +96,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: High performance real-time search (Support Chinese), indexes store in Redis
   for Rails applications.
 test_files: []
-has_rdoc: