Rfizzy 0.1.0

data/spec/searching/rfizzy_searching_search_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Rfizzy, "search search_index" do
+  let(:namespace) { SearchFactory.instance.namespace }
+  let(:tweet) { SearchFactory.instance.tweet }
+  let(:document_key_name) { SearchFactory.instance.document_key_name }
+  let(:document_id) { SearchFactory.instance.document_id }
+  let(:word_key_name) {SearchFactory.instance.word_key_name}
+  let(:word_list) { SearchFactory.instance.word_list }
+  let(:word_size) { SearchFactory.instance.word_size }
+  let(:search_words) { word_list.join(" ") }
+  let(:search_parameters) do 
+                          {:association => tweet[:association],
+                           :attribute_namespace => tweet[:attribute_namespace],
+                           :search => search_words} 
+                         end
+    
+    let(:search_keys) do 
+      search_keys_var = search_words.split(" ").map do |word|
+        "#{namespace}:word:#{tweet[:association]}:#{tweet[:attribute_namespace]}:#{word}"
+      end
+    end
+
+    let(:non_search_keys) do 
+      search_keys_var = "shit balls".split(" ").map do |word|
+        "#{namespace}:word:#{tweet[:association]}:#{tweet[:attribute_namespace]}:#{word}"
+      end
+    end
+
+    context "searching with multiple words" do
+      before(:each) do
+        @search = Rfizzy.new({:redis => R, :namespace => namespace }) 
+        @search.create_index(tweet)
+      end
+
+
+      context "should find something" do
+        it "should return the document associated" do
+          @search.should_receive(:search_keys).with(search_parameters).and_return(search_keys)
+          found_document_id = @search.search_index search_parameters
+          found_document_id.should include(document_id)
+        end
+      end
+      context "should find nothing" do
+        it "should not return the document associated" do
+          @search.should_receive(:search_keys).with(search_parameters).and_return(non_search_keys)
+          found_document_id = @search.search_index search_parameters
+          found_document_id.should_not include(document_id)
+          found_document_id.should be_empty
+        end
+        
+      end
+
+    end
+  end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'Rfizzy'
+require "redis"
+R = Redis.new
+R.select 10
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    
+  end
+
+  config.before(:each) do
+  end
+
+  config.after(:each) do
+  end
+
+  config.before(:all) do
+   R.select 10
+   R.flushdb
+
+  end
+  config.after(:all) do
+    R.select 10
+    R.flushdb
+  end
+
+end

data/spec/support/Factories/search_factories.rb

@@ -0,0 +1,37 @@
+require 'singleton'
+class SearchFactory
+  include Singleton
+  
+  def namespace
+    "short"
+  end
+  
+  def document_id
+    tweet[:document_id]
+  end
+  
+  def tweet    
+    {:attribute_namespace => :tweet,
+    :document_id => "MyPost",
+    :association => "MyUser",
+    :words => "should create the document set with proper key names filled with words"}
+  end
+  
+  def document_key_name
+    "#{namespace}:document:#{tweet[:association]}:#{tweet[:attribute_namespace]}:#{tweet[:document_id]}"
+  end
+  
+  def word_key_name
+    "#{namespace}:word:#{tweet[:association]}:#{tweet[:attribute_namespace]}:"
+  end
+  
+  def word_list
+    tweet[:words].split(" ").uniq
+  end
+  
+  def word_size
+    word_list.count
+  end
+
+end
+

data/spec/support/Factories/tagging_factories.rb

@@ -0,0 +1,37 @@
+require 'singleton'
+class TaggingFactory
+  include Singleton
+  
+  def namespace
+    "bali"
+  end
+  
+  def document_id
+    article[:document_id]
+  end
+  
+  def article    
+    {:attribute_namespace => :article,
+    :document_id => "MyPost",
+    :association => "MyUser",
+    :words => "food game sleep booze gaysex".split(" ")}
+  end
+  
+  def document_key_name
+    "#{namespace}:document:#{article[:association]}:#{article[:attribute_namespace]}:#{article[:document_id]}"
+  end
+  
+  def word_key_name
+    "#{namespace}:word:#{article[:association]}:#{article[:attribute_namespace]}:"
+  end
+  
+  def tag_list
+    article[:words].uniq
+  end
+  
+  def tag_size
+    tag_list.count
+  end
+
+end
+

