redislike 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b32d60e77c8f6e9fc89a7df48aa4f8229564c66e
+  data.tar.gz: ce5b4dcdafb32682ac78350970cbbedd6ccca032
+SHA512:
+  metadata.gz: ae5c0c559385cf9e46394631629f942b2bd4c5da4b9b9208d3d5ab13ad030b55fc65325b847cadb24cdf74d3bbc48bfbda23555dcb933e9addfbd468174b3b9a
+  data.tar.gz: 9e0bade973bb81c47130e8ba41975b4798d9ece654d338dda1c627ef23c071aa5e946842e59776797fabc5242c51ca3b266b8ee385f54609f3ba2b18902d385e

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle/
+coverage/
+vendor/
+Gemfile.lock

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Chris Olstrom
+
+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,82 @@
+redislike
+=========
+
+For when we want Redis, but can't have nice things.
+
+redislike adds backend-independent support for redis-like list operations to any Moneta datastore.
+
+Supported Operations
+--------------------
+* LINDEX
+* LINSERT
+* LLEN
+* LPOP
+* LPUSH
+* LPUSHX
+* LRANGE
+* LREM
+* LSET
+* LTRIM
+* RPOP
+* RPOPLPUSH
+* RPUSH
+* RPUSHX
+
+Missing
+-------
+* BLPOP
+* BRPOP
+* BRPOPLPUSH
+
+Other Supported Operations
+--------------------------
+* EXISTS
+
+Installation
+------------
+
+```gem install redislike```
+
+or in your Gemfile
+
+```gem 'redislike'```
+
+Example
+-----
+
+```
+require 'redislike'
+datastore = Moneta.new :Memory, expires: true
+
+datastore.lpush 'pending', 'foo'
+datastore.rpoplpush 'pending', 'active'
+puts datastore.lrange 'active', 0, -1
+```
+
+Should return ```['foo']```
+
+Motivation
+----------
+
+Redis may be my favourite data store, for a number of reasons that have nothing to do with this gem. It's also not a silver bullet. Like many tools, used in the right context, it excels. Out of its element, it adds complexity and overhead (when compared to using a tool better suited to that problem domain).
+
+Then there's Moneta, a lovely gem that provides a unified API to an impressive range of backends for key/value storage. This allows low-effort integration with whatever data store you already have. The consistency also enables trivial swapping of backends as the evolution of an application guides requirements, without rewriting much of anything.
+
+To achive this consistency, Moneta omits support for backend-specfic features. One of those that I often want is the (B)RPOPLPUSH list operation from Redis. This takes an item from the tail of one list, and puts it at the head of another list.
+
+Rather than depending on a Redis backend for Moneta, and passing these operations through to it, I built redis-like queue operations on top of Moneta. Once those were in place, it seemed reasonable to continue and build the rest.
+
+At this point, some sort of scope began to take shape. The methods were restructured to align with those provided by Redis, and tests were written to guide this process.
+
+**TL;DR: I wanted RPOPLPUSH in Moneta, didn't define scope boundaries and accidentally reimplemented (some of) Redis.**
+
+Dependencies
+------------
+* Moneta
+
+What's up with the tests?
+-------------------------
+
+Alright, so the tests are a bit unconventional, in the sense that you need a working redis server to actually run the tests for a gem with the stated intent of not requiring a redis server.
+
+These tests that redislike is in fact, redis-like. These work by executing the same instructions against redis, and an in-memory instance of redislike, and asserting that the results should be the same.

data/Rakefile

@@ -0,0 +1,64 @@
+# require 'simplecov'
+
+require 'rubocop/rake_task'
+require 'reek/rake/task'
+require 'roodi_task'
+
+task default: [:test]
+
+task test: [:kintama]
+
+desc 'Run Test Suite'
+task :kintama do
+  sh 'ruby tests/redislike.rb'
+end
+
+task audit: [:style, :complexity, :duplication, :design, :documentation]
+
+task style: [:rubocop]
+
+desc 'Enforce Style Conformance with RuboCop'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.patterns = ['lib/**/*.rb']
+  task.fail_on_error = false
+end
+
+task complexity: [:flog]
+
+desc 'Assess Complexity with Flog'
+# FlogTask.new :flog, 9000, ['lib']
+task :flog do
+  sh 'flog lib/**/*.rb'
+end
+
+task duplication: [:flay]
+
+task :flay do
+  sh 'flay'
+end
+
+task design: [:roodi, :reek]
+
+desc 'Find Code Smells with Reek'
+Reek::Rake::Task.new(:reek) do |task|
+  task.fail_on_error = false
+end
+
+task :rework do
+  sh 'churn'
+end
+
+task :documentation do
+  sh 'inch'
+end
+
+task generate: [:documents, :graphs]
+
+task :documents do
+  sh 'yard'
+end
+
+task :graphs  do
+  sh 'bundle viz'
+  sh 'yard graph | dot -Tpng > lib_graph.png'
+end

