flocks 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9670cef0827448591a9929ae6b1e29e9a10907d8
+  data.tar.gz: f44b3a80e9ba291f79472cb32f207de3e3fd2fda
+SHA512:
+  metadata.gz: b1bee72695582429793848aa7ae8694c6f05e5f8710ae2cf14e9f79baf0ecf62afc395e4fc1c316676f57a393f70a0dbc74413ddc7167480e630b3c9b56c460d
+  data.tar.gz: ac2b6281eb80f9853680c5312358035be1af26e6794aafa4f25695470a7ccd1d69e9fe4722ca45f5ab7e6c8b1963fe1e374771f40e5aa1cff145744132cc768b

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in flocks.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2014, Byliner, Inc
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name of the DUO Interactive, LLC nor the names of its contributors
+  may be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,142 @@
+# Flocks
+
+Flocks is a lightweight searchable social graph that tracks a user's followers, who they are following, and who they have blocked.
+
+Flocks uses [Redis](http://redis.io/documentation) to store the relationships.
+
+User lists are sorted alphabetically and can be searched!
+
+Flocks uses usernames (or any unique string identifier) when following in order to sort the following/followers lists.
+By requiring usernames when establishing relationships, Flocks becomes searchable.
+Flocks will return all user ids with user_ids matching the query string.
+Flocks search capabilities can be used to autocomplete text fields with usernames in a user's social graph.
+
+For example, if a user is following: 'Adam', 'Aaron', 'Addison', and 'John'
+
+Searching for 'a' will return the ids associated with Adam, Aaron, and Addison
+Searching for 'ad' will return the id associated with Adam
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'flocks'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install flocks
+
+## Usage
+
+Configure flocks:
+
+```ruby
+Flocks.configure do |configuration|
+  configuration.redis = Redis.new
+  configuration.namespace = 'flocks'
+  configuration.following_key = 'following'
+  configuration.followers_key = 'followers'
+  configuration.blocked_key = 'blocked'
+  configuration.page_size = 25
+end
+```
+
+Use flocks:
+
+```ruby
+require 'flocks'
+=> true
+
+Flocks.configure do |configuration|
+  configuration.redis = Redis.new
+  configuration.namespace = 'flocks'
+  configuration.following_key = 'following'
+  configuration.followers_key = 'followers'
+  configuration.blocked_key = 'blocked'
+  configuration.page_size = 25
+end
+
+Flocks.new(1, 'username').follow(11, 'other_username')
+=> true
+
+Flocks.new(1, 'username').following?(11)
+=> true
+
+Flocks.new(11, 'other_username').following?(1)
+=> false
+
+Flocks.new(11, 'other_username').follow(1, 'username')
+=> true
+
+Flocks.new(11, 'other_username').following?(1)
+=> true
+
+Flocks.new(1, 'username').following_count
+=> 1
+
+Flocks.new(1, 'username').followers_count
+=> 1
+
+Flocks.new(11, 'other_username').unfollow(1)
+=> true
+
+Flocks.new(11, 'other_username').following_count
+=> 0
+
+Flocks.new(1, 'username').following_count
+=> 1
+
+Flocks.new(1, 'username').following
+=> ["11"]
+
+Flocks.new(1, 'username').block(11)
+=> true
+
+Flocks.new(11, 'username').following?(1)
+=> false
+
+Flocks.new(1, 'username').blocked?(11)
+=> true
+
+Flocks.new(11, 'other_username').follow(1)
+=> nil
+
+Flocks.new(1, 'username').unblock(11)
+=> true
+
+Flocks.new(1, 'username').blocked?(11)
+=> false
+
+Flocks.new(11, 'other_username').follow(1)
+=> true
+
+Flocks.new(1, 'username').follow(11)
+=> true
+
+Flocks.new(1, 'username').search_following('other')
+=> ["11"]
+
+Flocks.new(1, 'username').search_followers('other')
+=> ["11"]
+
+Flocks.new(1, 'username').search_graph('other')
+=> ["11"]
+
+```
+
+## Thanks
+
+Many thanks to [amico](https://github.com/agoragames/amico) creator [agoragames](https://github.com/agoragames).  A lot of the code used was inspired by the [amico gem](https://github.com/agoragames/amico).
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/flocks/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'bundler/gem_tasks'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :default => :test

data/flocks.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flocks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "flocks"
+  spec.version       = Flocks::VERSION
+  spec.authors       = ["Adam Ryan"]
+  spec.email         = ["adam.g.ryan@gmail.com"]
+  spec.summary       = %q{Single node social relationships using redis.}
+  spec.description   = %q{Single node social relationships using redis.}
+  spec.homepage      = "https://github.com/byliner/flocks"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "redis"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/lib/flocks.rb

@@ -0,0 +1,23 @@
+require 'redis'
+require 'flocks/configuration'
+require 'flocks/ordering'
+require 'flocks/relationships'
+require 'flocks/search'
+require 'flocks/version'
+
+module Flocks
+  class << self
+    include Configuration
+    include Ordering
+    include Search
+    include Relationships
+
+    attr_accessor :user_id, :username_score
+
+    def new(user_id, username = nil)
+      self.user_id = user_id
+      self.username_score = rank_username(username)
+      self
+    end
+  end
+end

data/lib/flocks/configuration.rb

@@ -0,0 +1,113 @@
+module Flocks
+  # Configuration settings for Flocks.
+  module Configuration
+    # Redis instance.
+    attr_accessor :redis
+
+    # Flocks namespace for Redis.
+    attr_writer :namespace
+
+    # Key used in Redis for tracking who an individual is following.
+    attr_writer :following_key
+
+    # Key used in Redis for tracking the followers of an individual.
+    attr_writer :followers_key
+
+    # Key used in Redis for tracking who an individual blocks.
+    attr_writer :blocked_key
+
+    # Key used in Redis for tracking who has blocked an individual.
+    attr_writer :blocked_by_key
+
+    # Key used in Redis for tracking who has reciprocated a follow for an individual.
+    attr_writer :reciprocated_key
+
+    # Key used in Redis for tracking pending follow relationships for an individual.
+    attr_writer :pending_key
+
+    # Key used in Redis for tracking who an individual is awaiting approval from.
+    attr_writer :pending_with_key
+
+    # Key used to indicate whether or not a follow should be pending or not.
+    attr_writer :pending_follow
+
+    # Page size to be used when paging through the various types of relationships.
+    attr_writer :page_size
+
+    # Set the percision for relationship sorting granularity
+    attr_writer :string_score_percision
+
+    # Yield self to be able to configure Flocks with block-style configuration.
+    #
+    # Example:
+    #
+    #   Flocks.configure do |configuration|
+    #     configuration.redis = Redis.new
+    #     configuration.namespace = 'flocks'
+    #     configuration.following_key = 'following'
+    #     configuration.followers_key = 'followers'
+    #     configuration.blocked_key = 'blocked'
+    #     configuration.blocked_by_key = 'blocked_by'
+    #     configuration.page_size = 25
+    #   end
+    def configure
+      yield self
+    end
+
+    # Flocks namespace for Redis.
+    #
+    # @return the Flocks namespace or the default of 'flocks' if not set.
+    def namespace
+      @namespace ||= 'flocks'
+    end
+
+    # Key used in Redis for tracking who an individual is following.
+    #
+    # @return the key used in Redis for tracking who an individual is following or the default of 'following' if not set.
+    def following_key
+      @following_key ||= 'following'
+    end
+
+    # Key used in Redis for tracking the followers of an individual.
+    #
+    # @return the key used in Redis for tracking the followers of an individual or the default of 'followers' if not set.
+    def followers_key
+      @followers_key ||= 'followers'
+    end
+
+    # Key used in Redis for tracking who an individual blocks.
+    #
+    # @return the key used in Redis for tracking who an individual blocks or the default of 'blocked' if not set.
+    def blocked_key
+      @blocked_key ||= 'blocked'
+    end
+
+    # Key used in Redis for tracking who has blocked an individual.
+    #
+    # @return the key used in Redis for tracking who has blocked an individual or the default of 'blocked_by' if not set.
+    def blocked_by_key
+      @blocked_by_key ||= 'blocked_by'
+    end
+
+    # Key used in Redis for tracking who has reciprocated a follow for an individual.
+    #
+    # @return the key used in Redis for tracking who has reciprocated a follow for an individual or the default of 'reciprocated' if not set.
+    def reciprocated_key
+      @reciprocated_key ||= 'reciprocated'
+    end
+
+    # Page size to be used when paging through the various types of relationships.
+    #
+    # @return the page size to be used when paging through the various types of relationships or the default of 25 if not set.
+    def page_size
+      @page_size ||= 25
+    end
+
+    # Number of characters to be used when scoring a username for indexing in redis
+    #
+    # @return the scoring percision
+    def string_score_percision
+      @string_score_percision ||= 5
+    end
+  end
+end

data/lib/flocks/ordering.rb

@@ -0,0 +1,33 @@
+module Flocks
+  module Ordering
+    def rank_username(username)
+      # Selects the number of characters to be evaluated for sorting
+      percision_index = string_score_percision - 1
+
+      # Base score
+      score = 0
+
+      # Get the first 5 characters in an array
+      characters = username.to_s.downcase[0..percision_index].split('')
+
+      # If the username is short, tack on the lowest ascii value
+      characters << '0' until characters.size == string_score_percision
+
+      # Reverse them for easy multiplication scoring
+      characters.reverse.each_with_index do |char, i|
+
+        # Use the mutiplier, increase magnitude for weighting first letters more
+        # multiplier = (character_multiplier[0..(i + 1)].to_i)
+
+        multiplier = 10 ** i
+        # Square the multiplier to avoid large ascii values from thwrowing off calculations
+        char_score = "#{char}"[0].ord * multiplier * multiplier
+
+        # Aggregate the swcore
+        score += char_score
+      end
+
+      score
+    end
+  end
+end

data/lib/flocks/relationships.rb

@@ -0,0 +1,87 @@
+module Flocks
+  module Relationships
+
+    def relationship_following_key
+      "#{following_key}/#{user_id}"
+    end
+
+    def relationship_followers_key(id = user_id)
+      "#{followers_key}/#{id}"
+    end
+
+    def relationship_blocked_key
+      "#{blocked_key}/#{user_id}"
+    end
+
+    def follow(other_user_id, other_username)
+      return if (user_id == other_user_id) || (blocked? other_user_id)
+
+      other_username_score = rank_username(other_username)
+      redis.zadd relationship_following_key, other_username_score, other_user_id
+      redis.zadd relationship_followers_key(other_user_id), username_score, user_id
+    end
+
+    def unfollow(other_user_id)
+      redis.zrem relationship_following_key, other_user_id
+      redis.zrem relationship_followers_key(other_user_id), user_id
+    end
+
+    def following(page = 0, limit = 0)
+      # Without arguments returns the full set
+      start, stop = bounds(page, limit)
+      redis.zrange relationship_following_key, start, stop
+    end
+
+    def followers(page = 0, limit= 0)
+      start, stop = bounds(page, limit)
+      redis.zrange relationship_followers_key(user_id), start, stop
+    end
+
+    def following?(other_user_id)
+      following.include? other_user_id.to_s
+    end
+
+    def following_count
+      redis.zcard relationship_following_key
+    end
+
+    def followers_count
+      redis.zcard relationship_followers_key
+    end
+
+    def following_page_count(limit = page_size)
+      (following_count.to_f / limit.to_f).ceil
+    end
+
+    def followers_page_count(limit = page_size)
+      (followers_count.to_f / limit.to_f).ceil
+    end
+
+    def block(other_user_id)
+      # Unfollow
+      unfollow other_user_id
+      self.new(other_user_id).unfollow user_id
+
+      # Block
+      redis.sadd relationship_blocked_key, other_user_id
+    end
+
+    def unblock(other_user_id)
+      redis.srem relationship_blocked_key, other_user_id
+    end
+
+    def blocked
+      redis.smembers relationship_blocked_key
+    end
+
+    def blocked?(other_user_id)
+      blocked.include? other_user_id.to_s
+    end
+
+    protected
+
+    def bounds(page, limit)
+      [(page - 1) * limit, (page * limit) - 1]
+    end
+  end
+end

data/lib/flocks/search.rb

@@ -0,0 +1,37 @@
+module Flocks
+  module Search
+
+    # Search a user's list of following
+    def search_following(query)
+      redis.zrangebyscore relationship_following_key, start_score(query), stop_score(query)
+    end
+
+    # Search a user's list of followers
+    def search_followers(query)
+      redis.zrangebyscore relationship_followers_key, start_score(query), stop_score(query)
+    end
+
+    # Search a user's entire social graph
+    def search_graph(query)
+      (search_following(query) + search_followers(query)).uniq
+    end
+
+    protected
+
+    # Set constraints to return relevent results
+    # Starting score for redis zrangebyscore
+    def start_score(query)
+      rank_username(query)
+    end
+
+    # 'aaa' -> 'aab'
+    # Ending score for redis zrangebyscore
+    def stop_score(query)
+      query_array = query.chars
+      last_char = (query_array.pop.ord + 1).chr
+      stop_name = query_array.push(last_char).join('')
+      rank_username(stop_name)
+    end
+
+  end
+end

data/lib/flocks/version.rb

@@ -0,0 +1,3 @@
+module Flocks
+  VERSION = "0.0.1"
+end

data/test/flocks/configuration_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class ConfigurationTest < MiniTest::Test
+
+  def test_configuration
+    Flocks.configure do |config|
+      config.redis = Redis.new
+      config.namespace = 'flocks_test'
+      config.following_key = 'following_test'
+      config.followers_key = 'followers_test'
+      config.blocked_key = 'blocked_test'
+      config.blocked_by_key = 'blocked_by_test'
+      config.page_size = 50
+    end
+
+    assert_equal 'flocks_test', Flocks.namespace
+    assert_equal 'following_test', Flocks.following_key
+    assert_equal 'followers_test', Flocks.followers_key
+    assert_equal 'blocked_test', Flocks.blocked_key
+    assert_equal 'blocked_by_test', Flocks.blocked_by_key
+    assert_equal  50, Flocks.page_size
+  end
+end

data/test/flocks/flocks_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class FlocksTest < MiniTest::Test
+
+  def test_initialization
+    flock = Flocks.new(1, 1)
+    assert_equal 1, flock.user_id
+    assert_equal 4948484848, flock.username_score
+  end
+end

data/test/flocks/ordering_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class OrderingTest < MiniTest::Test
+  include Flocks::Ordering
+  include Flocks::Configuration
+
+  def test_score_string_extension
+    # ASCII 'd' == 100, summed up in the scorer == 10101010100
+    assert_equal 10101010100, rank_username('ddddd')
+  end
+
+end

data/test/flocks/relationships_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class RelationshipsTest < MiniTest::Test
+
+  def test_follow_and_unfollow
+    flock = Flocks.new(1, 'username')
+    flock.follow(2, 'other_username')
+    assert flock.following?(2)
+
+    flock.unfollow(2)
+    refute flock.following?(2)
+  end
+
+  def test_following_and_following_count
+    flock = Flocks.new(1, 'username')
+    flock.follow(2, 'other_username')
+    assert_equal ['2'], flock.following
+    assert_equal 1, flock.following_count
+  end
+
+  def test_followers_and_followers_count
+    flock = Flocks.new(1, 'username')
+    flock.follow(2, 'other_username')
+
+    other_flock = Flocks.new(2, 'other_username')
+    assert_equal ['1'], other_flock.followers
+    assert_equal 1, other_flock.followers_count
+  end
+
+  def test_following_page_count
+    flock = Flocks.new(1, 'username')
+    (2..40).to_a.each { |i| flock.follow(i, "#{i}") }
+    assert_equal 2, flock.following_page_count
+  end
+
+  def test_followers_page_count
+    (2..40).to_a.each { |i| Flocks.new(i, "#{i}").follow(1, "username") }
+    flock = Flocks.new(1, 'username')
+    assert_equal 2, flock.followers_page_count
+  end
+
+  def test_block_blocked_and_unblock
+    flock = Flocks.new(1, 'username')
+    flock.follow(2, 'other_username')
+
+    flock.block(2)
+    assert_equal ['2'], flock.blocked
+    assert flock.blocked? 2
+    refute Flocks.new(2).following? 1
+
+    flock.unblock(2)
+    assert_equal ([]), flock.blocked
+  end
+
+end

data/test/flocks/search_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class SearchTest < MiniTest::Test
+
+  def test_search_following
+    flock = Flocks.new(1, 'username')
+    flock.follow(2, 'other_username')
+    flock.follow(3, 'other_username2')
+    flock.follow(4, 'dissimilar_username')
+    results = flock.search_following('other')
+
+    assert_equal ['2', '3'], results
+  end
+
+  def test_search_followers
+    Flocks.new(2, 'other_username').follow(1, 'username')
+    Flocks.new(3, 'other_username2').follow(1, 'username')
+    Flocks.new(4, 'disssimilar_username').follow(1, 'username')
+
+    flock = Flocks.new(1, 'username')
+    results = flock.search_followers('other')
+    assert_equal ['2', '3'], results
+  end
+
+  def test_search_graph
+    Flocks.new(1, 'username').follow(2, 'other_username')
+    Flocks.new(2, 'other_username').follow(1, 'username')
+    Flocks.new(1, 'username').follow(3, 'other_username3')
+    Flocks.new(4, 'other_username4').follow(1, 'username')
+    Flocks.new(5, 'disssimilar_username').follow(1, 'username')
+
+    flock = Flocks.new(1, 'username')
+    results = flock.search_graph('other')
+    assert_equal ['2', '3', '4'], results
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require :test
+
+require 'minitest/autorun'
+require 'redis'
+require 'flocks'
+
+# Support files
+Dir["#{File.expand_path(File.dirname(__FILE__))}/support/*.rb"].each do |file|
+  require file
+end
+
+class MiniTest::Test
+  def setup
+    Flocks.configure do |config|
+      config.redis = Redis.new
+      config.namespace = 'flocks'
+      config.following_key = 'following'
+      config.followers_key = 'followers'
+      config.blocked_key = 'blocked'
+      config.blocked_by_key = 'blocked_by'
+      config.page_size = 25
+    end
+
+    Flocks.redis.flushdb
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: flocks
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Ryan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  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.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: minitest
+  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: Single node social relationships using redis.
+email:
+- adam.g.ryan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- flocks.gemspec
+- lib/flocks.rb
+- lib/flocks/configuration.rb
+- lib/flocks/ordering.rb
+- lib/flocks/relationships.rb
+- lib/flocks/search.rb
+- lib/flocks/version.rb
+- test/flocks/configuration_test.rb
+- test/flocks/flocks_test.rb
+- test/flocks/ordering_test.rb
+- test/flocks/relationships_test.rb
+- test/flocks/search_test.rb
+- test/test_helper.rb
+homepage: https://github.com/byliner/flocks
+licenses:
+- BSD
+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: Single node social relationships using redis.
+test_files:
+- test/flocks/configuration_test.rb
+- test/flocks/flocks_test.rb
+- test/flocks/ordering_test.rb
+- test/flocks/relationships_test.rb
+- test/flocks/search_test.rb
+- test/test_helper.rb