briskly 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1e4055da36518f843ffa0a729ec7ab016d2ab9d
+  data.tar.gz: cd3a5302b93311c7639379865fcf20d9293e1089
+SHA512:
+  metadata.gz: 7256bcc2ba6efe086617b0b0fff4d607396ab013ff702bdb28534134d865fe8a1ab89dca3ca4e46706a2c67d42324cde543771ada1c05204c75c277165c2fe5e
+  data.tar.gz: 454ee238cf15ffdf96416f66d8d8b8acc8dfc2b2014445492882105e39840172cfe588e0be7c05c5f9d504ba29922e6825c44982f77b186e3091fff294a63ee5

data/.gitignore

@@ -0,0 +1,4 @@
+.ruby-version
+*.gem
+tmp/*
+.bundle/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+script:
+  - 'bundle exec rspec'
+

data/Gemfile

@@ -0,0 +1,3 @@
+source ENV.fetch('GEM_SOURCE', 'https://rubygems.org')
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    briskly (0.1.1)
+      fast_trie
+      i18n
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    fast_trie (0.5.0)
+    ffi (1.9.3)
+    guard (0.10.0)
+      ffi (>= 0.5.0)
+      thor (~> 0.14.6)
+    guard-rspec (0.7.3)
+      guard (>= 0.10.0)
+    i18n (0.6.9)
+    method_source (0.8.2)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-nav (0.2.3)
+      pry (~> 0.9.10)
+    rake (10.2.2)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    slop (3.5.0)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  briskly!
+  bundler (~> 1.4)
+  guard (~> 0)
+  guard-rspec (~> 0)
+  pry (~> 0)
+  pry-nav (~> 0)
+  rake (~> 10.0)
+  rspec (~> 2.4)

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Pedro Cunha
+
+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,94 @@
+briskly [![Build Status](https://travis-ci.org/pedrocunha/briskly.svg?branch=master)](https://travis-ci.org/pedrocunha/briskly) [![Code Climate](https://codeclimate.com/github/pedrocunha/briskly.png)](https://codeclimate.com/github/pedrocunha/briskly)
+=====
+
+### Usage:
+
+#### Storing:
+
+You can store a collection within a specific key. The data must be an array of hashes with a keyword and an optional data argument. Keyword can
+be an array.
+
+```ruby
+Briskly.store('cities').with([
+  { keyword: ['London', 'Londres'], data: { id: 10, name: London } },
+  { keyword: 'Berlin', data: { id: 15, name: Berlin } },
+  { keyword: 'Barcelona', data: { id: 25, name: Barcelona } }
+)]
+```
+
+- Elements are returned in the order they were inserted
+- Re-using the same key **overrides** the existing collection
+
+
+
+#### Searching:
+
+Search on collections using `#on`. The result is composed by an hash with the key(s) requested 
+and the values are instances of `Briskly::Element` class. This object responds to `#keyword` and `#data`.
+
+```ruby
+Briskly.store('cities').with([
+  { keyword: ['London', 'Londres'], data: { id: 10, name: London } },
+  { keyword: 'Berlin', data: { id: 15, name: Berlin } },
+  { keyword: 'Barcelona', data: { id: 25, name: Barcelona } }
+)]
+
+result = Briskly.on('cities').search('lon')
+
+result
+=> { 'cities' => [ #Briskly::Element ... ]
+
+result['cities'].first.keyword
+=> 'London'
+
+
+result = Briskly.on('cities').search('londres')
+result['cities'].first.keyword
+=> 'Londres'
+
+result['cities'].first.alternatives
+=> ['London']
+
+```
+
+Example with multiple collections
+
+```ruby
+Briskly.store('cities').with([
+  { keyword: 'Foo' },
+  ...
+)]
+
+Briskly.store('countries').with([
+  { keyword: 'Foobear' },
+  ...
+)]
+
+result = Briskly.on('countries', 'cities').search('foo')
+
+result
+=> { 'cities' => [ #Briskly::Element ], 'countries' => [ #Briskly::Element ] }
+```
+
+Notes:
+- Search is not case sensitive
+- Results are returned only if they match beginning of word
+
+
+
+Note on Patches/Pull Requests
+=============================
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+License
+============
+MIT licence. Copyright (c) 2013 HouseTrip Ltd.
+

data/Rakefile

@@ -0,0 +1,4 @@
+#!/usr/bin/env rake
+# encoding: UTF-8
+
+require 'bundler/gem_tasks'

data/briskly.gemspec

@@ -0,0 +1,28 @@
+require File.expand_path('../lib/briskly/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'briskly'
+  gem.authors       = 'Pedro Cunha'
+  gem.email         = 'pkunha@gmail.com'
+  gem.description   = %q{An in-memory autocomplete}
+  gem.summary       = %q{
+    An left-hand search in-memory autocomplete wrapper around
+    a C extension for fast searches
+  }
+  gem.homepage      = 'http://github.com/pedrocunha/briskly'
+  gem.license       = 'MIT'
+  gem.files         = `git ls-files`.split($\)
+  gem.require_paths = ['lib']
+  gem.version       = Briskly::VERSION
+
+  gem.add_dependency 'i18n'
+  gem.add_dependency 'fast_trie'
+
+  gem.add_development_dependency 'bundler', '~> 1.4'
+  gem.add_development_dependency 'rake', '~> 10.0'
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'pry', '~> 0'
+  gem.add_development_dependency 'pry-nav', '~> 0'
+  gem.add_development_dependency 'guard', '~> 0'
+  gem.add_development_dependency 'guard-rspec', '~> 0'
+end

data/lib/briskly.rb

@@ -0,0 +1,19 @@
+require 'briskly/version'
+
+module Briskly
+  @@storage = {}
+
+  module_function
+
+  def store(key)
+    @@storage[key] = Briskly::Store.new(key)
+  end
+
+  def on(*keys)
+    stores = [keys].flatten.map { |key| @@storage[key] || Briskly::Store.new(key) }
+    Briskly::Scope.new stores
+  end
+end
+
+require 'briskly/store'
+require 'briskly/scope'

data/lib/briskly/element.rb

@@ -0,0 +1,22 @@
+require 'briskly'
+require 'briskly/keyword'
+
+class Briskly::Element
+
+  attr_reader :data
+  attr_reader :keyword
+  attr_reader :alternatives
+
+  def initialize(keyword, data = nil, alternatives = [])
+    raise ArgumentError unless keyword
+
+    @keyword      = Briskly::Keyword.new(keyword)
+    @data         = data
+    @alternatives = alternatives.map { |alternative| Briskly::Keyword.new(alternative) }
+  end
+
+  def keyword(internal = nil)
+    internal == :internal ? @keyword : @keyword.to_s
+  end
+
+end

data/lib/briskly/keyword.rb

@@ -0,0 +1,23 @@
+require 'briskly'
+require 'i18n'
+
+class Briskly::Keyword
+
+  def initialize(keyword)
+    @keyword = keyword
+  end
+
+  def to_s
+    @keyword
+  end
+
+  def normalised
+    @_normalised ||= begin
+      I18n.transliterate(@keyword)
+        .downcase
+        .gsub(/[^a-z -]/, '')
+        .gsub(/[\s-]+/, ' ')
+    end
+  end
+
+end

data/lib/briskly/scope.rb

@@ -0,0 +1,20 @@
+require 'briskly'
+
+class Briskly::Scope
+
+  attr_reader :stores
+
+  def initialize(stores)
+    @stores = stores
+  end
+
+  def search(keyword, options = {})
+    result = {}
+
+    @stores.each do |store|
+      result[store.key] = store.search(keyword, options)
+    end
+
+    result
+  end
+end

data/lib/briskly/store.rb

@@ -0,0 +1,78 @@
+require 'briskly'
+require 'briskly/element'
+require 'trie'
+
+class Briskly::Store
+
+  attr_reader :key
+
+  def initialize(key)
+    @key      = key
+    @store    = Trie.new
+    @elements = {}
+  end
+
+  def with(values)
+    @store    = Trie.new
+    @elements = {}
+
+    values.each_with_index do |value, index|
+
+      keywords = Array.new(1) { value[:keyword] }.flatten(1)
+
+      keywords.each do |keyword|
+        alternatives = keywords - [ keyword ]
+        element      = Briskly::Element.new(keyword, value[:data], alternatives)
+        normalised   = element.keyword(:internal).normalised
+
+        # We need to make sure we keep the index
+        # and in order to avoid loops always order
+        # the array after each insertion
+        @elements[normalised] ||= []
+        @elements[normalised].push([element, index])
+                             .sort! { |a,b| a[1] <=> b[1] }
+      end
+
+    end
+
+
+    @elements.each do |key, values|
+      @store.add key, values
+    end
+  end
+
+  def search(keyword, options = {})
+    keyword = Briskly::Keyword.new(keyword)
+
+    result  = @store.children_with_values(keyword.normalised)
+                    .map(&:last)
+                    .flatten(1)
+                    .sort{ |a, b| a[1] <=> b[1] }
+
+    
+    limit   = options.fetch(:limit, result.length)
+    counter = 0
+    output  = []
+    related = []
+
+
+    # If n elements have the same index that
+    # means they are related. Trie will give
+    # the best keyword match on it's first
+    # position so we should ignore the others
+    #
+    # `related` keeps the list of related keywords
+    result.each do |element|
+      next if related[element[1]] 
+      related[element[1]] = true
+
+      output << element[0]
+
+      counter += 1
+      break if counter == limit
+    end
+    
+    output
+  end
+end
+

data/lib/briskly/version.rb

@@ -0,0 +1,6 @@
+require 'pathname'
+
+module Briskly
+  VERSION = '0.1.1'
+  GEMDIR  = Pathname.new(__FILE__).parent.parent.parent
+end

data/spec/briskly/element_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'briskly/element'
+
+describe Briskly::Element do
+
+  context 'one keyword' do
+
+    subject { described_class.new('foo', { a: 2 }) }
+
+    describe '#new' do
+      it 'accepts a keyword and data' do
+        expect(subject).to be_a described_class
+      end
+
+      it 'allows access to the keyword' do
+        expect(subject.keyword).to eq('foo')
+      end
+
+      it 'allows access to the internal keyword instance' do
+        expect(subject.keyword(:internal)).to be_a Briskly::Keyword
+      end
+
+      it 'allows access to its data' do
+        expect(subject.data).to eql(a: 2)
+      end
+    end
+
+  end
+
+  context 'alternatives' do
+    subject { described_class.new('foo', { a: 2 }, ['bar', 'bear']) }
+
+    it 'converts alternatives to keyword elements' do
+      expect(subject.alternatives.first.to_s).to eql('bar')
+    end
+  end
+
+  context 'without keywords' do
+    it 'raises ArgumentError' do
+      expect { described_class.new }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/briskly/keyword_spec.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'briskly/keyword'
+
+describe Briskly::Keyword do
+
+  describe '#to_s' do
+    subject { described_class.new('foo') }
+
+    it 'returns the keyword' do
+      expect(subject.to_s).to eq('foo')
+    end
+  end
+
+  describe '#normalised' do
+    subject { described_class.new('foo-bar-ão') }
+
+    it 'removes accents and dashes' do
+      expect(subject.normalised).to eq('foo bar ao')
+    end
+  end
+
+end

data/spec/briskly/scope_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'briskly/scope'
+
+describe Briskly::Scope do
+
+  let(:results) { [{ foo: 'bar' }] }
+  let(:store)   { double('Store', key: 'en:foo', search: results) }
+  let(:stores)  { [store] }
+
+  subject { described_class.new(stores) }
+
+  it 'initializes with stores' do
+    expect(subject).to be_a described_class
+  end
+
+  describe '#search' do
+
+    it 'returns an hash with the store key' do
+      expect(subject.search('foo').keys).to eql(['en:foo'])
+    end
+
+    it 'returns the search result' do
+      expect(subject.search('foo')['en:foo'].first).to eql({ foo: 'bar' })
+    end
+
+  end
+
+end

data/spec/briskly/store_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+require 'briskly/store'
+
+describe Briskly::Store do
+
+  describe '#new' do
+
+    it 'accepts a store name as argument' do
+      expect(described_class.new('en:foo').key).to eql('en:foo')
+    end
+
+    it 'raises exception with multiple arguments' do
+      expect{ described_class.new('en:foo', 'en:bar') }.to raise_error
+    end
+  end
+
+  describe '#with' do
+
+    subject { described_class.new('en:foo') }
+
+    it 'stores an element' do
+      expect(subject.with [{ keyword: 'foo', data: { :id => 100 } }]).to be_true
+    end
+
+    it 'data argument is optional' do
+      expect(subject.with [{ keyword: 'foo' }]).to be_true
+    end
+
+    it 'keywords argument is mandatory' do
+      expect{subject.with [{ data: 'foo' }]}.to raise_error
+    end
+
+    it 'stores an element with an array of keywords' do
+      expect{subject.with [{ keyword: ['foo', 'bar'], data: 'foo' }]}.to_not raise_error
+    end
+  end
+
+  describe '#search' do
+
+    subject { described_class.new('en:foo') }
+
+
+    context 'limiting results' do
+
+      before do
+        subject.with([
+          { keyword: 'foo'     },
+          { keyword: 'foobear' },
+          { keyword: 'foobaz'  },
+          { keyword: 'fooyolo' },
+          { keyword: 'foocorse'},
+          { keyword: 'foopizza'}
+        ])
+      end
+
+      it 'returns only five elements' do
+        result = subject.search('foo', limit: 5)
+        expect(result).to have(5).items
+      end
+
+      it 'returns all results' do
+        result = subject.search('foo')
+        expect(result).to have(6).items
+      end
+
+    end
+
+    context 'multiple results' do
+
+      before do 
+        subject.with([
+          { keyword: 'london' },
+          { keyword: 'lon'    },
+          { keyword: 'londa'  },
+          { keyword: 'lonato' },
+          { keyword: 'bear'   }
+        ])
+      end
+
+      let(:result) { subject.search('lon') }
+
+      it 'returns all matching results' do
+        expect(result.length).to eql(4)
+      end
+
+      it 'respects the order of insertion' do
+        expect(result.map(&:keyword)).to eql(['london', 'lon', 'londa', 'lonato'])
+      end
+    end
+
+    context 'attached data' do
+      it 'returns respective data' do
+        subject.with([ keyword: 'bob', data: 1 ])
+        expect(subject.search('bob').first.data).to eql(1)
+      end
+    end
+
+    context 'ignores case-sensitive' do
+      it 'ignores case on the keyword' do
+        subject.with([ keyword: 'bob' ])
+        expect(subject.search('Bob').first.keyword).to eql('bob')
+      end
+
+      it 'ignores case on the keywords' do
+        subject.with([ keyword: 'Bob' ])
+        expect(subject.search('bob').first.keyword).to eql('Bob')
+      end
+    end
+
+    context 'matching partially keywords' do
+
+      it 'returns a result if keyword length is smaller than keywords chars' do
+        subject.with([ keyword: 'bob_is_nice' ])
+        expect(subject.search('Bob').first.keyword).to eql('bob_is_nice')
+      end
+
+      it 'does not return a result if keyword length is bigger than keywords chars' do
+        subject.with([ keyword: 'bob' ])
+        expect(subject.search('BobIsNice')).to be_empty
+      end
+
+    end
+
+    context 'handling empty store' do
+      it 'returns empty array' do
+        expect(subject.search('foo')).to be_empty
+      end
+    end
+
+    context 'overriding data' do
+
+      before do
+        subject.with([ keyword: 'foo', data: 1])
+        subject.with([ keyword: 'foo', data: 2])
+      end
+
+      it 'returns only 1 element' do
+        expect(subject.search('foo')).to have(1).item
+      end
+
+      it 'returns the right data' do
+        expect(subject.search('foo').first.data).to eql(2)
+      end
+
+    end
+
+    context 'same keywords' do
+      before do
+        subject.with([ 
+          { keyword: 'foo', data: 1 },
+          { keyword: 'foo', data: 2 }
+        ])
+      end
+
+      let(:result) { subject.search('foo') }
+
+      it 'returns 2 results' do
+        expect(result).to have(2).items
+      end
+
+      it 'respects order' do
+        expect(result.map(&:data)).to eql [1, 2]
+      end
+    end
+
+    context 'multiple keywords' do
+      before do
+        subject.with([ 
+          { keyword: ['foo', 'bar'], data: 1 },
+          { keyword: 'bear', data: 2 }
+        ])
+      end
+
+      let(:result) { subject.search('bar') }
+
+      it 'returns 1 result for bar' do
+        expect(result).to have(1).item
+      end
+
+      it 'returns data equal to 1' do
+        expect(result.map(&:data)).to eql [1]
+      end
+
+    end
+
+    context 'multiple keywords with similar names' do
+      before do
+        subject.with([ 
+          { keyword: ['foo', 'foobar'] }
+        ])
+      end
+
+      let(:result) { subject.search('foo') }
+
+      it 'returns 1 result for foo' do
+        expect(result).to have(1).item
+      end
+
+      it 'returns the element with keyword foo' do
+        expect(result.map(&:keyword)).to eql ['foo']
+      end
+
+    end
+
+    context 'multiple keywords with similar names but different elements' do
+      before do
+        subject.with([ 
+          { keyword: ['foo', 'foobar'], data: 1 },
+          { keyword: ['foobar'], data: 2 }
+        ])
+      end
+
+      let(:result) { subject.search('foo') }
+
+      it 'returns 2 result for foo' do
+        expect(result).to have(2).item
+      end
+
+      it 'returns data' do
+        expect(result.map(&:data)).to eql [1, 2]
+      end
+
+    end
+
+  end
+
+end

data/spec/briskly_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'briskly'
+
+describe Briskly, 'integration' do
+
+  before do
+    described_class.store('en:foo').with([
+      { keyword: ['foo', 'bear'] },
+      { keyword: 'foobear' }
+    ])
+  end
+
+  context 'searching single collections' do
+
+    subject { described_class.on('en:foo').search('foo') }
+
+    it 'returns matching values for en:foo collection' do
+      expect(subject['en:foo'].map(&:keyword)).to eql(['foo', 'foobear'])
+    end
+
+  end
+
+  context 'alternatives' do
+
+    subject { described_class.on('en:foo').search('bear') }
+
+    it 'matches the alternative' do
+      expect(subject['en:foo'].map(&:keyword)).to eql(['bear'])
+    end
+
+  end
+
+  context 'limiting results' do
+
+    it 'returns only 1 element' do
+      subject = described_class.on('en:foo').search('foo', limit: 1)
+      expect(subject['en:foo']).to have(1).item
+    end
+
+    it 'returns all results' do
+      subject = described_class.on('en:foo').search('foo')
+      expect(subject['en:foo']).to have(2).items
+    end
+
+  end
+  
+
+  context 'searching multiple collections' do
+    before do 
+      described_class.store('en:bar').with([
+        { keyword: 'bar' },
+        { keyword: 'bar-bear' },
+        { keyword: 'foo' }
+      ])
+    end
+
+    subject { described_class.on('en:foo', 'en:bar').search('foo') }
+
+    it 'returns 2 collections' do
+      expect(subject.keys.length).to eql(2)
+    end
+
+    it 'returns matching values for en:foo collection' do
+      expect(subject['en:foo'].map(&:keyword)).to eql(['foo', 'foobear'])
+    end
+
+    it 'returns matching values for en:bar collection' do
+      expect(subject['en:bar'].map(&:keyword)).to eql(['foo'])
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'pry'
+
+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,193 @@
+--- !ruby/object:Gem::Specification
+name: briskly
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Pedro Cunha
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fast_trie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An in-memory autocomplete
+email: pkunha@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- briskly.gemspec
+- lib/briskly.rb
+- lib/briskly/briskly.bundle
+- lib/briskly/element.rb
+- lib/briskly/keyword.rb
+- lib/briskly/scope.rb
+- lib/briskly/store.rb
+- lib/briskly/version.rb
+- spec/briskly/element_spec.rb
+- spec/briskly/keyword_spec.rb
+- spec/briskly/scope_spec.rb
+- spec/briskly/store_spec.rb
+- spec/briskly_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/pedrocunha/briskly
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: An left-hand search in-memory autocomplete wrapper around a C extension for
+  fast searches
+test_files: []