airspace 1.0.0

data/lib/airspace/store.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Airspace
+  # The Store is the data access layer that knows how to persist and retrieve all data.
+  # There really should never be a need to interact directly with the store, it merely
+  # acts as an intermediary between the Redis client and the Dataset/Reader.
+  class Store
+    attr_reader :client
+
+    def initialize(client)
+      raise ArgumentError unless client
+
+      @client = client
+    end
+
+    def exist?(key)
+      client.exists(key.root)
+    end
+
+    def persist(key, info_hash, chunks, expires_in_seconds)
+      options = make_options(expires_in_seconds)
+
+      multi_pipeline do
+        client.set(key.root, info_hash.to_json, options)
+
+        chunks.each_with_index do |chunk, index|
+          chunk_key = key.chunk(index)
+          client.set(chunk_key, chunk.to_json, options)
+        end
+      end
+
+      nil
+    end
+
+    def retrieve(key)
+      return nil unless exist?(key)
+
+      data = client.get(key)
+
+      JSON.parse(data)
+    end
+
+    def delete(key, chunk_count)
+      return false unless exist?(key)
+
+      multi_pipeline do
+        client.del(key.root)
+
+        (0...chunk_count).each do |index|
+          chunk_key = key.chunk(index)
+          client.del(chunk_key)
+        end
+      end
+
+      true
+    end
+
+    def chunks(key, chunk_count)
+      futures     = chunk_futures(key, chunk_count)
+      all_chunks  = []
+
+      futures.each do |chunk_future|
+        cached_chunk = chunk_future.value
+        all_chunks += JSON.parse(cached_chunk)
+      end
+
+      all_chunks
+    end
+
+    def chunk(key, chunk_index)
+      chunk_key     = key.chunk(chunk_index)
+      cached_chunk  = client.get(chunk_key)
+
+      return [] unless cached_chunk
+
+      JSON.parse(cached_chunk)
+    end
+
+    private
+
+    def multi_pipeline
+      client.multi do
+        client.pipelined do
+          yield
+        end
+      end
+    end
+
+    def make_options(expires_in_seconds)
+      {}.tap do |o|
+        o[:ex] = expires_in_seconds if expires_in_seconds
+      end
+    end
+
+    def chunk_futures(key, chunk_count)
+      futures = []
+
+      client.pipelined do
+        (0...chunk_count).each do |index|
+          chunk_key = key.chunk(index)
+          futures << client.get(chunk_key)
+        end
+      end
+
+      futures
+    end
+  end
+end

data/lib/airspace/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Airspace
+  VERSION = '1.0.0'
+end

