moneta 1.5.2 → 1.6.0

data/script/parallel-tests

@@ -1,82 +0,0 @@
-#!/usr/bin/env ruby
-
-ENV['PARALLEL_TESTS'] = 'yes'
-
-require 'multi_json'
-
-def tag_args tags
-  tags.flat_map{ |tag| ['--tag', tag] }
-end
-
-def example_ids tags, specs
-  json = `bundle exec rspec -f j --dry-run #{tag_args(tags).join(' ')} -- #{specs.join(' ')}`
-  data = MultiJson.load(json)
-  data['examples'].map{ |example| example['id'] }
-end
-
-def run(*args)
-  pid = spawn(*args)
-  Signal.trap("INT") { Process.kill("INT", pid) }
-  Process.wait(pid)
-  $? == 0
-ensure
-  Signal.trap("INT", "DEFAULT")
-end
-
-tags = ARGV.take_while { |arg| arg[0] != '-' }
-ARGV.shift(tags.length)
-opts = []
-files = nil
-while arg = ARGV.shift
-  case arg
-  when '--'
-    files = ARGV
-    break
-  when '--remainder'
-    files = Dir['spec/**/*_spec.rb', 'test/**/*_test.rb']
-    existing = File.open('.travis.yml').each_line.flat_map do |line|
-      next unless matches = line.match(%r{((?:test|spec)/(?:[\w\.]+/?)*)})
-      path = matches[1]
-      path[-3..-1] == '.rb' ? path : path + '/**/*.rb'
-    end.compact
-    files -= Dir[*existing]
-  else
-    opts << arg
-  end
-end
-
-files ||= Dir['spec', 'test/**/*_test.rb']
-specs, tests = files.partition { |file| file.match /^spec/ }
-
-puts "The following specs will be executed:\n\t#{specs.join "\n\t"}\n\n" unless specs.empty?
-puts "The following tests will be executed:\n\t#{tests.join "\n\t"}\n\n" unless tests.empty?
-
-results = []
-unless specs.empty?
-  # run all non :isolate examples in parallel
-  results << run(*%w{bundle exec parallel_rspec --},
-                 *opts,
-                 *tag_args(tags | %w{~isolate}),
-                 '--',
-                 *specs)
-
-  # find the example IDs of the isolate examples to be run in serial
-  ids = example_ids(tags, specs) - example_ids(tags | %w{~isolate}, specs)
-  unless ids.empty?
-    results << run(*%w{bundle exec rspec},
-                   *opts,
-                   '--',
-                   *ids)
-  end
-end
-
-tests.each do |test|
-  results << run(*%w{bundle exec ruby}, test)
-end
-
-if results.any?{ |result| !result }
-  puts "\e[31m########## MONETA TESTSUITE FAILED ##########\e[0m"
-  exit 1
-end
-
-puts "\e[32m########## MONETA TESTSUITE SUCCEDED ##########\e[0m"

data/script/start-couchdb

@@ -1,27 +0,0 @@
-#!/bin/bash
-set -e
-
-# Copied from https://github.com/apache/couchdb-pkg/blob/master/debian/README.Debian
-COUCHDB_PASSWORD=password
-echo "couchdb couchdb/mode select standalone
-couchdb couchdb/mode seen true
-couchdb couchdb/bindaddress string 127.0.0.1
-couchdb couchdb/bindaddress seen true
-couchdb couchdb/adminpass password ${COUCHDB_PASSWORD}
-couchdb couchdb/adminpass seen true
-couchdb couchdb/adminpass_again password ${COUCHDB_PASSWORD}
-couchdb couchdb/adminpass_again seen true" | sudo debconf-set-selections
-DEBIAN_FRONTEND=noninteractive sudo apt-get install -y --force-yes couchdb
-
-# Reconfigure CouchDB to use delayed commits for speed: http://guide.couchdb.org/draft/performance.html
-sudo sed -i '/\[couchdb\]/a delayed_commits = true' /etc/couchdb/local.ini
-
-# (Re)start couchdb
-sudo systemctl restart couchdb
-
-# Display some info about CouchDB
-sudo systemctl status couchdb
-until curl http://localhost:5984/; do
-  sleep 1
-done
-