data/lib/redislike/helpers/lists.rb

@@ -0,0 +1,40 @@
+module RedisLike
+  module Helpers
+    module Lists
+      def enqueue(list, item, to:, allow_create: true)
+        operation = to == :head ? :unshift : :push
+        items = fetch list, []
+        items.method(operation).call(item)
+        store list, items if allow_create || exists(list)
+        llen list
+      end
+
+      def dequeue(list, from:)
+        operation = from == :head ? :shift : :pop
+        current = fetch list, []
+        item = current.method(operation).call
+        store list, current
+        item
+      end
+
+      def remove_count(list, count, item, from:)
+        operation = from == :tail ? :rindex : :index
+        items = fetch list, []
+        removed = count.times.map do
+          found = items.method(operation).call(item)
+          items.delete_at found if found
+        end
+        store list, items
+        removed.compact.length
+      end
+
+      def remove_all(list, item)
+        items = fetch list, []
+        remove_count list, items.count(item), item, from: :head
+        # remaining = items.reject { |i| i == item }
+        # store list, remaining
+        # items.length - remaining.length
+      end
+    end
+  end
+end

data/lib/redislike/keys.rb

@@ -0,0 +1,15 @@
+require 'moneta'
+
+module RedisLike
+  module Keys
+    def exists(list)
+      key? list
+    end
+  end
+end
+
+module Moneta
+  module Defaults
+    include RedisLike::Keys
+  end
+end

data/lib/redislike/lists.rb

@@ -0,0 +1,91 @@
+require 'moneta'
+require_relative 'helpers/lists'
+
+# Module containing mixins for redis-like operations.
+module RedisLike
+  # Mixin containing redis-like list operations for Moneta stores.
+  module Lists
+    include RedisLike::Keys
+    include RedisLike::Helpers::Lists
+
+    def lpush(list, item)
+      enqueue list, item, to: :head
+    end
+
+    def lpushx(list, item)
+      enqueue list, item, to: :head, allow_create: false
+    end
+
+    def rpush(list, item)
+      enqueue list, item, to: :tail
+    end
+
+    def rpushx(list, item)
+      enqueue list, item, to: :tail, allow_create: false
+    end
+
+    def lpop(list)
+      dequeue list, from: :head
+    end
+
+    def rpop(list)
+      dequeue list, from: :tail
+    end
+
+    def rpoplpush(source, destination)
+      item = rpop source
+      lpush destination, item
+      item
+    end
+
+    def lindex(list, item)
+      fetch(list, []).at item
+    end
+
+    def linsert(list, location, pivot, item)
+      return 0 unless exists list
+      return -1 unless lrange(list, 0, -1).include? pivot
+      items = fetch list, []
+      index = items.index pivot
+      index += 1 if location == :before
+      items.insert(index, item)
+      store list, items
+      llen list
+    end
+
+    def llen(list)
+      fetch(list, []).length
+    end
+
+    def lrange(list, start, stop)
+      fetch(list, [])[(start..stop)] || []
+    end
+
+    def lrem(list, count, item)
+      case
+      when count > 0
+        remove_count list, count, item, from: :head
+      when count < 0
+        remove_count list, count.abs, item, from: :tail
+      when count == 0
+        remove_all list, item
+      end
+    end
+
+    def lset(list, index, item)
+      items = fetch list, []
+      items[index] = item
+      'OK' if store list, items
+    end
+
+    def ltrim(list, start, stop)
+      'OK' if store list, lrange(list, start, stop)
+    end
+  end
+end
+
+module Moneta
+  module Defaults
+    include RedisLike::Lists
+  end
+end

data/lib/redislike.rb

@@ -0,0 +1,2 @@
+require_relative 'redislike/keys'
+require_relative 'redislike/lists'