data/spec/airspace/airspace_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './spec/spec_helper'
+
+class CustomSerializer < ::Airspace::Serializer
+  def serialize_data(obj)
+    obj = obj.map { |k, v| [k.to_sym, v] }.to_h
+
+    json_serialize(
+      [
+        obj[:movie_name],
+        obj[:release_date].to_s,
+        obj[:rating]
+      ]
+    )
+  end
+
+  def deserialize_data(json)
+    array = json_deserialize(json)
+
+    {
+      movie_name: array[0],
+      release_date: Date.parse(array[1]),
+      rating: array[2]
+    }
+  end
+
+  def serialize_row(obj)
+    obj = obj.map { |k, v| [k.to_sym, v] }.to_h
+
+    json_serialize([obj[:id], obj[:name]])
+  end
+
+  def deserialize_row(json)
+    array = json_deserialize(json)
+
+    {
+      id: array[0],
+      name: array[1]
+    }
+  end
+end
+
+# This is mainly to ensure CI has a proper Redis installation and instance.
+describe ::Airspace do
+  let(:client) { Redis.new }
+
+  let(:data) do
+    {
+      'movie_name' => 'Avengers',
+      'release_date' => Date.new(2012, 5, 5),
+      'rating' => 'PG-13'
+    }
+  end
+
+  let(:data_hash) do
+    {
+      'movie_name' => 'Avengers',
+      'release_date' => '2012-05-05',
+      'rating' => 'PG-13'
+    }
+  end
+
+  let(:rows) do
+    [
+      { 'id' => 1, 'name' => 'Iron Man' },
+      { 'id' => 2, 'name' => 'Hulk' },
+      { 'id' => 3, 'name' => 'Thor' },
+      { 'id' => 4, 'name' => 'Spiderman' },
+      { 'id' => 5, 'name' => 'Captain America' }
+    ]
+  end
+
+  let(:pages) do
+    rows.each_slice(2).to_a
+  end
+
+  let(:symbolized_pages) do
+    pages.map { |page| page.map { |row| row.map { |k, v| [k.to_sym, v] }.to_h } }
+  end
+
+  describe '#get, #set, #del' do
+    it 'should use passed in ID' do
+      id = 'marvel'
+      options = { prefix: TEST_PREFIX }
+
+      ::Airspace.set(client, data: data, id: id, pages: pages, options: options)
+
+      actual_reader = ::Airspace.get(client, id, options: options)
+      expect(actual_reader.data).to eq(data_hash)
+      expect(actual_reader.page_count).to eq(pages.length)
+
+      actual_pages = actual_reader.pages
+      expect(actual_pages).to eq(pages)
+
+      actual_page1 = actual_reader.page(1)
+      expect(actual_page1).to eq(pages[0])
+
+      actual_page2 = actual_reader.page(2)
+      expect(actual_page2).to eq(pages[1])
+
+      actual_page3 = actual_reader.page(3)
+      expect(actual_page3).to eq(pages[2])
+
+      deleted = ::Airspace.del(client, id, options: options)
+      expect(deleted).to be true
+
+      reader = ::Airspace.get(client, id, options: options)
+      expect(reader).to be nil
+    end
+
+    it 'should auto-assign ID' do
+      options = { prefix: TEST_PREFIX }
+      id = ::Airspace.set(client, data: data, pages: pages, options: options)
+
+      actual_reader = ::Airspace.get(client, id, options: options)
+      expect(actual_reader.data).to eq(data_hash)
+      expect(actual_reader.page_count).to eq(pages.length)
+
+      actual_pages = actual_reader.pages
+      expect(actual_pages).to eq(pages)
+
+      actual_page1 = actual_reader.page(1)
+      expect(actual_page1).to eq(pages[0])
+
+      actual_page2 = actual_reader.page(2)
+      expect(actual_page2).to eq(pages[1])
+
+      actual_page3 = actual_reader.page(3)
+      expect(actual_page3).to eq(pages[2])
+
+      deleted = ::Airspace.del(client, id, options: options)
+      expect(deleted).to be true
+
+      reader = ::Airspace.get(client, id, options: options)
+      expect(reader).to be nil
+    end
+
+    it 'should suppport custom serialization' do
+      options = {
+        prefix: TEST_PREFIX,
+        serializer: CustomSerializer.new
+      }
+
+      id = ::Airspace.set(client, data: data, pages: pages, options: options)
+
+      actual_reader = ::Airspace.get(client, id, options: options)
+      expect(actual_reader.data).to eq(data.map { |k, v| [k.to_sym, v] }.to_h)
+      expect(actual_reader.page_count).to eq(pages.length)
+
+      actual_pages = actual_reader.pages
+      expect(actual_pages).to eq(symbolized_pages)
+
+      actual_page1 = actual_reader.page(1)
+      expect(actual_page1).to eq(symbolized_pages[0])
+
+      actual_page2 = actual_reader.page(2)
+      expect(actual_page2).to eq(symbolized_pages[1])
+
+      actual_page3 = actual_reader.page(3)
+      expect(actual_page3).to eq(symbolized_pages[2])
+
+      deleted = ::Airspace.del(client, id, options: options)
+      expect(deleted).to be true
+
+      reader = ::Airspace.get(client, id, options: options)
+      expect(reader).to be nil
+    end
+  end
+end

