relaxo 0.4.7 → 1.0.0

data/lib/relaxo/{json.rb → dataset.rb}

@@ -18,16 +18,43 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-# You can define `Relaxo::JSON` before loading Relaxo, and it will use this implementation without trying to load the default JSON implementation.
+require 'rugged'
 
-module Relaxo
-end
+require_relative 'directory'
 
-unless defined? Relaxo::JSON
-	unless defined? JSON
-		# Try to load a JSON implementation if it doesn't already exist:
-		require 'json'
+module Relaxo
+	class Dataset
+		def initialize(repository, tree)
+			@repository = repository
+			@tree = tree
+			
+			@directories = {}
+		end
+		
+		def read(path)
+			if entry = @tree.path(path) and entry[:type] == :blob and oid = entry[:oid]
+				@repository.read(oid)
+			end
+		rescue Rugged::TreeError
+			return nil
+		end
+		
+		alias [] read
+		
+		def exist?(path)
+			read(path) != nil
+		end
+		
+		def each(path = nil, &block)
+			return to_enum(:each, path) unless block_given?
+			
+			directory(path).each(&block)
+		end
+		
+		protected
+		
+		def directory(path = nil)
+			@directories[path] ||= Directory.new(@repository, @tree, path)
+		end
 	end
-	
-	Relaxo::JSON = JSON
 end

data/lib/relaxo/directory.rb

@@ -0,0 +1,97 @@
+# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require 'rugged'
+
+module Relaxo
+	class Directory
+		def initialize(repository, tree, path)
+			@repository = repository
+			@tree = tree
+			@path = path
+			
+			@entries = nil
+			@changes = {}
+		end
+		
+		def freeze
+			@changes.freeze
+			
+			super
+		end
+		
+		def entries
+			@entries ||= load_entries!
+		end
+		
+		def each(&block)
+			return to_enum(:each) unless block_given?
+			
+			entries.each do |entry|
+				entry[:object] ||= @repository.read(entry[:oid])
+				
+				yield entry[:name], entry[:object]
+			end
+		end
+		
+		def insert(entry)
+			_, _, name = entry[:name].rpartition('/')
+			
+			@changes[name] = entry
+			
+			# Blow away the cache:
+			@entries = nil
+		end
+		
+		def delete(entry)
+			_, _, name = entry[:name].rpartition('/')
+			
+			@changes[name] = nil
+			
+			# Blow away the cache:
+			@entries = nil
+		end
+		
+		private
+		
+		def fetch_tree(path = @path)
+			entry = @tree.path(path)
+			
+			Rugged::Tree.new(@repository, entry[:oid])
+		rescue Rugged::TreeError
+			return nil
+		end
+		
+		# Load the entries from the tree, applying any changes.
+		def load_entries!
+			entries = @changes.dup
+			
+			if tree = fetch_tree
+				tree.each_blob do |entry|
+					unless entries.key? entry[:name]
+						entries[entry[:name]] = entry
+					end
+				end
+			end
+			
+			return entries.values.compact.sort_by{|entry| entry[:name]}
+		end
+	end
+end

data/lib/relaxo/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Relaxo
-	VERSION = "0.4.7"
+	VERSION = "1.0.0"
 end

data/relaxo.gemspec

@@ -22,8 +22,7 @@ Gem::Specification.new do |spec|
 	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 	spec.require_paths = ["lib"]
 	
-	spec.add_dependency "json", "~> 1.8"
-	spec.add_dependency "rest-client"
+	spec.add_dependency "rugged"
 	
 	spec.add_development_dependency "rspec", "~> 3.4.0"
 	spec.add_development_dependency "bundler", "~> 1.3"

data/spec/relaxo/changeset_spec.rb

@@ -0,0 +1,39 @@
+
+require_relative 'test_records'
+
+RSpec.describe Relaxo::Changeset do
+	include_context "test records"
+	
+	it "should enumerate all documents including writes" do
+		records = []
+		
+		database.commit(message: "Testing Enumeration") do |dataset|
+			5.times do |i|
+				object = dataset.append("extra-#{i}")
+				dataset.write("#{prefix}/extra-#{i}", object)
+			end
+			
+			expect(dataset.exist?("#{prefix}/extra-0")).to be_truthy
+			
+			records = dataset.each(prefix).to_a
+		end
+		
+		expect(records.count).to be 25
+	end
+	
+	it "should enumerate all documents excluding deletes" do
+		records = []
+		
+		database.commit(message: "Testing Enumeration") do |dataset|
+			5.times do |i|
+				dataset.delete("#{prefix}/#{i}")
+			end
+			
+			expect(dataset.exist?("#{prefix}/0")).to be_falsey
+			
+			records = dataset.each(prefix).to_a
+		end
+		
+		expect(records.count).to be 15
+	end
+end

data/spec/relaxo/concurrency_spec.rb

@@ -0,0 +1,39 @@
+
+require_relative 'test_records'
+
+RSpec.describe Relaxo::Changeset do
+	include_context "test records"
+	
+	it "should detect conflicts" do
+		events = []
+		
+		alice = Fiber.new do
+			database.commit(message: "Alice Data") do |changeset|
+				events << :alice
+				
+				object = changeset.append("sample-data-1")
+				changeset.write("conflict-path", object)
+				
+				Fiber.yield
+			end
+		end
+		
+		bob = Fiber.new do
+			database.commit(message: "Bob Data") do |changeset|
+				events << :bob
+				
+				object = changeset.append("sample-data-1")
+				changeset.write("conflict-path", object)
+				
+				Fiber.yield
+			end
+		end
+		
+		alice.resume
+		bob.resume
+		alice.resume
+		bob.resume
+		
+		expect(events).to be == [:alice, :bob, :bob]
+	end
+end

data/spec/relaxo/database_spec.rb

@@ -1,52 +1,87 @@
-#!/usr/bin/env ruby
 
 require 'relaxo'
-require 'relaxo/attachments'
-
-require_relative 'spec_helper'
 
 RSpec.describe Relaxo::Database do
-	before :all do
-		@connection = Relaxo::Connection.new(TEST_DATABASE_HOST)
-		@database = Relaxo::Database.new(@connection, TEST_DATABASE_NAME)
+	let(:database_path) {File.join(__dir__, 'test')}
+	
+	let(:database) {Relaxo.connect(database_path, test_key: "test_value")}
+	
+	let(:document_path) {'test/document.json'}
+	let(:sample_json) {'[1, 2, 3]'}
+	
+	before(:each) {FileUtils.rm_rf(database_path)}
+	
+	it "should be initially empty" do
+		expect(database).to be_empty
+	end
+	
+	it "should not be empty with one document" do
+		database.commit(message: "Create test document") do |dataset|
+			oid = dataset.append(sample_json)
+			dataset.write(document_path, oid)
+		end
 		
-		if @database.exist?
-			@database.delete!
+		expect(database).to_not be_empty
+	end
+	
+	it "should have metadata" do
+		expect(database[:test_key]).to be == "test_value"
+	end
+	
+	it "should create a document" do
+		database.commit(message: "Create test document") do |dataset|
+			oid = dataset.append(sample_json)
+			dataset.write(document_path, oid)
 		end
 		
-		@database.create!
+		database.current do |dataset|
+			expect(dataset[document_path].data).to be == sample_json
+		end
 	end
 	
-	it "should connect and add a document" do
-		expect(@database.id?('foobar')).to be false
+	it "should erase a document" do
+		database.commit(message: "Create test document") do |dataset|
+			oid = dataset.append(sample_json)
+			dataset.write(document_path, oid)
+		end
 		
-		document = {'animal' => 'Cat', 'name' => 'Seifa'}
+		database.commit(message: "Delete test document") do |dataset|
+			dataset.delete(document_path)
+		end
 		
-		@database.save(document)
+		database.current do |dataset|
+			expect(dataset[document_path]).to be nil
+		end
+	end
+	
+	it "should create multiple documents" do
+		database.commit(message: "Create first document") do |dataset|
+			oid = dataset.append(sample_json)
+			dataset.write(document_path, oid)
+		end
 		
-		id = document[Relaxo::ID]
-		expect(@database.id?(id)).to be true
+		database.commit(message: "Create second document") do |dataset|
+			oid = dataset.append(sample_json)
+			dataset.write(document_path + '2', oid)
+		end
 		
