cloudsearchable 0.0.3 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 977311a4dc8f21c3619d10a0cf09641d115daaca
+  data.tar.gz: 10e9103f7e75c26adb34311c63ceda1048290ce6
+SHA512:
+  metadata.gz: 4e78c50baf6fbd8b31a84f96d513b922287481d23b5c3c724ce65405e9790dec7b7f643c04edc4477499a1cee73063d99da94fffa0ee360338769842da550ef4
+  data.tar.gz: 791a74806038012011dc9590628c5695d9519d8ea89e2713707ac67bc4f6e147ded776feb58c77cedc49e5db7bca17ee10c44a7400d170193b985b9c5522ccf3

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --format documentation
+--order random

data/LICENSE.txt

@@ -1,22 +1,14 @@
-Copyright (c) 2013 Lane LaRue
+Copyright (c) 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved. 
 
-MIT License
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+    http://www.apache.org/licenses/LICENSE-2.0
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,5 +1,7 @@
 # Cloudsearchable
-An ActiveRecord-style ORM query interface for AWS Cloud Search.
+An ActiveRecord-style ORM query interface for [Amazon CloudSearch](https://aws.amazon.com/cloudsearch/).
+
+[![Build Status](https://travis-ci.org/awslabs/cloudsearchable.svg)](https://travis-ci.org/awslabs/cloudsearchable)
 
 ## Installation
 Add to your Gemfile: gem 'cloudsearchable'. Run bundle or: gem install cloudsearchable.
@@ -15,18 +17,18 @@ class Customer
   # This is the default index. You probably only need one.
   index_in_cloudsearch do |idx|
     # Fetch the customer_id field from customer
-    literal :customer_id, :returnable => true,  :searchable => true, :source => Proc.new { customer }
+    literal :customer_id, :result_enabled => true,  :search_enabled => true, :source => Proc.new { customer }
 
     # Map the 'name' Ruby attribute to a field called 'test_name'
-    text    :test_name,   :returnable => false, :searchable => true, :source => :name
+    text    :test_name,   :result_enabled => false, :search_enabled => true, :source => :name
 
     # uint fields can be used in result ranking functions
-    uint    :helpfulness, :returnable => true,  :searchable => false do; 1234 end
+    uint    :helpfulness, :result_enabled => true,  :search_enabled => false do; 1234 end
   end
 
   # A named index.
   index_in_cloudsearch :test_index do |idx|
-    literal :id,          :searchable => true
+    literal :id,          :search_enabled => true
   end
 end
 ```
@@ -121,7 +123,7 @@ See spec tests and source code for more information.
 * [Lane LaRue](https://github.com/luxx)
 * [Philip White](https://github.com/philipmw)
 
-MIT License
+Apache 2.0 License
 
 ## Contributing
 

data/Rakefile

@@ -1,5 +1,5 @@
 require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new('spec')
+RSpec::Core::RakeTask.new
 
 # make spec test the default task
 task :default => :spec

data/cloudsearchable.gemspec

@@ -47,9 +47,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "yard"
-  spec.add_dependency 'aws-sdk'
+  spec.add_dependency 'aws-sdk', "~> 2"
 
   # testing dependencies
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", '~> 3'
   spec.add_development_dependency "activemodel"
 end

data/lib/cloudsearchable/cloud_search.rb

@@ -5,7 +5,7 @@ module CloudSearch
   API_VERSION = "2011-02-01"
 
   def self.client
-    @client ||= AWS::CloudSearch::Client.new
+    @client ||= Aws::CloudSearch::Client.new
   end
 
   def self.client=(client)
@@ -27,8 +27,7 @@ module CloudSearch
     req.body = JSON.generate sdf_list
     req["Content-Type"] = "application/json"
 
-    http = Net::HTTP.new uri.host,uri.port
-    response = http.start{|http| http.request(req)}
+    response = Net::HTTP.start(uri.host, uri.port){|http| http.request(req)}
 
     if response.is_a? Net::HTTPSuccess
       JSON.parse response.body

data/lib/cloudsearchable/version.rb

@@ -1,3 +1,3 @@
 module Cloudsearchable
-  VERSION = "0.0.3"
+  VERSION = "1.0.0"
 end

data/spec/cloudsearchable/cloud_search_spec.rb

@@ -1,3 +1,4 @@
+require 'net/http'
 require 'spec_helper'
 require 'test_classes/cloud_searchable_test_class'
 
@@ -28,17 +29,17 @@ describe CloudSearch do
   let(:success_response){ MockHTTPOK.new( {"status" => "success", "adds" => 1, "deletes" => 0}.to_json ) }
 
   it 'json parses the response' do
-    Net::HTTP.any_instance.stub(:start).and_return{success_response}
+    allow(Net::HTTP).to receive(:start).and_return(success_response)
 
     response = described_class.post_sdf endpoint, sdf_document
-    response.should eq JSON.parse success_response.body
+    expect(response).to eq JSON.parse(success_response.body)
   end
 
   it 'triggers error! on response its no not a Net::HTTPSuccess' do
     response = MockHTTPBadRequest.new
-    Net::HTTP.any_instance.stub(:start).and_return{response}
+    allow(Net::HTTP).to receive(:start).and_return(response)
 
-    response.should_receive(:error!)
+    expect(response).to receive(:error!)
     described_class.post_sdf endpoint, sdf_document
   end
 

data/spec/cloudsearchable/cloudsearchable_spec.rb

@@ -6,17 +6,17 @@ describe Cloudsearchable do
 
   it 'can describe an index that returns ids for the class type' do
     test_index = clazz.cloudsearch_index
-    test_index.should be_kind_of(Cloudsearchable::Domain)
-    test_index.fields.should have(4).items #3 explicit + 1 for the id of the object
+    expect(test_index).to be_a(Cloudsearchable::Domain)
+    expect(test_index.fields.count).to eq 4 #3 explicit + 1 for the id of the object
   end
   
   it 'has a default index' do
-    clazz.cloudsearch_index.should be_kind_of(Cloudsearchable::Domain)
-    clazz.cloudsearch_index(:test_index).should_not be(clazz.cloudsearch_index)
+    expect(clazz.cloudsearch_index).to be_a(Cloudsearchable::Domain)
+    expect(clazz.cloudsearch_index(:test_index)).to_not eq(clazz.cloudsearch_index)
   end
   
   it 'names domains consistent with CloudSearch limitations' do
-    clazz.cloudsearch_index(:test_index).name.should =~ /^[a-z][a-z0-9\-]+$/
+    expect(clazz.cloudsearch_index(:test_index).name).to be =~ /^[a-z][a-z0-9\-]+$/
   end
 
   describe 'an ordinary object' do
@@ -34,21 +34,21 @@ describe Cloudsearchable do
 
     it 'supplies the right values to the fields' do
       test_index = clazz.cloudsearch_index
-      test_index.fields[:test_class_id].value_for(inst).should be(inst.id)
-      test_index.fields[:customer_id].value_for(inst).should   be(inst.customer)
-      test_index.fields[:test_name].value_for(inst).should     be(inst.name)
-      test_index.fields[:helpfulness].value_for(inst).should   be(1234)
+      expect(test_index.fields[:test_class_id].value_for(inst)).to eq(inst.id)
+      expect(test_index.fields[:customer_id].value_for(inst)).to eq(inst.customer)
+      expect(test_index.fields[:test_name].value_for(inst)).to eq (inst.name)
+      expect(test_index.fields[:helpfulness].value_for(inst)).to eq(1234)
     end
     
     it 'reindexes when told to' do
-      clazz.cloudsearch_index(           ).should_receive(:post_record).with(inst, inst.id, inst.lock_version)
-      clazz.cloudsearch_index(:test_index).should_receive(:post_record).with(inst, inst.id, inst.lock_version)
+      expect(clazz.cloudsearch_index(           )).to receive(:post_record).with(inst, inst.id, inst.lock_version)
+      expect(clazz.cloudsearch_index(:test_index)).to receive(:post_record).with(inst, inst.id, inst.lock_version)
       inst.update_indexes
     end
     
     it 'generates a sensible addition sdf document' do
       sdf = clazz.cloudsearch_index.send :addition_sdf, inst, inst.id, inst.lock_version
-      sdf[:fields][:helpfulness].should be(1234)
+      expect(sdf[:fields][:helpfulness]).to eq(1234)
     end
   end
 
@@ -62,8 +62,8 @@ describe Cloudsearchable do
     end
 
     it 'reindexes when told to' do
-      clazz.cloudsearch_index(           ).should_receive(:delete_record).with(inst.id, inst.lock_version)
-      clazz.cloudsearch_index(:test_index).should_receive(:delete_record).with(inst.id, inst.lock_version)
+      expect(clazz.cloudsearch_index(           )).to receive(:delete_record).with(inst.id, inst.lock_version)
+      expect(clazz.cloudsearch_index(:test_index)).to receive(:delete_record).with(inst.id, inst.lock_version)
       inst.update_indexes
     end
   end

data/spec/cloudsearchable/config/option_spec.rb

@@ -16,25 +16,25 @@ describe Cloudsearchable::Config::Options do
 
   it 'sets and gets' do
     subject.foo = 5
-    subject.foo.should eq 5
+    expect(subject.foo).to eq 5
   end
 
   it 'defaults' do
-    subject.warnings.should_not be_nil
-    subject.warnings.should eq subject.settings[:warnings]
+    expect(subject.warnings).to_not be_nil
+    expect(subject.warnings).to eq subject.settings[:warnings]
   end
 
   it 'resets option' do
     subject.timezone = "EST"
-    subject.timezone.should eq "EST"
+    expect(subject.timezone).to eq "EST"
     subject.reset_timezone
-    subject.timezone.should eq "PST"
+    expect(subject.timezone).to eq "PST"
   end
 
   it 'resets all options' do
     subject.foo = 5
     subject.reset
-    subject.foo.should eq nil
+    expect(subject.foo).to be_nil
   end
 
 end

data/spec/cloudsearchable/config_spec.rb

@@ -6,10 +6,10 @@ describe Cloudsearchable::Config do
       config.domain_prefix = 'dev-llarue-'
     end
 
-    Cloudsearchable.configure.domain_prefix.should eq 'dev-llarue-'
+    expect(Cloudsearchable.configure.domain_prefix).to eq 'dev-llarue-'
   end
 
   it 'aliases configure to config' do
-    Cloudsearchable.config.domain_prefix.should eq Cloudsearchable.configure.domain_prefix
+    expect(Cloudsearchable.config.domain_prefix).to eq Cloudsearchable.configure.domain_prefix
   end
 end

data/spec/cloudsearchable/domain_spec.rb

@@ -4,7 +4,7 @@ require 'test_classes/cloud_searchable_test_class'
 describe Cloudsearchable::Domain do
   before(:each) do
     fake_client = double('client')
-    CloudSearch.stub(:client).and_return(fake_client)
+    allow(CloudSearch).to receive(:client).and_return(fake_client)
   end
   
   #
@@ -15,7 +15,7 @@ describe Cloudsearchable::Domain do
   let(:needs_rebuild_domain) do
     described_class.new('nrb-index').tap do |dom|
       resp = describe_domain_response(dom.name)
-      CloudSearch.client.stub(:describe_domains).with(:domain_names => [dom.name]).
+      allow(CloudSearch.client).to receive(:describe_domains).with(:domain_names => [dom.name]).
         and_return(
           describe_domain_response(dom.name, :required_index_documents => true),
           describe_domain_response(dom.name, :processing => true),
@@ -27,26 +27,26 @@ describe Cloudsearchable::Domain do
   # A domain name named 'my-index'
   let(:domain) do
     described_class.new('my-index').tap do |dom|
-      CloudSearch.client.stub(:describe_domains).and_return(describe_domain_response(dom.name))
-      CloudSearch.client.stub(:describe_domains).with(:domain_names => [dom.name]).and_return(describe_domain_response(dom.name))
+      allow(CloudSearch.client).to receive(:describe_domains).and_return(describe_domain_response(dom.name))
+      allow(CloudSearch.client).to receive(:describe_domains).with(:domain_names => [dom.name]).and_return(describe_domain_response(dom.name))
     end
   end
 
   let(:empty_domain) do
     described_class.new('my-index').tap do |dom|
-      CloudSearch.client.stub(:describe_domains).and_return({})
+      allow(CloudSearch.client).to receive(:describe_domains).and_return({})
     end
   end
   
   it 'can be instantiated' do
     index = domain
-    index.name.should end_with('my-index')
+    expect(index.name).to end_with('my-index')
   end
 
   it 'can haz a literal field' do
     index = domain
     index.add_field(:literary, :literal) { nil }
-    index.fields[:literary].type.should eq(:literal)
+    expect(index.fields[:literary].type).to eq(:literal)
   end
 
   it 'can be initialized with a nested class' do
@@ -56,7 +56,7 @@ describe Cloudsearchable::Domain do
       end
     end
 
-    OuterClassForCloudSearch::InnerClass.cloudsearch_prefix.should match(/^[A-Za-z0-9_-]+$/)
+    expect(OuterClassForCloudSearch::InnerClass.cloudsearch_prefix).to match(/^[A-Za-z0-9_-]+$/)
     Object.instance_eval { remove_const :OuterClassForCloudSearch }
   end
   
@@ -69,12 +69,12 @@ describe Cloudsearchable::Domain do
       end
     end
     
-    it "should generate present fields" do
-      subject.addition_sdf(object, "id", 1)[:fields][:field_with_present_value].should == 42
+    it "generates present fields" do
+      expect(subject.addition_sdf(object, "id", 1)[:fields][:field_with_present_value]).to eq 42
     end
     
-    it "should not generate nil fields" do
-      subject.addition_sdf(object, "id", 1)[:fields][:field_with_nil_value].should be_nil
+    it "does not generate nil fields" do
+      expect(subject.addition_sdf(object, "id", 1)[:fields][:field_with_nil_value]).to be_nil
     end
   end
 
@@ -88,18 +88,18 @@ describe Cloudsearchable::Domain do
   # on a class variable
   #
   it 'caches endpoints for multiple domains' do
-    domain.send(:search_endpoint).should_not eq(needs_rebuild_domain.send(:search_endpoint))
+    expect(domain.send(:search_endpoint)).to_not eq(needs_rebuild_domain.send(:search_endpoint))
   end
 
   it 'endpoint selected is based on the domain name' do
-    domain.send(:search_endpoint).should eq describe_domain_response(domain.name)[:domain_status_list][0][:search_service][:endpoint]
-    domain.send(:doc_endpoint).should    eq describe_domain_response(domain.name)[:domain_status_list][0][:doc_service][:endpoint]
+    expect(domain.send(:search_endpoint)).to eq describe_domain_response(domain.name)[:domain_status_list][0][:search_service][:endpoint]
+    expect(domain.send(:doc_endpoint)).to    eq describe_domain_response(domain.name)[:domain_status_list][0][:doc_service][:endpoint]
   end
   
   it 'sleeps, waiting for reindexing' do
-    CloudSearch.client.should_receive(:index_documents).with(:domain_name => needs_rebuild_domain.name)
-    CloudSearch.client.should_receive(:describe_domains).exactly(3).times
-    needs_rebuild_domain.apply_changes(3).should == true
+    expect(CloudSearch.client).to receive(:index_documents).with(:domain_name => needs_rebuild_domain.name)
+    expect(CloudSearch.client).to receive(:describe_domains).exactly(3).times
+    expect(needs_rebuild_domain.apply_changes(3)).to be_truthy
   end
 
   protected

data/spec/cloudsearchable/field_spec.rb

@@ -2,28 +2,32 @@ require 'spec_helper'
 require 'ostruct'
 
 describe Cloudsearchable::Field do
+  before :all do
+    ENV['AWS_REGION'] = 'us-east-1'
+  end
+
   it 'has a name' do
     field = described_class.new 'fnord', :literal
-    field.name.should eq(:fnord)
+    expect(field.name).to eq(:fnord)
   end
 
   it 'can find its value' do
     test_value = nil
     field = described_class.new('foo', :literal, :source => Proc.new { test_value })
     test_value = 123
-    field.value_for(Object.new).should eq(test_value)
+    expect(field.value_for(Object.new)).to eq(test_value)
 
     record = OpenStruct.new :a => test_value
     field2 = described_class.new('bar', :literal, :source => :a)
-    field.value_for(record).should eq(test_value)
+    expect(field.value_for(record)).to eq(test_value)
   end
 
   it 'generates a field definition' do
     domain_name = 'narnia'
     field = described_class.new('fnord', :literal, :search_enabled => true)
-    CloudSearch.client.should_receive(:define_index_field) do |call|
-      call[:domain_name].should eq(domain_name)
-      call[:index_field][:literal_options][:search_enabled].should be_true
+    expect(CloudSearch.client).to receive(:define_index_field) do |call|
+      expect(call[:domain_name]).to eq(domain_name)
+      expect(call[:index_field][:literal_options][:search_enabled]).to be_truthy
     end
     field.define_in_domain domain_name
   end

data/spec/cloudsearchable/query_chain_spec.rb

@@ -12,7 +12,7 @@ describe Cloudsearchable::Query do
 
   describe '#where' do
     it 'can build a simple search query' do
-      clazz.search.where(:customer_id, :eq, 'A1234').query.to_q[:bq].should =~ /customer_id:'A1234'/
+      expect(clazz.search.where(:customer_id, :eq, 'A1234').query.to_q[:bq]).to be =~ /customer_id:'A1234'/
     end
 
     it 'rejects field names that were not defined in the index' do
@@ -21,31 +21,31 @@ describe Cloudsearchable::Query do
 
     it 'chains' do
       query = clazz.search.where(customer_id: 'A1234').where(helpfulness: 42).query.to_q[:bq]
-      query.should =~ /customer_id:'A1234'/
-      query.should =~ /helpfulness:42/
+      expect(query).to be =~ /customer_id:'A1234'/
+      expect(query).to be =~ /helpfulness:42/
     end
 
     it 'can build a query with "not equal to" condition' do
-      query = clazz.search.where(:customer_id, :!=, 'A1234').query.to_q[:bq].should =~ /\(not customer_id:'A1234'\)/
+      expect(clazz.search.where(:customer_id, :!=, 'A1234').query.to_q[:bq]).to be =~ /\(not customer_id:'A1234'\)/
     end
 
     it 'can build a query from a hash' do
       query = clazz.search.where(customer_id: 'A1234', helpfulness: 42).query.to_q[:bq]
-      query.should =~ /customer_id:'A1234'/
-      query.should =~ /helpfulness:42/
+      expect(query).to be =~ /customer_id:'A1234'/
+      expect(query).to be =~ /helpfulness:42/
     end
 
     context 'literal data type' do
       it 'supports equality' do
-        clazz.search.where(:customer_id, :==, 'ABC').query.to_q[:bq].should eq "customer_id:'ABC'"
+        expect(clazz.search.where(:customer_id, :==, 'ABC').query.to_q[:bq]).to eq "customer_id:'ABC'"
       end
 
       it 'supports :any' do
-        clazz.search.where(:customer_id, :any, ['ABC', 'DEF']).query.to_q[:bq].should eq "(or customer_id:'ABC' customer_id:'DEF')"
+        expect(clazz.search.where(:customer_id, :any, ['ABC', 'DEF']).query.to_q[:bq]).to eq "(or customer_id:'ABC' customer_id:'DEF')"
       end
 
       it 'accepts a value as an integer' do
-        clazz.search.where(customer_id: 123).query.to_q[:bq].should =~ /customer_id:'123'/
+        expect(clazz.search.where(customer_id: 123).query.to_q[:bq]).to be =~ /customer_id:'123'/
       end
 
       it 'rejects nil value' do
@@ -55,43 +55,43 @@ describe Cloudsearchable::Query do
 
     context 'uint data type' do
       it 'supports range query' do
-        clazz.search.where(:helpfulness, :within_range, "0..#{123}").query.to_q[:bq].should =~ /helpfulness:0..123/
+        expect(clazz.search.where(:helpfulness, :within_range, "0..#{123}").query.to_q[:bq]).to be =~ /helpfulness:0..123/
       end
 
       it 'supports range query using a ruby range' do
-        clazz.search.where(:helpfulness, :within_range, 0..123).query.to_q[:bq].should =~ /helpfulness:0..123/
+        expect(clazz.search.where(:helpfulness, :within_range, 0..123).query.to_q[:bq]).to be =~ /helpfulness:0..123/
       end
 
       it 'supports equality' do
-        clazz.search.where(:helpfulness, :==, 123).query.to_q[:bq].should eq 'helpfulness:123'
+        expect(clazz.search.where(:helpfulness, :==, 123).query.to_q[:bq]).to eq 'helpfulness:123'
       end
 
       it 'supports not-equality' do
-        clazz.search.where(:helpfulness, :!=, 123).query.to_q[:bq].should eq '(not helpfulness:123)'
+        expect(clazz.search.where(:helpfulness, :!=, 123).query.to_q[:bq]).to eq '(not helpfulness:123)'
       end
 
       it 'supports greater-than' do
-        clazz.search.where(:helpfulness, :>, 123).query.to_q[:bq].should =~ /helpfulness:124../
+        expect(clazz.search.where(:helpfulness, :>, 123).query.to_q[:bq]).to be =~ /helpfulness:124../
       end
 
       it 'supports greater-than-or-equal-to' do
-        clazz.search.where(:helpfulness, :>=, 123).query.to_q[:bq].should =~ /helpfulness:123../
+        expect(clazz.search.where(:helpfulness, :>=, 123).query.to_q[:bq]).to be =~ /helpfulness:123../
       end
 
       it 'supports less-than' do
-        clazz.search.where(:helpfulness, :<, 123).query.to_q[:bq].should =~ /helpfulness:..122/
+        expect(clazz.search.where(:helpfulness, :<, 123).query.to_q[:bq]).to be =~ /helpfulness:..122/
       end
 
       it 'supports less-than-or-equal-to' do
-        clazz.search.where(:helpfulness, :<=, 123).query.to_q[:bq].should =~ /helpfulness:..123/
+        expect(clazz.search.where(:helpfulness, :<=, 123).query.to_q[:bq]).to be =~ /helpfulness:..123/
       end
 
       it 'supports :any' do
-        clazz.search.where(:helpfulness, :any, [123, 456]).query.to_q[:bq].should eq '(or helpfulness:123 helpfulness:456)'
+        expect(clazz.search.where(:helpfulness, :any, [123, 456]).query.to_q[:bq]).to eq '(or helpfulness:123 helpfulness:456)'
       end
 
       it 'accepts a value as a string' do
-        clazz.search.where(helpfulness: '123').query.to_q[:bq].should =~ /helpfulness:123/
+        expect(clazz.search.where(helpfulness: '123').query.to_q[:bq]).to be =~ /helpfulness:123/
       end
 
       [Object.new, nil, '123a'].each do |v|
@@ -112,45 +112,45 @@ describe Cloudsearchable::Query do
 
 
   it 'supports querying for any of several values of a field' do
-    clazz.search.where(:test_name, :any, %w{big small}).query.to_q[:bq].should include("(or test_name:'big' test_name:'small')")
+    expect(clazz.search.where(:test_name, :any, %w{big small}).query.to_q[:bq]).to include("(or test_name:'big' test_name:'small')")
   end
 
   it 'supports text method' do
     query = clazz.search.text('test').query.to_q[:q]
-    query.should =~ /test/
+    expect(query).to be =~ /test/
   end
 
   it 'supports chaining text and where clauses together' do
     query = clazz.search.text('test').where(:helpfulness, :==, 123).query
-    query.to_q[:q].should  =~ /test/
-    query.to_q[:bq].should =~ /helpfulness:123/
+    expect(query.to_q[:q]).to be =~ /test/
+    expect(query.to_q[:bq]).to be =~ /helpfulness:123/
   end
 
   it 'supports ordering with a rank expression' do
-    clazz.search.where(customer_id: 12345).order('-helpfulness').query.to_q[:rank].should eq '-helpfulness'
+    expect(clazz.search.where(customer_id: 12345).order('-helpfulness').query.to_q[:rank]).to eq '-helpfulness'
   end
 
   it 'supports limit' do
-    clazz.search.where(customer_id: 12345).limit(10).query.to_q[:size].should eq 10
+    expect(clazz.search.where(customer_id: 12345).limit(10).query.to_q[:size]).to eq 10
   end
 
   it 'has high default limit' do
-    clazz.search.where(customer_id: 12345).query.to_q[:size].should eq 100000
+    expect(clazz.search.where(customer_id: 12345).query.to_q[:size]).to eq 100000
   end
 
   it 'supports offset' do
-    clazz.search.where(customer_id: 12345).offset(100).query.to_q[:start].should eq 100
+    expect(clazz.search.where(customer_id: 12345).offset(100).query.to_q[:start]).to eq 100
   end
 
   context 'queries' do
     before(:each) do
-      clazz.cloudsearch_index.should_receive(:execute_query).and_return(cloudsearch_response)
+      expect(clazz.cloudsearch_index).to receive(:execute_query).and_return(cloudsearch_response)
     end
 
     context 'query warning' do
       before(:each) do
-        clazz.stub(:find).and_return([])
-        Cloudsearchable.logger.should_receive(:warn).with(/CS-InvalidFieldOrRankAliasInRankParameter/)
+        allow(clazz).to receive(:find).and_return([])
+        expect(Cloudsearchable.logger).to receive(:warn).with(/CS-InvalidFieldOrRankAliasInRankParameter/)
       end
 
       let(:query){clazz.search.where(customer_id: 12345).order("-adult")}
@@ -192,16 +192,16 @@ describe Cloudsearchable::Query do
       end
 
       it 'causes WarningInQueryResult exception' do
-        lambda{ query.to_a }.should raise_error(Cloudsearchable::WarningInQueryResult)
+        expect{ query.to_a }.to raise_error(Cloudsearchable::WarningInQueryResult)
       end
 
       it 'takes a :fatal_warnings option, and when set to false, does not raise' do
         sample_query = Cloudsearchable::QueryChain.new(double, fatal_warnings: false)
-        sample_query.instance_variable_get(:@fatal_warnings).should eq false
+        expect(sample_query.instance_variable_get(:@fatal_warnings)).to be_falsey
 
         q = query
         q.query.instance_variable_set(:@fatal_warnings, false)
-        lambda{ q.to_a }.should_not raise_error
+        expect{ q.to_a }.to_not raise_error
       end
     end
 
@@ -238,55 +238,55 @@ describe Cloudsearchable::Query do
       end
 
       it 'materializes' do
-        clazz.should_receive(:find).with(["ANINSTANCEID"]).and_return([customer_id])
+        expect(clazz).to receive(:find).with(["ANINSTANCEID"]).and_return([customer_id])
         query = clazz.search.where(customer_id: 12345)
-        query.to_a.should == [customer_id]
+        expect(query.to_a).to eq [customer_id]
       end
 
       it 'materializes db results only once' do
         expected_results = [customer_id, other_customer_id]
-        clazz.should_receive(:find).once.and_return(expected_results)
+        expect(clazz).to receive(:find).once.and_return(expected_results)
 
         query = clazz.search.where(customer_id: 12345)
         query.materialize!
         query.materialize!
       end
 
-      it 'should not materialize if only asking for found_count' do
-        clazz.should_not_receive(:find)
+      it 'does not materialize if only asking for found_count' do
+        expect(clazz).to_not receive(:find)
         clazz.search.where(customer_id: 12345).found_count
       end
 
       it 'supports each for multiple results' do
         expected_results = [customer_id, other_customer_id]
-        clazz.should_receive(:find).with(["ANINSTANCEID"]).and_return(expected_results)
+        expect(clazz).to receive(:find).with(["ANINSTANCEID"]).and_return(expected_results)
 
         results = clazz.search.where(customer_id: 12345).to_a
-        (0..results.length).each{ |i| results[i].should eq expected_results[i] }
+        (0..results.length).each{ |i| expect(results[i]).to eq expected_results[i] }
       end
 
       it 'supports each for single results' do
-        clazz.should_receive(:find).with(["ANINSTANCEID"]).and_return(customer_id)
+        expect(clazz).to receive(:find).with(["ANINSTANCEID"]).and_return(customer_id)
 
         results = clazz.search.where(customer_id: 12345).to_a
-        results.each{ |r| r.should eq customer_id }
+        results.each{ |r| expect(r).to eq customer_id }
       end
 
       it 'supports each for nil result' do
-        clazz.should_receive(:find).with(["ANINSTANCEID"]).and_return(nil)
+        expect(clazz).to receive(:find).with(["ANINSTANCEID"]).and_return(nil)
 
         results = clazz.search.where(customer_id: 12345).to_a
-        results.each{ |r| r.should_not be }
+        results.each{ |r| expect(r).to be_nil }
       end
 
       it 'uses materialized method' do
-        clazz.should_receive(:another_find).with(["ANINSTANCEID"]).and_return(customer_id)
+        expect(clazz).to receive(:another_find).with(["ANINSTANCEID"]).and_return(customer_id)
         clazz.materialize_method :another_find
         clazz.search.where(customer_id: 12345).to_a
       end
 
       it 'returns the correct found count' do
-        clazz.search.where(customer_id: 12345).found_count.should == 11
+        expect(clazz.search.where(customer_id: 12345).found_count).to eq 11
       end
     end
 
@@ -335,7 +335,7 @@ describe Cloudsearchable::Query do
       end
 
       it 'does not raise an exception' do
-        clazz.should_receive(:find).with([]).and_return(nil)
+        expect(clazz).to receive(:find).with([]).and_return(nil)
         clazz.search.where(:customer_id, :!=, 'ABCDE')
         expect { clazz.search.where(:customer_id, :!=, 'ABCDE').to_a }.to_not raise_error
       end

data/spec/spec_helper.rb

@@ -7,4 +7,5 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'cloudsearchable'
 
 RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
 end

data/spec/test_classes/cloud_searchable_test_class.rb

@@ -25,18 +25,18 @@ CloudSearchableSampleClassFactory = Proc.new do
     # This is the default index. You probably only need one.
     index_in_cloudsearch do |idx|
       # Fetch the customer_id field from customer
-      literal :customer_id, :returnable => true,  :searchable => true, :source => Proc.new { customer }
+      literal :customer_id, :result_enabled => true,  :search_enabled => true, :source => Proc.new { customer }
 
       # Map the 'name' Ruby attribute to a field called 'test_name'
-      text    :test_name,   :returnable => false, :searchable => true, :source => :name
+      text    :test_name,   :result_enabled => false, :search_enabled => true, :source => :name
 
       # uint fields can be used in result ranking functions
-      uint    :helpfulness, :returnable => true,  :searchable => false do; 1234 end
+      uint    :helpfulness, :result_enabled => true,  :search_enabled => false do; 1234 end
     end
 
     # A named index.
     index_in_cloudsearch :test_index do |idx|
-      literal :id,          :searchable => true
+      literal :id,          :search_enabled => true
     end
   end
 end

metadata

@@ -1,110 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: cloudsearchable
 version: !ruby/object:Gem::Version
-  version: 0.0.3
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Lane LaRue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-28 00:00:00.000000000 Z
+date: 2015-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: ActiveRecord-like query interface for AWS Cloud Search
@@ -114,7 +101,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .rspec
+- ".rspec"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -140,27 +127,26 @@ files:
 homepage: ''
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ActiveRecord-like query interface for AWS Cloud Search
 test_files:
 - spec/cloudsearchable/cloud_search_spec.rb
@@ -172,4 +158,3 @@ test_files:
 - spec/cloudsearchable/query_chain_spec.rb
 - spec/spec_helper.rb
 - spec/test_classes/cloud_searchable_test_class.rb
-has_rdoc: