s3db 0.0.0

data/lib/s3db/record.rb

@@ -0,0 +1,195 @@
+module S3DB
+  module Record
+    attr_accessor :data
+
+    module ClassMethods
+      attr_accessor :_database, :_collection, :_schema, :_id_generator, :_id_field
+
+      # Set the database to use for the record.
+      #
+      # database  - S3DB::Database instance. Required.
+      #
+      # Returns the database instance.
+      def database(database)
+        self._database = database
+      end
+
+      # Set the collection to a new collection with the passed name.
+      #
+      # name  - String name of the collection. Required.
+      #
+      # returns the newly created S3DB::Collection.
+      def collection_name(name)
+        self._collection = S3DB::Collection.create(_database, name)
+      end
+
+      # Set the id generator for new records.
+      #
+      # proc  - Proc to call, returning the id field. Required.
+      #
+      # returns the Proc instance.
+      def id_generator(proc)
+        self._id_generator = proc
+      end
+
+      # Set the field to use for the id. It will be passed to the id_generator
+      # proc.
+      #
+      # id_field  - String name of field. Required.
+      #
+      # returns the id_field.
+      def id_field(key)
+        self._id_field = key.to_s
+      end
+
+      # Set a field on the record to validate as a string.
+      #
+      # key   - String name of key. Required.
+      #
+      # returns the schema.
+      def string(key)
+        schema = instance_variable_get(:@_schema) || {}
+        schema[key.to_s] = 'String'
+        instance_variable_set(:@_schema, schema)
+      end
+
+      # Locate all records in the collection.
+      #
+      # returns the output from S3DB::Collection#list_records.
+      def all
+        instance_variable_get(:@_collection).list_records.map do |rec|
+          new(JSON.parse(rec))
+        end
+      end
+
+      # Locate a single record from the collection by filename.
+      #
+      # filename  - String filename to return. Required.
+      #
+      # returns the record on success; raises an error on failure.
+      def find(filename)
+        record = new(_id: filename)
+        res = _database.backend.read_record(_database.name, _collection.name, record.__send__(:_filename))
+
+        raise ArgumentError, 'missing record!' unless res
+
+        new(JSON.parse(res))
+      end
+
+      # Create a new record, and write it to disk.
+      #
+      # data  - Hash data for the record.
+      #
+      # returns an instance of the record.
+      def create(data)
+        record = new(data)
+        record.__send__(:_set_id)
+        record.save
+      end
+    end
+
+    # Instantiate a new record.
+    #
+    # data  - Hash of data. Required.
+    #
+    # returns a new instance of the record.
+    def initialize(data)
+      hash = {}
+      data.each_pair do |k,v|
+        hash[k.to_s] = v
+      end
+
+      @data = hash
+    end
+
+    def new_record?
+      _id.nil?
+    end
+
+    # Save an instantiated record.
+    #
+    # returns the record on success or failure.
+    def save
+      _set_id
+
+      return false if _id.nil?
+
+      self.class._database.backend.write_record(
+        self.class._database.name,
+        self.class._collection.name,
+        _filename,
+        @data.to_json
+      )
+
+      self
+    end
+
+    # Save an instantiated record, raising an error on failure.
+    #
+    # returns the record on success; raises an error on failure.
+    def save!
+      save || raise(ArgumentError, 'failed to save!')
+    end
+
+    # Update the data for a record and save.
+    #
+    # data  - Hash of data for the record. Required.
+    #
+    # returns #save.
+    def update(data)
+      return false if _id.nil?
+
+      # Copy the existing id to the new data, if it exists.
+      data.merge('_id' => _id)
+
+      # Update the dataset
+      @data = data
+
+      save
+    end
+
+    def _id=(id)
+      @data['_id'] = id
+    end
+
+    def _id
+      @data['_id']
+    end
+
+    # TODO: implement a missing method method for getter/setters
+
+    private
+
+    def _filename
+      '%s.json' % [_id]
+    end
+
+    def _set_id
+      return _id if !_id.nil?
+
+      if self.class._id_generator.nil? || self.class._id_field.nil?
+        self._id = UUIDTools::UUID.random_create.to_s
+      else
+        self._id = self.class._id_generator.call(@data[self.class._id_field])
+      end
+
+      _id
+    end
+
+    def _valid?
+      return false unless @data.keys.map(&:to_s).sort == self.class._schema.keys.map(&:to_s).sort
+
+      @data.each_pair do |key, value|
+        return false unless value.class.to_s == self.class._schema[key.to_s]
+      end
+
+      true
+    end
+
+    # When included, extend the class methods of the host class
+    def self.included(host_class)
+      host_class.extend(ClassMethods)
+    end
+  end
+end
+

data/lib/s3db/utils.rb

@@ -0,0 +1,11 @@
+module S3DB
+  class Utils
+    class << self
+      def sanitize(input)
+        raise ArgumentError, 'invalid input!' unless input =~ /^\w+$/i
+
+        input.to_s
+      end
+    end
+  end
+end

data/s3db.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+files = ['./s3db.gemspec']
+files << './lib/s3db.rb'
+
+# Gemfile
+files << 'Gemfile'
+files << 'Gemfile.lock'
+
+
+Gem::Specification.new do |gem|
+  gem.name          = "s3db"
+  gem.version       = '0.0.0'
+  gem.authors       = ["Jack Brown"]
+  gem.email         = ["jack@brownjohnf.com"]
+  gem.description   = "S3-backed storage engine"
+  gem.summary       = "Leverage the endless cheap capacity of s3 for high-latency storage"
+  gem.homepage      = "https://github.com/brownjohnf/s3db"
+
+  gem.files         = files
+  # Library files
+  gem.files         << Dir.glob(File.join('lib', '**', '*.rb'))
+  # Spec files
+  gem.files         << Dir.glob(File.join('spec', '**', '*.rb'))
+  # Examples
+  gem.files         << Dir.glob(File.join('examples', '**', '*.rb'))
+  gem.executables   << 's3db'
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'uuidtools', '~> 2.1', '>= 2.1.5'
+  gem.add_dependency 'json', '~> 1.8', '>= 1.8.3'
+
+  gem.add_development_dependency 'guard-rspec', '~> 4.6', '>= 4.6.4'
+  gem.add_development_dependency 'rspec',       '~> 3.3', '>= 3.3.0'
+  gem.add_development_dependency 'simplecov',   '~> 0.10', '>= 0.10.0'
+
+  gem.license = "MIT"
+end
+

data/spec/lib/s3db/collection_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+RSpec.describe S3DB::Collection do
+  before :each do
+    S3DB::FileBackend.delete(TEST_DB_BASE_PATH)
+    @backend = S3DB::FileBackend.create(TEST_DB_BASE_PATH)
+    @database = S3DB::Database.create(@backend, 'testdb')
+  end
+
+  after :each do
+    S3DB::FileBackend.delete(TEST_DB_BASE_PATH)
+  end
+
+  describe '::create' do
+    it 'calls #initialize and #save' do
+      expect(S3DB::Collection).to \
+        receive(:new).with(@database, 'testcoll').and_call_original
+      expect_any_instance_of(S3DB::Collection).to receive(:save)
+      expect(S3DB::Collection.create(@database, 'testcoll')).to \
+        be_a(S3DB::Collection)
+    end
+  end
+
+  describe 'instance methods' do
+    let(:coll_name) { 'testcoll' }
+    let(:schema) do
+      {
+        'id' => 'String'
+      }
+    end
+
+    subject do
+      S3DB::Collection.new(@database, coll_name)
+    end
+
+    it 'responds to accessors/readers' do
+      expect(subject).to respond_to(:name)
+      expect(subject).to respond_to(:database)
+    end
+
+    describe '#initialize' do
+      it 'sets @database' do
+        expect(subject.instance_variable_get(:@database)).to eq(@database)
+        expect(subject.database).to eq(@database)
+      end
+
+      it 'sets @name' do
+        expect(subject.instance_variable_get(:@name)).to eq(coll_name)
+        expect(subject.name).to eq(coll_name)
+      end
+
+      it 'accepts a block and yields itself' do
+        subject
+
+        S3DB::Collection.new(@database, coll_name) do |collection|
+          expect(collection.class).to eq S3DB::Collection
+        end
+      end
+
+      it 'accepts an optional block' do
+        expect(S3DB::Collection.new(@database, coll_name)).to \
+          be_a(S3DB::Collection)
+      end
+
+      it 'validates itself' do
+        expect_any_instance_of(S3DB::Collection).to receive(:validate!)
+
+        S3DB::Collection.new(@database, coll_name)
+      end
+    end
+
+    describe '#validate!' do
+      it 'checks the db and raises an error' do
+        expect do
+          S3DB::Collection.new('database', coll_name)
+        end.to raise_error ArgumentError, 'database must be an S3DB::Database!'
+
+        expect do
+          S3DB::Collection.new(@database, coll_name)
+        end.to_not raise_error
+      end
+
+      it 'checks the name and raises an error' do
+        subject.instance_variable_set(:@name, 1)
+        expect do
+          subject.validate!
+        end.to raise_error ArgumentError, 'name must be a String!'
+      end
+    end
+  end
+end

data/spec/lib/s3db/database_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+RSpec.describe S3DB::Database do
+  before :each do
+    S3DB::FileBackend.delete(TEST_DB_BASE_PATH)
+    @backend = S3DB::FileBackend.create(TEST_DB_BASE_PATH)
+  end
+
+  after :each do
+    S3DB::FileBackend.delete(TEST_DB_BASE_PATH)
+  end
+
+  describe '::create' do
+    it 'writes a new db' do
+      expect(@backend).to receive(:write_db).and_call_original
+
+      S3DB::Database.create(@backend, 'test')
+    end
+
+    it 'returns a db' do
+      expect(S3DB::Database.create(@backend, 'test')).to be_a(S3DB::Database)
+    end
+  end
+
+  describe '::drop' do
+    before :each do
+      S3DB::Database.create(@backend, 'test')
+    end
+
+    it 'calls delete_db on the backend' do
+      expect(@backend).to receive(:delete_db).and_call_original
+
+      S3DB::Database.drop(@backend, 'test')
+    end
+
+    it 'does not raise an error on a non-existent db' do
+      S3DB::Database.drop(@backend, 'test')
+
+      expect do
+        S3DB::Database.drop(@backend, 'test')
+      end.to_not raise_error
+    end
+  end
+
+  context 'instance methods' do
+    let(:dbname) { 'test' }
+
+    subject do
+      S3DB::Database.create(@backend, dbname)
+    end
+
+    describe '#initialize' do
+      it 'sets the name' do
+        expect(subject.instance_variable_get(:@name)).to eq(dbname)
+      end
+
+      it 'sets the database' do
+        expect(subject.instance_variable_get(:@database)).to eq(@database)
+      end
+
+      it 'accepts a block and yields itself' do
+        subject
+
+        S3DB::Database.new(subject.backend, subject.name) do |db|
+          expect(db.class).to eq S3DB::Database
+        end
+      end
+
+      it 'accepts an optional block' do
+        expect(S3DB::Database.new(subject.backend, subject.name)).to \
+          be_a(S3DB::Database)
+      end
+    end
+
+    describe '#save' do
+      it 'writes the db to disk' do
+        expect(@backend).to receive(:write_db).with(subject.name)
+        expect(subject.save).to eq(subject)
+      end
+    end
+
+    describe '#show_collections' do
+      it 'calls backend.list_collections with the db name' do
+        expect(@backend).to \
+          receive(:list_collections).with(dbname).and_return([])
+
+        subject.show_collections
+      end
+
+      it 'returns an array of strings' do
+        subject.create_collection('testcollection')
+
+        expect(subject.show_collections).to eq %w{testcollection}
+      end
+
+      it 'sorts the collections' do
+        array = %w{a b c}
+        allow(@backend).to receive(:list_collections).and_return(array)
+
+        expect(subject.show_collections).to eq array
+      end
+    end
+
+    describe '#create_collection' do
+      it 'calls collection::create' do
+        expect(S3DB::Collection).to \
+          receive(:create).with(subject, 'testcollection')
+
+        subject.create_collection('testcollection')
+      end
+    end
+
+    describe '#drop_collection' do
+      it 'calls backend.delete_collection' do
+        expect(@backend).to \
+          receive(:delete_collection).with(dbname, 'testcollection').and_call_original
+
+        subject.drop_collection('testcollection')
+      end
+    end
+
+    describe '#path' do
+      it 'calls backend.db_path' do
+        subject # needed to setup initial calls to db_path
+
+        expect(@backend).to \
+          receive(:db_path).with('test').and_call_original
+
+        expect(subject.path).to eq TEST_DB_BASE_PATH + '/' + dbname
+      end
+    end
+
+    describe 'private #valid?' do
+      it 'returns true if backend.valid_db? is true' do
+        allow(@backend).to receive(:db_exist?).and_return(true)
+
+        expect(subject.__send__(:valid?)).to be true
+      end
+    end
+  end
+end