-		copy = @database.get(id)
-		document.each do |key, value|
-			expect(copy[key]).to be == value
+		database.current do |dataset|
+			expect(dataset[document_path].data).to be == sample_json
+			expect(dataset[document_path + '2'].data).to be == sample_json
 		end
 	end
 	
-	it "should save an attachment" do
-		document = {
-			Relaxo::ATTACHMENTS => {
-				"foo.txt" => {
-					"content_type" => "text\/plain",
-					"data" => "VGhpcyBpcyBhIGJhc2U2NCBlbmNvZGVkIHRleHQ="
-				}
-			}
-		}
-		
-		result = @database.save(document)
-		expect(result['ok']).to be true
+	it "can enumerate documents" do
+		database.commit(message: "Create first document") do |dataset|
+			oid = dataset.append(sample_json)
+			
+			10.times do |id|
+				dataset.write(document_path + "-#{id}", oid)
+			end
+		end
 		
-		document = @database.get(document[Relaxo::ID])
-		expect(document[Relaxo::ATTACHMENTS].size).to be == 1
+		database.current do |dataset|
+			expect(dataset.each('test').count).to be == 10
+		end
 	end
 end

data/spec/relaxo/enumeration_spec.rb

@@ -0,0 +1,30 @@
+
+require_relative 'test_records'
+
+RSpec.describe Relaxo::Dataset do
+	include_context "test records"
+	
+	it "should enumerate all documents" do
+		records = []
+		
+		database.current do |dataset|
+			records = dataset.each(prefix).to_a
+		end
+		
+		expect(records.count).to be 20
+	end
+end
+
+RSpec.describe Relaxo::Changeset do
+	include_context "test records"
+	
+	it "should enumerate all documents" do
+		records = []
+		
+		database.commit(message: "Testing Enumeration") do |dataset|
+			records = dataset.each(prefix).to_a
+		end
+		
+		expect(records.count).to be 20
+	end
+end

data/spec/relaxo/performance_spec.rb

@@ -0,0 +1,78 @@
+
+require 'benchmark/ips' if ENV['BENCHMARK']
+require 'ruby-prof' if ENV['PROFILE']
+require 'flamegraph' if ENV['FLAMEGRAPH']
+
+RSpec.describe "Relaxo Performance" do
+	let(:database_path) {File.join(__dir__, 'test')}
+	let(:database) {Relaxo.connect(database_path)}
+	
+	if defined? Benchmark
+		def benchmark(name = nil)
+			Benchmark.ips do |benchmark|
+				# Collect more data for benchmark:
+				benchmark.time = 20
+				benchmark.warmup = 10
+				
+				benchmark.report(name) do |i|
+					yield i
+				end
+				
+				benchmark.compare!
+			end
+		end
+	elsif defined? RubyProf
+		def benchmark(name)
+			result = RubyProf.profile do
+				yield 1000
+			end
+			
+			#result.eliminate_methods!([/^((?!Utopia).)*$/])
+			printer = RubyProf::FlatPrinter.new(result)
+			printer.print($stderr, min_percent: 1.0)
+			
+			printer = RubyProf::GraphHtmlPrinter.new(result)
+			filename = name.gsub('/', '_') + '.html'
+			File.open(filename, "w") do |file|
+				printer.print(file)
+			end
+		end
+	elsif defined? Flamegraph
+		def benchmark(name)
+			filename = name.gsub('/', '_') + '.html'
+			Flamegraph.generate(filename) do
+				yield 1
+			end
+		end
+	else
+		def benchmark(name)
+			yield 1
+		end
+	end
+	
+	before(:each) do
+		FileUtils.rm_rf(database_path)
+	end
+	
+	it "single transaction should be fast" do
+		benchmark("single") do |iterations|
+			database.commit(message: "Some Documents") do |dataset|
+				iterations.times do |i|
+					object = dataset.append("good-#{i}")
+					dataset.write("#{i%100}/#{i}", object)
+				end
+			end
+		end
+	end
+	
+	it "multiple transactions should be fast" do
+		benchmark("multiple") do |iterations|
+			iterations.times do |i|
+				database.commit(message: "Some Documents") do |dataset|
+					object = dataset.append("good-#{i}")
+					dataset.write("#{i%100}/#{i}", object)
+				end
+			end
+		end
+	end
+end