data/spec/airspace/chunker_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './spec/spec_helper'
+
+describe ::Airspace::Chunker do
+  subject { ::Airspace::Chunker }
+
+  describe 'initialization' do
+    it 'should raise ArgumentError with a negative pages_per_chunk' do
+      expect { subject.new(-1) }.to raise_error(ArgumentError)
+    end
+
+    it 'should raise ArgumentError with a zero pages_per_chunk' do
+      expect { subject.new(0) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#count with pages_per_chunk = 5' do
+    it { expect(subject.new(5).count(0)).to eq(0) }
+    it { expect(subject.new(5).count(1)).to eq(1) }
+    it { expect(subject.new(5).count(2)).to eq(1) }
+    it { expect(subject.new(5).count(3)).to eq(1) }
+    it { expect(subject.new(5).count(4)).to eq(1) }
+    it { expect(subject.new(5).count(5)).to eq(1) }
+    it { expect(subject.new(5).count(6)).to eq(2) }
+  end
+
+  describe '#count with pages_per_chunk = 1' do
+    let(:pages_per_chunk) { 1 }
+    it { expect(subject.new(pages_per_chunk).count(0)).to eq(0) }
+    it { expect(subject.new(pages_per_chunk).count(1)).to eq(1) }
+    it { expect(subject.new(pages_per_chunk).count(2)).to eq(2) }
+    it { expect(subject.new(pages_per_chunk).count(3)).to eq(3) }
+    it { expect(subject.new(pages_per_chunk).count(4)).to eq(4) }
+    it { expect(subject.new(pages_per_chunk).count(5)).to eq(5) }
+    it { expect(subject.new(pages_per_chunk).count(6)).to eq(6) }
+  end
+
+  describe '#count with pages_per_chunk = 9' do
+    let(:pages_per_chunk) { 9 }
+    it { expect(subject.new(pages_per_chunk).count(0)).to eq(0) }
+    it { expect(subject.new(pages_per_chunk).count(1)).to eq(1) }
+    it { expect(subject.new(pages_per_chunk).count(2)).to eq(1) }
+    it { expect(subject.new(pages_per_chunk).count(3)).to eq(1) }
+    it { expect(subject.new(pages_per_chunk).count(4)).to eq(1) }
+    it { expect(subject.new(pages_per_chunk).count(5)).to eq(1) }
+    it { expect(subject.new(pages_per_chunk).count(6)).to eq(1) }
+  end
+
+  it '#each with page_size = 0' do
+    chunker = subject.new(5)
+
+    actual = chunker.each(0).with_object([]) { |chunk, array| array << chunk }
+
+    expected = []
+
+    expect(actual).to eq(expected)
+  end
+
+  it '#each with page_size = 6' do
+    chunker = subject.new(5)
+
+    actual = chunker.each(6).with_object([]) { |chunk, array| array << chunk }
+
+    expected = [
+      ::Airspace::Chunker::Chunk.new(0, 0, 4),
+      ::Airspace::Chunker::Chunk.new(1, 5, 9)
+    ]
+
+    expect(actual).to eq(expected)
+  end
+
+  it '#each with page_size = 13' do
+    chunker = subject.new(5)
+
+    actual = chunker.each(13).with_object([]) { |chunk, array| array << chunk }
+
+    expected = [
+      ::Airspace::Chunker::Chunk.new(0, 0, 4),
+      ::Airspace::Chunker::Chunk.new(1, 5, 9),
+      ::Airspace::Chunker::Chunk.new(2, 10, 14)
+    ]
+
+    expect(actual).to eq(expected)
+  end
+
+  describe '.locate' do
+    it { expect(subject.new(5).locate(0)).to eq(::Airspace::Chunker::Location.new(0, 0)) }
+    it { expect(subject.new(5).locate(1)).to eq(::Airspace::Chunker::Location.new(0, 1)) }
+    it { expect(subject.new(5).locate(2)).to eq(::Airspace::Chunker::Location.new(0, 2)) }
+    it { expect(subject.new(5).locate(3)).to eq(::Airspace::Chunker::Location.new(0, 3)) }
+    it { expect(subject.new(5).locate(4)).to eq(::Airspace::Chunker::Location.new(0, 4)) }
+    it { expect(subject.new(5).locate(5)).to eq(::Airspace::Chunker::Location.new(1, 0)) }
+    it { expect(subject.new(5).locate(6)).to eq(::Airspace::Chunker::Location.new(1, 1)) }
+
+    it 'should raise ArgumentError with a negative pages_per_chunk' do
+      expect { subject.new(-1).locate(0) }.to raise_error(ArgumentError)
+    end
+
+    it 'should raise ArgumentError with a zero pages_per_chunk' do
+      expect { subject.new(0).locate(0) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/airspace/store_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './spec/spec_helper'
+
+# This is mainly to ensure CI has a proper Redis installation and instance.
+describe ::Airspace::Store do
+  let(:client) { Redis.new }
+
+  describe 'initialization' do
+    it 'should raise ArgumentError with a null client' do
+      expect { ::Airspace::Store.new(nil) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'database_cleaner'
+require 'simplecov'
+require 'simplecov-console'
+require 'redis'
+require 'pry'
+
+TEST_PREFIX = 'airspace_test'
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner[:redis].strategy = :truncation, { only: ['airspace_test:*'] }
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner[:redis].cleaning do
+      example.run
+    end
+  end
+end
+
+SimpleCov.formatter = SimpleCov::Formatter::Console
+SimpleCov.start
+
+require './lib/airspace'