data/spec/tagging/rfizzy_tagging_create_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Rfizzy, "tagging create" do
+  let(:namespace) { TaggingFactory.instance.namespace }
+  let(:article) { TaggingFactory.instance.article }
+  let(:document_key_name) { TaggingFactory.instance.document_key_name }
+  
+  let(:word_key_name) {TaggingFactory.instance.word_key_name}
+  let(:tag_list) { TaggingFactory.instance.tag_list }
+  let(:tag_size) { TaggingFactory.instance.tag_size }
+    
+  before(:each) do
+    @search = Rfizzy.new({:redis => R, :namespace => namespace }) 
+    @search.create_index(article)
+  end
+  
+context "create an index with" do      
+  context "a document that" do
+    it "should exist " do
+      R.exists(document_key_name).should be_true
+    end
+    it "should be of the type set" do
+      R.type(document_key_name).should == "set"
+    end
+    it "should contain tags" do  
+      R.smembers(document_key_name).should have(tag_size).things
+    end             
+  end
+
+  context "a set for each tag that" do
+    it "should exist" do
+      tag_list.each do |word|
+        R.exists("#{word_key_name}#{word}").should be_true
+      end
+    end
+    it "should refer to the document_id" do
+      tag_list.each do |word|
+        R.sismember("#{word_key_name}#{word}", article[:document_id])
+      end
+    end
+  end
+  end
+end  

data/spec/tagging/rfizzy_tagging_search_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Rfizzy, "tagging search_index" do
+  let(:namespace) { TaggingFactory.instance.namespace }
+  let(:article) { TaggingFactory.instance.article }
+  let(:document_key_name) { TaggingFactory.instance.document_key_name }
+  let(:document_id) { TaggingFactory.instance.document_id }
+  let(:tag_key_name) {TaggingFactory.instance.tag_key_name}
+  let(:tag_list) { TaggingFactory.instance.tag_list }
+  let(:tag_size) { TaggingFactory.instance.tag_size }
+  let(:tags) { tag_list }
+  let(:tag_parameters) do 
+                          {:association => article[:association],
+                           :attribute_namespace => article[:attribute_namespace],
+                           :search => tags} 
+                         end
+    
+    let(:tag_keys) do 
+      search_keys_var = tags.map do |word|
+        "#{namespace}:word:#{article[:association]}:#{article[:attribute_namespace]}:#{word}"
+      end
+    end
+
+    let(:non_tag_keys) do 
+      search_keys_var = "does not exist".split(" ").map do |word|
+        "#{namespace}:word:#{article[:association]}:#{article[:attribute_namespace]}:#{word}"
+      end
+    end
+
+    context "searching with multiple tags" do
+      before(:each) do
+        @search = Rfizzy.new({:redis => R, :namespace => namespace }) 
+        @search.create_index(article)
+      end
+
+
+      context "should find something" do
+        it "should return the document associated" do
+          @search.should_receive(:search_keys).with(tag_parameters).and_return(tag_keys)
+          found_document_id = @search.search_index tag_parameters
+          found_document_id.should include(document_id)
+        end
+      end
+      
+      context "should find nothing" do
+        it "should not return the document associated" do
+          @search.should_receive(:search_keys).with(tag_parameters).and_return(non_tag_keys)
+          found_document_id = @search.search_index tag_parameters
+          found_document_id.should_not include(document_id)
+          found_document_id.should be_empty
+        end
+        
+      end
+
+    end
+  end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: Rfizzy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Seivan Heidari
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-18 00:00:00.000000000 +08:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &2154016400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2154016400
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2154015920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2154015920
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2154015360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2154015360
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2154014880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2154014880
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2154014400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *2154014400
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &2154013900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2154013900
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: &2154013420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2154013420
+- !ruby/object:Gem::Dependency
+  name: syntax
+  requirement: &2154012820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2154012820
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: &2154012300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+  type: :development
+  prerelease: false
+  version_requirements: *2154012300
+description: Full text search engine with Redis. Works in all Ruby projects. Very
+  simple built, source code is < 300loc including tests. Was built because it's cheaper
+  to go with the 20mb Redis solution with redis than using PostgreSQL's full text
+  search. Also I needed background jobs and might as well use Resque for that.
+email: seivan@kth.se
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- Rfizzy.gemspec
+- VERSION
+- docs/FullTextSearch.html
+- docs/Tagging.html
+- docs/docco.css
+- docs/installation_and_setup.html
+- example_usage/FullTextSearch.rb
+- example_usage/Tagging.rb
+- example_usage/installation_and_setup.rb
+- lib/Rfizzy.rb
+- spec/.DS_Store
+- spec/initialization/rfizzy_searching_initialize_spec.rb
+- spec/searching/.DS_Store
+- spec/searching/rfizzy_searching_create_spec.rb
+- spec/searching/rfizzy_searching_destroy_spec.rb
+- spec/searching/rfizzy_searching_search_spec.rb
+- spec/spec_helper.rb
+- spec/support/.DS_Store
+- spec/support/Factories/search_factories.rb
+- spec/support/Factories/tagging_factories.rb
+- spec/tagging/rfizzy_tagging_create_spec.rb
+- spec/tagging/rfizzy_tagging_search_spec.rb
+has_rdoc: true
+homepage: http://github.com/seivan/Rfizzy
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 807837584847606337
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Full text search engine with Redis. Works in all Ruby projects
+test_files: []