sensei-rb 0.1.0

data/.gitignore

@@ -0,0 +1,53 @@
+*.rbc
+*.sassc
+.sass-cache
+capybara-*.html
+.idea
+.rspec
+/.bundle
+/vendor/bundle
+/log/*
+/tmp
+.DS_Store
+.vagrant
+.tm_properties
+/vendor/qbes
+.vagrant
+.tm_properties
+
+/db/*.sqlite3
+/public/system/*
+/coverage/
+/spec/tmp/*
+**.orig
+rerun.txt
+pickle-email-*.html
+*.js.js
+app/assets/stylesheets/application.css
+*.swp
+*.iml
+.pt
+*.rdb
+Vagrantfile
+db/structure.sql
+
+# JetBrains IDE files
+.idea
+*.iml
+*.iws
+piston.ipr
+
+# Zeus
+custom_plan.rb
+zeus.json
+
+# Ignore simplecov output
+coverage
+
+# Ignore ci_reporter output
+spec/reports
+
+# Ignore local config
+.ruby-version
+
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+    
+before_install:
+  - gem install bundler
+
+rvm:
+  - 1.9.3
+  - ruby-head
+  - jruby-19mode
+  - rbx-19mode
+
+gemfile:
+  - Gemfile
+
+notifications:
+  email:
+    - ci-admins@identified.com

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Identified
+
+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:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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

@@ -0,0 +1,11 @@
+sensei-rb
+=========
+
+[![Build Status](https://secure.travis-ci.org/Identified/sensei-rb.png)](http://travis-ci.org/Identified/sensei-rb?branch=master)
+
+Install
+-------
+Include the gem in your Gemfile:
+``` ruby
+gem 'sensei-rb', '~> 0.1.0'
+```

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+task default: :spec

data/lib/sensei/client.rb

@@ -0,0 +1,243 @@
+# require 'erb'
+require 'yaml'
+
+module Sensei
+  class HTTPBadResponse < StandardError
+  end
+
+  class Client
+    cattr_accessor :sensei_hosts, :sensei_port, :http_kafka_port, :uid_key, :http_kafka_hosts, :fake_update
+    attr_accessor :search_timeout
+
+    DATA_TRANSACTION_KEY = "sensei_client_data_transaction"
+    TEST_TRANSACTION_KEY = "sensei_client_test_transaction"
+
+    def self.configure(path = "config/sensei.yml")
+      if File.exists? path
+        config = YAML.load(ERB.new(File.read(path)).result)
+
+        # Limit config to specific environment if Rails is defined
+        defined? ::Rails and
+          config = config[::Rails.env]
+
+        self.sensei_hosts      = config['sensei_hosts']
+        self.sensei_port       = config['sensei_port']
+        self.http_kafka_port   = config['http_kafka_port']
+        self.uid_key           = config['uid_key']
+        self.http_kafka_hosts  = config['http_kafka_hosts']
+        self.fake_update       = config['fake_update'] || false
+      end
+
+      yield self if block_given?
+    end
+
+
+    def self.current_data_transaction
+      Thread.current[DATA_TRANSACTION_KEY].last
+    end
+
+    def self.current_test_transaction
+      Thread.current[TEST_TRANSACTION_KEY].last
+    end
+
+    def self.begin_transaction key
+      Thread.current[key] ||= []
+      Thread.current[key] << []
+    end
+
+    def self.in_sensei_transaction? key
+      Thread.current[key] ||= []
+      Thread.current[key].count > 0
+    end
+
+    # This does a "data transaction," in which any update events will get
+    # buffered until the block is finished, after which everything gets sent.
+    def self.transaction &block
+      begin
+        begin_transaction DATA_TRANSACTION_KEY
+        block.call
+        kafka_commit(current_data_transaction)
+      ensure
+        Thread.current[DATA_TRANSACTION_KEY].pop
+      end
+    end
+
+    def self.test_transaction &block
+      begin
+        begin_transaction TEST_TRANSACTION_KEY
+        block.call
+      ensure
+        kafka_rollback(current_test_transaction)
+        Thread.current[TEST_TRANSACTION_KEY].pop
+      end
+    end
+
+    # Undo all of the data events that just occurred.
+    # This is only really useful during tests.  Also,
+    # it's only capable of rolling back insertions.
+    def self.kafka_rollback(data_events)
+      to_delete = data_events.select{|x| x[uid_key]}.map{|x| {:_type => '_delete', :_uid => x[uid_key]}}
+      kafka_commit to_delete
+    end
+
+    def self.in_data_transaction?
+      self.in_sensei_transaction? DATA_TRANSACTION_KEY
+    end
+
+    def self.in_test_transaction?
+      self.in_sensei_transaction? TEST_TRANSACTION_KEY
+    end
+
+    def self.sensei_url
+      raise unless sensei_hosts
+      "http://#{sensei_hosts.sample}:#{sensei_port || 8080}/sensei"
+    end
+
+    def initialize optargs={}
+      @query = optargs[:query].try(:to_sensei)
+      @facets = (optargs[:facets] || {})
+      @selections = (optargs[:selections] || {})
+      @other_options = optargs.dup.keep_if {|k,v| ![:query, :facets, :selections].member?(k)}
+    end
+
+    def self.kafka_send items
+      if in_data_transaction?
+        current_data_transaction << items
+      else
+        kafka_commit items
+      end
+
+      if in_test_transaction?
+        Thread.current[TEST_TRANSACTION_KEY].last << items
+      end
+      true
+    end
+
+    def self.kafka_commit items
+      if !fake_update
+        req = Curl::Easy.new("http://#{http_kafka_hosts.sample}:#{http_kafka_port}/")
+        req.http_post(items.map(&:to_json).join("\n"))
+        raise Sensei::HTTPBadResponse, "Kafka url=#{req.url}, response_code=#{req.response_code}, response_body=#{req.body_str}" if req.response_code != 200
+        req.body_str
+      end
+    end
+
+    def self.delete uids
+      kafka_send(uids.map do |uid|
+                   {:type => 'delete', :uid => uid.to_s}
+                 end)
+    end
+
+    def self.update(documents)
+      kafka_send documents
+    end
+
+    DEFAULT_FACET_OPTIONS = {:max => 6, :minCount => 1}
+
+    # Add a desired facet to the results
+    def facet(field, options={})
+      @facets[field] = DEFAULT_FACET_OPTIONS.merge(options)
+      self
+    end
+
+    def relevance(r)
+      @relevance = r
+      self
+    end
+
+    def query(q)
+      @query=q.to_sensei
+      self
+    end
+
+    def all(q)
+      @query ? (@query &= q.to_sensei) : (@query = q.to_sensei)
+      self
+    end
+
+    def any(q)
+      @query ? (@query |= q.to_sensei) : (@query = q.to_sensei)
+      self
+    end
+
+    def not(q)
+      @query ? (@query &= q.to_sensei.must_not) : (@query = q.to_sensei.must_not)
+      self
+    end
+
+    # Do facet selection
+    def selection(fields = {})
+      @selections.merge!(fields)
+      self
+    end
+
+    def options(opts = {})
+      @other_options.merge!(opts)
+      self
+    end
+
+    def to_h
+      out = {}
+      if @query
+        out[:query] = @query.to_h
+        if @relevance
+          out[:query] = Sensei::BoolQuery.new(:operands => [@query], :operation => :must).to_h
+          out[:query][:bool][:relevance] = @relevance
+        end
+      end
+
+      (out[:facets] = @facets) if @facets.count > 0
+      selections = @selections.map { |field, terms| {:terms => {field => {values: terms, :operator => "or"}}} }
+      (out[:selections] = selections) if selections.count > 0
+      out.merge!(@other_options)
+      out
+    end
+
+    def self.q h
+      h.to_sensei
+    end
+
+    def self.construct options={}, &block
+      out = self.new(options)
+      search_query = class_eval(&block)
+      out.query(search_query)
+    end
+
+    def search
+      req = Curl::Easy.new(self.class.sensei_url)
+      req.timeout = self.search_timeout
+      req.http_post(self.to_h.to_json)
+      raise Sensei::HTTPBadResponse, "url=#{req.url}, response_code=#{req.response_code}, response_body=#{req.body_str}" if req.response_code != 200
+      JSON.parse(req.body_str)
+    end
+
+    # This method performs several separate queries with different
+    # selection settings as necessary.  This is needed to perform
+    # the common interaction pattern for faceted search, in which
+    # it is desired that selections from other facets affect a
+    # particular facet's counts, but a facet's own selections do
+    # facet do not affect its own counts.
+    def select_search
+      all_selection_results = search
+      facet_requests.map(&:search).each do |result|
+        field, counts = result['facets'].first
+        all_selection_results['facets'][field] += counts
+      end
+
+      all_selection_results['facets'] = Hash[*all_selection_results['facets'].map do |k,v|
+                                               [k, v.uniq_by{|x| x['value']}]
+                                             end.flatten(1)]
+      all_selection_results
+    end
+
+    # This method builds the requests necessary to perform the `select_search' method.
+    def facet_requests
+      @selections.map do |field, values|
+        Sensei::Client.new(:query => @query,
+                           :facets => @facets.dup.keep_if {|name, opts| name==field},
+                           :selections => @selections.dup.keep_if {|name, opts| name != field},
+                           :size => 0)
+      end
+    end
+  end
+end

data/lib/sensei/query.rb

@@ -0,0 +1,230 @@
+# Query DSL for SenseiDB
+# The basic grammar is as follows:
+
+# query :=   q(field => value)  (produces a term query)
+#          / q(field => [values ...])  (produces a boolean query composed of
+#                                      the OR of {field => value} queries for each value)
+#          / q(field => (start..end)) (produces a range query on field between start and end)
+#          / query & query  (ANDs two subqueries together)
+#          / query | query  (ORs two subqueries together)
+#
+# value := something that should probably be a string, but might work if it isn't
+#
+# Note: use of the `q' operator must be performed within the context of
+# a Sensei::Query.construct block, i.e.
+
+#      Sensei::Query.construct do
+#        (q(:foo => (15..30)) & q(:bar => '1')).boost!(10) | q(:baz => 'wiz')
+#      end
+
+# If you're not in a construct block, you can still do Sensei::Query.q(...).
+
+module Sensei
+  module Operators
+    def &(x)
+      return self if self == x
+      return self if x.is_a? EmptyQuery
+      BoolQuery.new(:operands => [self.to_sensei, x.to_sensei], :operation => :must)
+    end
+
+    def |(x)
+      return self if self == x
+      return self if x.is_a? EmptyQuery
+      BoolQuery.new(:operands => [self.to_sensei, x.to_sensei], :operation => :should)
+    end
+
+    def ~
+      self.must_not
+    end
+
+    def *(x)
+      self.boost!(x)
+    end
+
+    def must_not
+      BoolQuery.new(:operands => [self.to_sensei], :operation => :must_not)
+    end
+
+    def boost! amt
+      self.to_sensei.tap do |x| x.options[:boost] = amt end
+    end
+  end
+
+  class Query
+    attr_accessor :options
+    cattr_accessor :result_klass
+
+    include Operators
+
+    def initialize(opts={})
+      @options = opts
+    end
+
+    def get_boost
+      options[:boost] ? {:boost => options[:boost]} : {}
+    end
+
+    def to_sensei
+      self
+    end
+
+    def self.construct &block
+      class_eval(&block)
+    end
+
+    def self.q(h)
+      h.to_sensei
+    end
+
+    def not_query?
+      self.is_a?(Sensei::BoolQuery) && options[:operation] == :must_not
+    end
+
+    def run(options = {})
+      results = Sensei::Client.new(options.merge(:query => self)).search
+      if @@result_klass
+        @@result_klass.new(results)
+      else
+        results
+      end
+    end
+  end
+
+  class BoolQuery < Query
+    def operands
+      options[:operands]
+    end
+
+    def to_h
+      if self.not_query?
+        raise Exception, "Error: independent boolean NOT query not allowed."
+      end
+
+      not_queries, non_not_queries = operands.partition(&:not_query?)
+      not_queries = not_queries.map{|x| x.operands.map(&:to_h)}.flatten
+
+      non_not_queries = non_not_queries.reject{|x| x.is_a? AllQuery} if options[:operation] == :must
+
+      subqueries = non_not_queries.map(&:to_h)
+      mergeable, nonmergeable = subqueries.partition do |x|
+        isbool = x[:bool]
+        sameop = isbool && isbool[options[:operation]]
+        boosted = isbool && isbool[:boost]
+        isbool && sameop && (boosted.nil? || boosted == options[:boost])
+      end
+      merged_queries = mergeable.map{|x| x[:bool][options[:operation]]}.flatten(1)
+      merged_nots = mergeable.map{|x| x[:bool][:must_not] || []}.flatten(1)
+
+      all_nots = merged_nots + not_queries
+      not_clause = (all_nots.count > 0 ? {:must_not => all_nots} : {})
+
+      {:bool => {
+          options[:operation] => nonmergeable + merged_queries
+        }.merge(get_boost).merge(not_clause)
+      }
+    end
+  end
+
+  class TermQuery < Query
+    def to_h
+      {:term => {options[:field] => {:value => options[:value].to_s}.merge(get_boost)}}
+    end
+  end
+
+  class TermsQuery < Query
+    def to_h
+      {:terms => {options[:field] => {:values => options[:values].map(&:to_s)}.merge(get_boost)}}
+    end
+  end
+
+  class RangeQuery < Query
+    def to_h
+      {:range => {
+          options[:field] => {
+            :from => options[:from],
+            :to => options[:to],
+            :_type => options[:type] || ((options[:from].is_a?(Float) || options[:to].is_a?(Float)) ? "double" : "float")
+          }.merge(get_boost).merge(options[:type] == :date ? {:_date_format => options[:date_format] || 'YYYY-MM-DD'} : {})
+        },
+      }
+    end
+  end
+
+  class EmptyQuery < Query
+
+    def &(x)
+      x
+    end
+
+    def |(x)
+      x
+    end
+
+    def ~
+      raise 'Should not call on an empty query'
+    end
+
+    def *(x)
+      raise 'Should not call on an empty query'
+    end
+
+    def must_not
+      raise 'Should not call on an empty query'
+    end
+
+    def boost! amt
+      raise 'Should not call on an empty query'
+    end
+
+    def to_h
+      {}
+    end
+  end
+
+  class AllQuery < Query
+    def to_h
+      {:match_all => {}.merge(get_boost)}
+    end
+  end
+
+  class UIDQuery < Query
+    def initialize(uids)
+      uids = [uids] unless uids.is_a?(Array)
+      @uids = uids
+    end
+    def to_h
+      {:ids => {:values => @uids}}
+    end
+  end
+end
+
+class Hash
+  def to_sensei
+    field, value = self.first
+    if [String, Fixnum, Float, Bignum].member?(value.class)
+      Sensei::TermQuery.new(:field => field, :value => value)
+    else
+      value.to_sensei(field)
+    end
+  end
+end
+
+class Range
+  def to_sensei(field)
+    Sensei::RangeQuery.new(:from => self.begin, :to => self.end, :field => field)
+  end
+end
+
+class Array
+  def to_sensei(field, op=:should)
+    if op == :should
+      if self.length == 1
+        Sensei::TermQuery.new(:field => field, :value => self.first)
+      else
+        Sensei::TermsQuery.new(:field => field, :values => self)
+      end
+    else
+      Sensei::BoolQuery.new(:operation => op, :operands => self.map{|value| {field => value}.to_sensei})
+    end
+  end
+end

data/lib/sensei/version.rb

@@ -0,0 +1,3 @@
+module Sensei
+  VERSION = "0.1.0"
+end

data/lib/sensei-rb.rb

@@ -0,0 +1,2 @@
+require 'sensei/query'
+require 'sensei/client'

data/sensei-rb.gemspec

@@ -0,0 +1,23 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require "sensei/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'sensei-rb'
+  s.version     = '0.1.0'
+  s.date        = '2012-04-20'
+  s.summary     = "Ruby client for SenseiDB"
+  s.description = "A ruby client for SenseiDB."
+  s.authors     = ["Identified"]
+  s.email       = 'engineers@identified.com'
+  s.homepage = 'https://github.com/Identified/sensei-rb'
+  s.license  = 'MIT'
+
+  s.add_dependency('activesupport')
+  s.add_development_dependency('bundler')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec', '~> 2.13.0')
+
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+end

data/spec/fixtures/sensei-rails.yml

@@ -0,0 +1,10 @@
+common_ports: &common_ports
+  sensei_port: 8080
+  http_kafka_port: 9876
+
+some_rails_env:
+  <<: *common_ports
+  sensei_hosts:
+    - localhost
+  http_kafka_hosts:
+    - localhost

data/spec/fixtures/sensei-rails.yml.erb

@@ -0,0 +1,10 @@
+common_ports: &common_ports
+  sensei_port: <%= 8080 %>
+  http_kafka_port: <%= 9876 %>
+
+some_rails_env:
+  <<: *common_ports
+  sensei_hosts:
+    - <%= "localhost" %>
+  http_kafka_hosts:
+    - <%= "localhost" %>

data/spec/fixtures/sensei.yml

@@ -0,0 +1,6 @@
+sensei_port: 8080
+http_kafka_port: 9876
+sensei_hosts:
+  - localhost
+http_kafka_hosts:
+  - localhost

data/spec/fixtures/sensei.yml.erb

@@ -0,0 +1,6 @@
+sensei_port: <%= 8080 %>
+http_kafka_port: <%= 9876 %>
+sensei_hosts:
+  - <%= "localhost" %>
+http_kafka_hosts:
+  - <%= "localhost" %>

data/spec/sensei/client_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe Sensei::Client do
+  shared_examples "a configured client" do
+    subject { Sensei::Client }
+
+    describe "::configure" do
+      it "sets the configs from the yaml file into its class variables" do
+        subject.configure(file_path)
+        expect(Sensei::Client.sensei_hosts).to match_array(["localhost"])
+        expect(Sensei::Client.sensei_port).to eq(8080)
+        expect(Sensei::Client.http_kafka_port).to eq(9876)
+        expect(Sensei::Client.http_kafka_hosts).to match_array(["localhost"])
+      end
+    end
+  end
+
+  context "without RAILS_ENV" do
+    context "without ERB" do
+      it_behaves_like "a configured client" do
+        let(:file_path) { File.dirname(__FILE__) + '/../fixtures/sensei.yml' }
+      end
+    end
+
+    context "with ERB" do
+      it_behaves_like "a configured client" do
+        let(:file_path) {  File.dirname(__FILE__) + '/../fixtures/sensei.yml.erb' }
+      end
+    end
+
+  end
+
+ context "with RAILS_ENV" do
+   before { Rails = Struct.new(:env).new("some_rails_env") }
+   after { Object.send(:remove_const, :Rails) }
+
+   context "without ERB" do
+     it_behaves_like "a configured client" do
+       let(:file_path) { File.dirname(__FILE__) + '/../fixtures/sensei-rails.yml' }
+     end
+   end
+
+   context "with ERB" do
+     it_behaves_like "a configured client" do
+       let(:file_path) {  File.dirname(__FILE__) + '/../fixtures/sensei-rails.yml.erb' }
+     end
+   end
+ end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require 'active_support/all'
+require 'sensei/client'
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: sensei-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Identified
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: 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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: A ruby client for SenseiDB.
+email: engineers@identified.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/sensei-rb.rb
+- lib/sensei/client.rb
+- lib/sensei/query.rb
+- lib/sensei/version.rb
+- sensei-rb.gemspec
+- spec/fixtures/sensei-rails.yml
+- spec/fixtures/sensei-rails.yml.erb
+- spec/fixtures/sensei.yml
+- spec/fixtures/sensei.yml.erb
+- spec/sensei/client_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Identified/sensei-rb
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ruby client for SenseiDB
+test_files:
+- spec/fixtures/sensei-rails.yml
+- spec/fixtures/sensei-rails.yml.erb
+- spec/fixtures/sensei.yml
+- spec/fixtures/sensei.yml.erb
+- spec/sensei/client_spec.rb
+- spec/spec_helper.rb