data/script/start-hbase

@@ -1,47 +0,0 @@
-#!/bin/sh
-set -e
-
-cd $(dirname $(dirname $0))
-
-mkdir -p hbase
-mkdir -p zookeeper
-mkdir -p downloads
-root=$(pwd)
-
-version=$(curl -sS https://downloads.apache.org/hbase/stable/RELEASENOTES.md | grep -oP '(?<=# HBASE\s\s)(\d+\.?)+' | head -n1)
-
-echo HBase stable version is $version
-
-if [ ! -f downloads/hbase-$version-bin.tar.gz ]; then
-  echo Downloading HBase ...
-  wget -P downloads https://downloads.apache.org/hbase/stable/hbase-$version-bin.tar.gz
-fi
-
-echo Extracting HBase ...
-cd hbase
-tar -zxf $root/downloads/hbase-$version-bin.tar.gz
-
-echo Configuring HBase ...
-echo "export JAVA_HOME=/usr" >> hbase-$version/conf/hbase-env.sh
-tee <<-EOF > hbase-$version/conf/hbase-site.xml
-<configuration>
-  <property>
-    <name>hbase.rootdir</name>
-    <value>file://$root/hbase</value>
-  </property>
-  <property>
-    <name>hbase.zookeeper.property.dataDir</name>
-    <value>$root/zookeeper</value>
-  </property>
-  <property>
-    <name>hbase.unsafe.stream.capability.enforce</name>
-    <value>false</value>
-  </property>
-</configuration>
-EOF
-
-echo Launching HBase ...
-./hbase-$version/bin/start-hbase.sh
-./hbase-$version/bin/hbase-daemon.sh start thrift
-
-cd $root

data/script/start-services

@@ -1,10 +0,0 @@
-#!/bin/bash
-
-# Install and start CouchDB
-$(dirname $0)/start-couchdb
-
-# Install and start HBase
-$(dirname $0)/start-hbase
-
-# Waiting for servers to start
-sleep 3

data/script/travis-logs

@@ -1,14 +0,0 @@
-#! /usr/bin/env ruby
-require 'travis'
-require 'cgi'
-require 'fileutils'
-FileUtils.mkpath('logs')
-`git remote -v | grep origin | head -n1` =~ /github\.com:(.*?)\.git/
-repo = Travis::Repository.find($1)
-build = repo.recent_builds.select {|b| b.finished_at }.first
-build.jobs.each do |j|
-  c = j.config
-  id = "logs/#{j.allow_failures? ? 'allowed-' : ''}#{j.state}-#{c['rvm']}-#{CGI.escape c['env']}"
-  puts "Downloading #{j.id}"
-  File.open(id, 'w') {|f| f.write(j.log.body) }
-end

data/script/update-feature-matrix

@@ -1,148 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-require 'rubygems'
-require 'bundler/setup'
-Bundler.require(:doc)
-
-require 'yaml'
-
-output = "<table>\n"
-output << <<-TAB.lines.map(&:strip).join
-  <tr>
-    <th>Adapter</th><th>Required gems</th>
-    <th style="writing-mode:tb">MRI support<sup>1</sup></th>
-    <th style="writing-mode:tb">JRuby support<sup>1</sup></th>
-    <th style="writing-mode:tb">Multi-thread safe<sup>2</sup></th>
-    <th style="writing-mode:tb">Multi-process safe<sup>3</sup></th>
-    <th style="writing-mode:tb">Atomic increment<sup>4</sup></th>
-    <th style="writing-mode:tb">Atomic create<sup>5</sup></th>
-    <th style="writing-mode:tb">Native expires<sup>6</sup></th>
-    <th style="writing-mode:tb">Persistent</th>
-    <th style="writing-mode:tb">Key Traversal</th>
-    <th style="writing-mode:tb">Bulk read<sup>7</sup></th>
-    <th style="writing-mode:tb">Bulk write<sup>8</sup></th>
-    <th>Description</th>
-  </tr>
-TAB
-output << "\n\n"
-
-footnotes = {
-  "platform" => <<-EOF,
-  Indicates that the adapter is expected to work on this platform.  Most adapters will at least
-  work on MRI, but some are curently considered unstable, in which case they are not supported
-  on any platform.
-  EOF
-  "multi-thread safe" => <<-EOF,
-  Make adapters thread-safe by using `Moneta::Lock` or by passing the option `threadsafe: true` to
-  `Moneta#new`. There is also `Moneta::Pool` which can be used to share a store between multiple
-  threads if the store is multi-process safe. I recommend to add the option `:threadsafe` to
-  ensure thread-safety since for example under JRuby and Rubinius even the basic datastructures
-  are not thread safe due to the lack of a global interpreter lock (GIL). This differs from MRI
-  where some adapters might appear thread safe already but only due to the GIL.
-  EOF
-  "multi-process safe" => <<-EOF,
-  Share a Moneta store between multiple processes using `Moneta::Shared` (See below).
-  EOF
-  "atomic increment" => <<-EOF,
-  If a store provides atomic increment it can be used with `Moneta::Semaphore`. You can add weak
-  `#increment` support using the `Moneta::WeakIncrement` proxy.
-  EOF
-  "atomic create" => <<-EOF,
-  If a store provides atomic creation it can be used with `Moneta::Mutex`. You can add weak
-  `#create` support using the `Moneta::WeakCreate` proxy.
-  EOF
-  "native expires" => <<-EOF,
-  Add expiration support by using `Moneta::Expires` or by passing the option `expires: true` to
-  `Moneta#new`.
-  EOF
-  "bulk read" => <<-EOF,
-  This indicates that there is some performance gain when fetching
-  multiple values at once using `#values_at`/`#fetch_values` or `#slice`.
-  For instance, the `MGET` instruction in Redis, or the ability to retrieve
-  several rows in one query in SQL.
-  EOF
-  "bulk write" => <<-EOF
-  This indicates that there is some performance gain when storing multiple
-  key/value pairs at once using `#merge!`/`#update`.
-  EOF
-}
-
-YAML.parse_stream(File.read(File.join(File.dirname(File.dirname(__FILE__)), 'feature_matrix.yaml'))) do |document|
-  feature_group = document.to_ruby
-
-  output << %{<tr><th colspan="2">#{feature_group['group']}</th><th colspan="12"></th></tr>\n\n}
-
-  feature_group['notes'].each do |k,v|
-    footnotes[k] = v
-  end
-
-  feature_group['backends'].each do |backend|
-    output << '<tr>'
-    output << "<td>#{backend['adapter']}</td>"
-    output << "<td>#{backend['gems'] || '-'}</td>"
-
-    features = backend['features'] | (feature_group['features'] || [])
-    features += backend['platforms'] || []
-    %w{MRI JRuby threadsafe multiprocess increment create expires persist each_key bulk_read bulk_write}.each do |feature|
-      supported = if features.include? feature
-                    "yes"
-                  elsif backend['unknown'] && backend['unknown'].include?(feature)
-                    "unknown"
-                  else
-                    "no"
-                  end
-
-      note = if backend['notes'] && backend['notes'][feature]
-               "<sup>#{footnotes.keys.index(backend['notes'][feature]) + 1}</sup>"
-             else
-               ''
-             end
-
-      mark = case supported
-              when "yes"
-               "✓"
-              when "no"
-                "✗"
-              when "unknown"
-                '?'
-              end
-
-      colour = case supported
-               when "yes"
-                 '#5F5'
-               when "no"
-                 '#F44'
-               when "unknown"
-                 '#55F'
-               end
-
-      output << %{<td style="text-align:center;background:#{colour}">#{mark}#{note}</td>}
-    end
-
-    html_description = if backend['description']
-                         Kramdown::Document.new(backend['description']).to_html.match('<p>(.*)</p>')[1]
-                       else
-                         ''
-                       end
-    output << "<td>#{html_description}</td>"
-
-    output << '</tr>'
-    output << "\n\n"
-  end
-
-
-end
-
-output << "</table>\n\n"
-
-footnotes.each_value.each_with_index do |note, idx|
-  output << "#{idx+1}. #{note.lines.map(&:strip).join(" ")}\n"
-end
-
-readme = File.open('README.md', 'r+')
-new_readme = readme.read.sub(/(name="backend-matrix".*?\n).*?(------)/m, "\\1\n#{output}\n\\2")
-readme.rewind
-readme << new_readme
-readme.truncate(readme.tell)
-

data/spec/active_support/cache_moneta_store_spec.rb

@@ -1,282 +0,0 @@
-require 'moneta'
-require 'active_support'
-require 'active_support/cache/moneta_store'
-require 'ostruct'
-require_relative '../moneta/adapters/memcached_helper.rb'
-
-describe "cache_moneta_store" do
-  before(:all) do
-    @events = []
-    ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
-      @events << ActiveSupport::Notifications::Event.new(*args)
-    end
-  end
-
-  before(:each) do
-    @events.clear
-  end
-
-  # All stores should implement this basic behavior.
-  shared_examples :basic_store do
-    let(:rabbit) { OpenStruct.new name: 'bunny' }
-    let(:white_rabbit) { OpenStruct.new color: 'white' }
-
-    before(:each) do
-      store.clear
-      store.write 'rabbit', rabbit
-      @events.clear
-    end
-
-    it 'reads the data' do
-      expect(store.read('rabbit')).to eq rabbit
-    end
-
-    it 'writes the data' do
-      store.write 'rabbit', white_rabbit
-      expect(store.read('rabbit')).to eq white_rabbit
-    end
-
-    it 'deletes data' do
-      store.delete 'rabbit'
-      expect(store.read('rabbit')).to be_nil
-    end
-
-    it 'verifies existence of an object in the store' do
-      expect(store.exist?('rabbit')).to be true
-      expect(!!store.exist?('rab-a-dub')).to be false
-    end
-
-    it 'fetches data' do
-      expect(store.fetch('rabbit')).to eq rabbit
-      expect(store.fetch('rub-a-dub')).to be_nil
-      store.fetch('rub-a-dub') { 'Flora de Cana' }
-      expect(store.fetch('rub-a-dub')).to eq 'Flora de Cana'
-    end
-
-    it 'reads multiple keys' do
-      store.write 'irish whisky', 'Jameson'
-      result = store.read_multi 'rabbit', 'irish whisky'
-      expect(result['rabbit']).to eq rabbit
-      expect(result['irish whisky']).to eq 'Jameson'
-    end
-
-    it 'reads multiple keys and returns only the matched ones' do
-      store.delete 'irish whisky'
-      result = store.read_multi 'rabbit', 'irish whisky'
-      expect(result).not_to include('irish whisky')
-      expect(result).to include('rabbit')
-    end
-
-    it 'fetches multiple keys and fills in the missing ones' do
-      store.delete 'irish whisky'
-      result = store.fetch_multi('rabbit', 'irish whisky') do |k|
-        k + ' was missing'
-      end
-      expect(result['rabbit']).to eq rabbit
-      expect(result['irish whisky']).to eq 'irish whisky was missing'
-      expect(store.fetch('irish whisky')).to eq 'irish whisky was missing'
-    end
-  end
-
-  shared_examples :expiry do
-    it 'writes the data with expiration time' do
-      store.write 'rabbit', white_rabbit, expires_in: 0.2.second
-      expect(store.read('rabbit')).to eq white_rabbit
-      sleep 0.3
-      expect(store.read('rabbit')).to be_nil
-    end
-
-    it 'writes multiple values with expiration time' do
-      store.write_multi({
-                          'rabbit' => white_rabbit,
-                          'irish whisky' => 'Jameson'
-                        }, expires_in: 0.2.second)
-
-      expect(store.read_multi('rabbit', 'irish whisky')).to eq \
-        'rabbit' => white_rabbit,
-        'irish whisky' => 'Jameson'
-
-      sleep 0.3
-      expect(store.read_multi('rabbit', 'irish whisky')).to be_empty
-    end
-
-    it "sets expiry on cache miss" do
-      store.fetch('rabbit', force: true, expires_in: 0.2.second) { white_rabbit }
-      expect(store.fetch('rabbit')).to eq white_rabbit
-      sleep 0.3
-      expect(store.fetch('rabbit')).to be_nil
-    end
-
-    it 'does not set expiry on cache hit' do
-      expect(store.fetch('rabbit', expires_in: 0.2.second) { white_rabbit }).to eq rabbit
-      sleep 0.3
-      expect(store.fetch('rabbit')).to eq rabbit
-    end
-  end
-
-  # A store *may* implement this
-  shared_examples :increment_decrement do
-    it 'increments a key' do
-      store.write 'counter', 0, raw: true
-      (1..3).each do |i|
-        expect(store.increment('counter')).to eq i
-      end
-      expect(store.read('counter', raw: true).to_i).to eq 3
-    end
-
-    it 'decrements a key' do
-      store.write 'counter', 0, raw: true
-      3.times { store.increment 'counter' }
-      2.times { store.decrement 'counter' }
-      expect(store.read('counter', raw: true).to_i).to eq 1
-    end
-
-    it 'increments a key by given value' do
-      store.write 'counter', 0, raw: true
-      store.increment 'counter', 3
-      expect(store.read('counter', raw: true).to_i).to eq 3
-    end
-
-    it 'decrements a key by given value' do
-      store.write 'counter', 0, raw: true
-      3.times { store.increment 'counter' }
-      store.decrement 'counter', 2
-      expect(store.read('counter', raw: true).to_i).to eq 1
-    end
-  end
-
-  shared_examples :basic_instrumentation do
-    it 'notifies on #fetch' do
-      store.fetch('radiohead') { 'House Of Cards' }
-
-      read = @events.shift
-      expect(read.name).to eq 'cache_read.active_support'
-      expect(read.payload).to include(key: 'radiohead', super_operation: :fetch, hit: false)
-
-      generate = @events.shift
-      expect(generate.name).to eq 'cache_generate.active_support'
-      expect(generate.payload).to include(key: 'radiohead')
-
-      write = @events.shift
-      expect(write.name).to eq 'cache_write.active_support'
-      expect(write.payload).to include(key: 'radiohead')
-    end
-
-    it 'notifies on #read' do
-      store.read 'metallica'
-
-      read = @events.shift
-      expect(read.name).to eq 'cache_read.active_support'
-      expect(read.payload).to include(key: 'metallica', hit: false)
-    end
-
-    it 'notifies on #write' do
-      store.write 'depeche mode', 'Enjoy The Silence'
-
-      write = @events.shift
-      expect(write.name).to eq 'cache_write.active_support'
-      expect(write.payload).to include(key: 'depeche mode')
-    end
-
-    it 'notifies on #delete' do
-      store.delete 'the new cardigans'
-
-      delete = @events.shift
-      expect(delete.name).to eq 'cache_delete.active_support'
-      expect(delete.payload).to include(key: 'the new cardigans')
-    end
-
-    it 'notifies on #exist?' do
-      store.exist? 'the smiths'
-
-      exist = @events.shift
-      expect(exist.name).to eq 'cache_exist?.active_support'
-      expect(exist.payload).to include(key: 'the smiths')
-    end
-  end
-
-  # This doesn't seem to be documented at all, so we follow the
-  # behavior of MemCacheStore.
-  shared_examples :increment_decrement_instrumentation do
-    it 'notifies on #increment' do
-      store.increment 'pearl jam'
-
-      increment = @events.shift
-      expect(increment.name).to eq 'cache_increment.active_support'
-      expect(increment.payload).to eq(key: 'pearl jam', amount: 1)
-    end
-
-    it 'notifies on #decrement' do
-      store.decrement 'placebo'
-      decrement = @events.shift
-      expect(decrement.name).to eq 'cache_decrement.active_support'
-      expect(decrement.payload).to eq(key: 'placebo', amount: 1)
-    end
-  end
-
-  describe ActiveSupport::Cache::MonetaStore do
-    shared_examples :moneta_store do
-      include_examples :basic_store
-      include_examples :expiry
-      include_examples :increment_decrement
-      include_examples :basic_instrumentation
-      include_examples :increment_decrement_instrumentation
-
-      # FIXME: no other store does this -- perhaps this should be
-      # removed.
-      it 'notifies on #clear' do
-        store.clear
-
-        clear = @events.shift
-        expect(clear.name).to eq 'cache_clear.active_support'
-        expect(clear.payload).to eq(key: nil)
-      end
-    end
-
-    context "with :Memory store" do
-      let(:store) { described_class.new(store: :Memory) }
-      include_examples :moneta_store
-    end
-
-    context "with existing :Memory store" do
-      let(:store) { described_class.new(store: ::Moneta.new(:Memory)) }
-      include_examples :moneta_store
-    end
-
-    context "with Redis store", adapter: :Redis do
-      let(:store) { described_class.new(store: :Redis) }
-      include_examples :moneta_store
-    end
-  end
-
-  describe ActiveSupport::Cache::MemoryStore do
-    let(:store) { described_class.new }
-
-    include_examples :basic_store
-    include_examples :expiry
-    include_examples :increment_decrement
-    include_examples :basic_instrumentation
-  end
-
-  describe ActiveSupport::Cache::MemCacheStore, memcached: true do
-    let(:store) { described_class.new('127.0.0.1:11213') }
-
-    include_context :start_memcached, 11213
-
-    include_examples :basic_store
-    include_examples :expiry
-    include_examples :increment_decrement
-    include_examples :basic_instrumentation
-    include_examples :increment_decrement_instrumentation
-  end
-
-  describe ActiveSupport::Cache::RedisCacheStore, redis: true do
-    let(:store) { described_class.new(url: "redis:///3") }
-
-    include_examples :basic_store
-    include_examples :expiry
-    include_examples :increment_decrement
-    include_examples :basic_instrumentation
-    include_examples :increment_decrement_instrumentation
-  end
-end

data/spec/features/concurrent_create.rb

@@ -1,42 +0,0 @@
-shared_examples :concurrent_create do
-  # Each thread attempts to create
-  def create_thread(name)
-    Thread.new do
-      s = new_store
-      begin
-        (0...1000).map do |i|
-          s.create(i.to_s, name, expires: false).tap do
-            Thread.pass if rand(100) >= 99
-          end
-        end
-      ensure
-        s.close
-      end
-    end
-  end
-
-  it 'have atomic create across multiple threads', isolate: true do
-    names = %w{a b c}
-
-    # Spawn threads and then group results (lists of true/false values) by
-    # store index (0...1000)
-    results = names
-      .map { |name| create_thread(name) }
-      .map(&:value)
-      .transpose.each_with_index
-      .map { |created_values, i| [i.to_s, created_values] }
-      .to_h
-
-    # Just a quick sanity check
-    expect(results.length).to eq 1000
-
-    # Ensure that for each index, one and only one created value is true
-    expect(results.map { |_, created_values| created_values.inject(:^) }).to all(be true)
-
-    # Check that the when a call to create returned true, that the store
-    # contains the correct value as a result
-    expect(store.slice(*results.keys).to_h).to eq(results.map do |i, values|
-      [i, names[values.index(true)]]
-    end.to_h)
-  end
-end

data/spec/features/concurrent_increment.rb

@@ -1,39 +0,0 @@
-shared_examples :concurrent_increment do
-  def increment_thread(name)
-    Thread.new do
-      s = new_store
-      begin
-        # Create an array where each entry is a list of all the return values
-        # from calling increment for a particular key.
-        increments = (0...100).map { [] }
-        100.times do
-          100.times do |j|
-            increments[j] << s.increment(j.to_s, 1, expires: false)
-            Thread.pass if rand(1000) >= 995
-          end
-        end
-        increments
-      ensure
-        s.close
-      end
-    end
-  end
-
-  it 'have atomic increment across multiple threads', isolate: true do
-    results = %w{a b c}
-      .map { |name| increment_thread(name) }
-      .map(&:value)
-      .transpose # Now the array is indexed by store key instead of thread
-
-    # Sanity check
-    expect(results.length).to eq 100
-
-    results.each do |ith_values|
-      # ensure that for each pair in the triple there are no overlapping values
-      expect(ith_values.combination(2).map { |a, b| a & b }).to all be_empty
-
-      # ensure that when joined together they cover the full 1..300 range
-      expect(ith_values.inject(:+)).to contain_exactly(*1..300)
-    end
-  end
-end