data/redislike.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |gem|
+  gem.name        = 'redislike'
+  gem.version     = '0.1.0'
+  gem.licenses    = 'MIT'
+  gem.authors     = ['Chris Olstrom']
+  gem.email       = 'chris@olstrom.com'
+  gem.homepage    = 'http://colstrom.github.io/redislike/'
+  gem.summary     = %Q{For when we want Redis, but can't have nice things.}
+  gem.description = %Q{redislike adds backend-independent support for redis-like list operations to any Moneta datastore.}
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'moneta', '~> 0.8'
+
+  gem.add_development_dependency 'kintama', '~> 0.1'
+  gem.add_development_dependency 'simplecov', '~> 0.8'
+  gem.add_development_dependency 'redis', '~> 3.2'
+end

data/tests/redislike/lists.rb

@@ -0,0 +1,255 @@
+context 'List Operations' do
+  def mirror(method, *arguments)
+    original = @original.method(method).call(*arguments)
+    compatible = @compatible.method(method).call(*arguments)
+    [original, compatible]
+  end
+
+  def assert_compatible(method, *arguments)
+    assert_equal(*mirror(method, *arguments))
+  end
+
+  setup do
+    @original = Redis.new
+    # @compatible = Moneta.new :Daybreak, file: '.test.db', expires: true
+    @compatible = Moneta.new :Memory
+
+    @original.del 'test', 'test:a', 'test:b', 'test:nx'
+  end
+
+  teardown do
+    @original.disconnect!
+    @compatible.close
+  end
+
+  context 'lindex' do
+    setup do
+      mirror :lpush, 'test', 'foo'
+      mirror :lpush, 'test', 'bar'
+    end
+
+    test 'when list does not exist' do
+      assert_compatible :lindex, 'test:nx', 1
+    end
+
+    test 'in range' do
+      assert_compatible :lindex, 'test', 1
+    end
+
+    test 'out of range' do
+      assert_compatible :lindex, 'test', 999
+    end
+  end
+
+  context 'linsert' do
+    setup do
+      mirror :lpush, 'test', 'foo'
+    end
+
+    test 'when list does not exist' do
+      assert_compatible :linsert, 'test:nx', :before, 'foo', 'bar'
+      assert_compatible :linsert, 'test:nx', :after, 'foo', 'bar'
+    end
+
+    test 'when list contains pivot value' do
+      assert_compatible :linsert, 'test', :before, 'foo', 'bar'
+      assert_compatible :linsert, 'test', :after, 'foo', 'bar'
+    end
+
+    test 'when list does not contain pivot value' do
+      assert_compatible :linsert, 'test', :before, 'baz', 'bar'
+      assert_compatible :linsert, 'test', :after, 'baz', 'bar'
+    end
+  end
+
+  context 'llen' do
+    test 'when list does not exist' do
+      assert_compatible :llen, 'test:nx'
+    end
+
+    test 'when list exists' do
+      mirror :lpush, 'test', 'foo'
+      assert_compatible :llen, 'test'
+    end
+  end
+
+  context 'lpop' do
+    test 'when list does not exist' do
+      assert_compatible :lpop, 'test:nx'
+    end
+
+    test 'when list exists' do
+      mirror :lpush, 'test', 'foo'
+      assert_compatible :lpop, 'test:nx'
+    end
+  end
+
+  context 'lpush' do
+    test 'when list does not exist' do
+      assert_compatible :lpush, 'test:nx', 'foo'
+    end
+
+    test 'when list has items already' do
+      mirror :lpush, 'test', 'foo'
+      assert_compatible :lpush, 'test', 'foo'
+    end
+  end
+
+  context 'lpushx' do
+    test 'when list does not exist' do
+      assert_compatible :lpushx, 'test:nx', 'foo'
+    end
+
+    test 'when list has items already' do
+      mirror :lpush, 'test', 'foo'
+      assert_compatible :lpushx, 'test', 'foo'
+    end
+  end
+
+  context 'lrange' do
+    test 'when list does not exist' do
+      assert_compatible :lrange, 'test:nx', 0, -1
+    end
+
+    test 'when list exists' do
+      mirror :lpush, 'test', 'foo'
+      assert_compatible :lrange, 'test', 0, -1
+    end
+
+    test 'stop beyond range' do
+      mirror :lpush, 'test', 'foo'
+      assert_compatible :lrange, 'test', 0, 9
+    end
+
+    test 'stop before start' do
+      mirror :lpush, 'test', 'foo'
+      assert_compatible :lrange, 'test', -1, 1
+    end
+  end
+
+  context 'lrem' do
+    setup do
+      mirror :lpush, 'test', 'foo'
+      mirror :lpush, 'test', 'foo'
+      mirror :lpush, 'test', 'foo'
+    end
+
+    test 'when list does not exist' do
+      assert_compatible :lrem, 'test:nx', 0, 'foo'
+    end
+
+    test 'all items (present)' do
+      assert_compatible :lrem, 'test', 0, 'foo'
+    end
+
+    test 'all items (when not present)' do
+      assert_compatible :lrem, 'test', 0, 'bar'
+    end
+
+    test 'one from head (present)' do
+      assert_compatible :lrem, 'test', 1, 'foo'
+    end
+
+    test 'one from head (when not present)' do
+      assert_compatible :lrem, 'test', 1, 'bar'
+    end
+
+    test 'more than exists from head (present)' do
+      assert_compatible :lrem, 'test', 9, 'foo'
+    end
+
+    test 'more than exists from head (when not present)' do
+      assert_compatible :lrem, 'test', 9, 'bar'
+    end
+
+    test 'one from tail (present)' do
+      assert_compatible :lrem, 'test', -1, 'foo'
+    end
+
+    test 'one from tail (when not present)' do
+      assert_compatible :lrem, 'test', -1, 'bar'
+    end
+
+    test 'more than exists from tail (present)' do
+      assert_compatible :lrem, 'test', -9, 'foo'
+    end
+
+    test 'more than exists from tail (when not present)' do
+      assert_compatible :lrem, 'test', -9, 'bar'
+    end
+  end
+
+  context 'lset' do
+    setup do
+      mirror :lpush, 'test', 'foo'
+      mirror :lpush, 'test', 'foo'
+      mirror :lpush, 'test', 'foo'
+    end
+
+    test 'in range' do
+      assert_compatible :lset, 'test', 1, 'bar'
+      assert_equal mirror(:lindex, 'test', 1).uniq, ['bar']
+    end
+  end
+
+  context 'ltrim' do
+    setup do
+      100.times do
+        mirror :lpush, 'test', 'foo'
+      end
+    end
+
+    test 'when list does not exist' do
+      assert_compatible :ltrim, 'test:nx', 0, 10
+    end
+
+    test 'when range is larger than list length' do
+      assert_compatible :ltrim, 'test', 0, 200
+      assert_equal mirror(:lrange, 'test', 0, -1).uniq.flatten.size, 100
+    end
+  end
+
+  context 'rpop' do
+    test 'when list does not exist' do
+      assert_compatible :rpop, 'test:nx'
+    end
+
+    test 'when list exists' do
+      mirror :rpush, 'test', 'foo'
+      assert_compatible :rpop, 'test:nx'
+    end
+  end
+
+  context 'rpoplpush' do
+    test 'when source list does not exist' do
+      assert_compatible :rpoplpush, 'test:nx', 'test:b'
+    end
+
+    test 'when list exists' do
+      3.times { mirror :lpush, 'test:a', 'foo' }
+      assert_compatible :rpoplpush, 'test:a', 'test:b'
+    end
+  end
+
+  context 'rpush' do
+    test 'when list does not exist' do
+      assert_compatible :rpush, 'test:nx', 'foo'
+    end
+
+    test 'when list has items already' do
+      mirror :rpush, 'test', 'foo'
+      assert_compatible :rpush, 'test', 'foo'
+    end
+  end
+
+  context 'rpushx' do
+    test 'when list does not exist' do
+      assert_compatible :rpushx, 'test:nx', 'foo'
+    end
+
+    test 'when list has items already' do
+      mirror :rpush, 'test', 'foo'
+      assert_compatible :rpushx, 'test', 'foo'
+    end
+  end
+end

data/tests/redislike.rb

@@ -0,0 +1,11 @@
+
+require 'bundler/setup'
+require 'simplecov'
+SimpleCov.command_name 'Kintama'
+SimpleCov.start { add_filter '/vendor/' }
+require 'redis'
+require 'kintama'
+require 'moneta'
+
+require_relative '../lib/redislike'
+require_relative 'redislike/lists'

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: redislike
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Olstrom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: moneta
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: kintama
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: redislike adds backend-independent support for redis-like list operations
+  to any Moneta datastore.
+email: chris@olstrom.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/redislike.rb
+- lib/redislike/helpers/lists.rb
+- lib/redislike/keys.rb
+- lib/redislike/lists.rb
+- redislike.gemspec
+- tests/redislike.rb
+- tests/redislike/lists.rb
+homepage: http://colstrom.github.io/redislike/
+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.4.5
+signing_key: 
+specification_version: 4
+summary: For when we want Redis, but can't have nice things.
+test_files: []
+has_rdoc: