rudb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0d0953b3633a41451309300ae686f6a33257dff864c996c85b852475e5f7b7d7
+  data.tar.gz: 87017f8c90398f9f47c99385b671fbb365b47b09a61b8f774aeb57190a0aba62
+SHA512:
+  metadata.gz: e1459916d56817268764af91728bab8d9bb3f2eedab4b0b62cea19aed47e7b5accc75df8a13acf2064dd0f95b2ae00bc61b7c58340eb60679b6ac2e5792c0d1e
+  data.tar.gz: 65e881d04a43ece48dfd4812bf05f3279af6a2e48be47e472c1ca32f8eb6537db12b3ffe1da8d2fc0d7178bec075a6713b64f7bbae261d442614fee669ff5269

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in rdb.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    rudb (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  rake (~> 10.0)
+  rudb!
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Rustam Galeev
+
+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,69 @@
+# Rustik db XD
+
+Rustik DB is a Ruby implementation of simple files database, with Btree indexes.
+Btree is described in Introduction to Algorithms by Cormen, Leiserson, Rivest and Stein, Chapter 18.
+It's bundled with the `ORM mapper` which behaves like a Rails `find_by` and `save` methods on your classes.
+Please note, this gem is not purposed for production use, the only reason I've written it is to demonstrate how to write your own database, and use it with your own data mapper, like `ActiveRecord`.
+
+
+##Features
+
+- Create Btree of arbitrary degree (4 by default)
+- Insert and search by object attributes, like Rails framework does
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rdb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rdb
+
+## Usage
+
+```
+
+require_relative 'rdb'
+require_relative 'rdb/orm'
+
+class Plane
+  include Rdb::Orm
+  rdb_mount 'planes', {id: Integer, code: String, weight: Integer}, {id: Rdb::Indexes::Btree}, '/home/rustam/rdata'
+end
+
+names = %w(rose velvet pink blue charley delta bravo)
+
+300000.times do |x|
+  code = "%s%d%s" % [names.sample, rand(1000), names.sample]
+  Plane.create(code: code, weight: rand(1000))
+end
+
+Plane.find_by(id: 1123)
+
+x = Plane.new
+x.code = "superjet3000"
+x.weight = 2572
+x.save
+
+Plane.find_by(id: x.id)
+
+```
+
+## To Do
+
+The features in development are:
+
+- Hash index
+- Multiple indexes
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/lib/rdb.rb

@@ -0,0 +1,35 @@
+# Top level namespace Rdb
+require 'logger'
+
+module Rdb
+
+  ### alias for Collection#open
+  def self::open *args
+    Rdb::Collection.new *args
+  end
+
+  def self::logger
+    @logger ||= default_logger
+  end
+
+  class << self
+    attr_writer :logger
+  end  
+
+  private
+
+  def self.default_logger
+    logger = Logger.new(STDERR)
+    logger.level = Logger::ERROR
+    logger
+  end  
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rdb/storage_engine'
+require 'rdb/index'
+require 'rdb/document'
+require 'rdb/collection'
+require 'rdb/error'
+require 'rdb/version'

data/lib/rdb/collection.rb

@@ -0,0 +1,72 @@
+# the collection of documents
+module Rdb
+  class Collection
+
+    attr_accessor :name, :fields, :indexes, :path_to_database
+
+    PRIMARY_INDEX_NAME = :id
+    PRIMARY_INDEX_START_VAL = 0
+
+    # initialize collection with given attributes:
+    # @param name
+    # @param fields {id: Integer, name: String}
+    # @param indexes {id: Rdb::Indexes::Btree, name: Rdb::Indexes::Hash}
+    def initialize *args
+      @name = args.first[:name]
+      @fields = args.first[:fields]
+      @indexes = args.first[:indexes]
+      @path_to_database = args.first[:path_to_database]
+      setup_dirs
+    end
+
+    # insert document into collection
+    def << attrs
+    	primary_index_id = get_last_id(PRIMARY_INDEX_NAME) + 1
+      document = Rdb::Document.new attrs.merge(PRIMARY_INDEX_NAME => primary_index_id), {
+        fields: fields, 
+        indexes: indexes, 
+        collection_name: name, 
+        path_to_database: path_to_database,
+        last_id: primary_index_id}
+      raise ::Error, "Not a Document type" unless document.is_a? Rdb::Document
+      transaction do 
+        document.store!
+      end
+    end
+    alias_method :insert, :<<
+
+    # fetch document from collection
+    def [] key, value
+      index = indexes[key].new(key, {}, 
+          collection_name: name, 
+          path_to_database: path_to_database)
+      index.search value
+    end
+    alias_method :select, :[]
+
+    protected
+
+    # for future atomicity
+    def transaction
+    	yield if block_given?
+    end
+
+    def get_last_id index_name
+      Rdb::Indexes::Btree.get_last_id(File.join(path_to_database, name, index_name.to_s)) || PRIMARY_INDEX_START_VAL
+    end
+
+    def setup_dirs
+    	raise ::Error, "Database dir not found" unless Dir.exist? path_to_database
+    	paths = []
+    	path_to_collection = File.join(path_to_database, name)
+      paths << path_to_collection unless Dir.exist? path_to_collection
+    	indexes.keys.each do |index_name|
+    		path_to_index = File.join(path_to_database, name, index_name.to_s)
+      	paths << path_to_index unless Dir.exist? path_to_index
+      end
+
+      paths.each { |path| Dir.mkdir(path, 0700) }
+    end
+  end
+end
+

data/lib/rdb/document.rb

@@ -0,0 +1,27 @@
+# the set of attributes
+module Rdb
+  class Document
+
+    attr_accessor :attributes, :fields, :indexes, :collection_name, :path_to_database#, :last_id
+
+    def initialize attrs, options = {}
+      @attributes = attrs
+      @fields = options[:fields]
+      @indexes = options[:indexes]
+      @collection_name = options[:collection_name]
+      @path_to_database = options[:path_to_database]
+    end
+
+    def store!
+      indexes.inject({}) do |result, index_hash|
+        field_name, index_class = index_hash.flatten
+        index = index_class.new field_name, attributes, 
+          collection_name: collection_name, 
+          path_to_database: path_to_database
+
+        result[field_name] = index.create!
+        result
+      end
+    end
+  end
+end

data/lib/rdb/error.rb

@@ -0,0 +1,4 @@
+module Rdb
+  class Error < StandardError
+  end
+end

data/lib/rdb/index.rb

@@ -0,0 +1,11 @@
+# the index interface
+module Rdb
+  class Index
+    def create!
+      false
+    end
+  end
+end
+
+require 'rdb/indexes/btree'
+require 'rdb/indexes/hash'

data/lib/rdb/indexes/btree.rb

@@ -0,0 +1,235 @@
+require 'fileutils'
+
+module Rdb
+  module Indexes
+    class Btree < Rdb::Index
+
+      attr_accessor :key, :attributes, :collection_name, :min_degree, :path_to_database
+
+      def initialize key, attributes, opts
+        @key = key
+        @attributes = attributes
+        @collection_name = opts[:collection_name]
+        @path_to_database = opts[:path_to_database]
+        @min_degree = 4
+        Rdb.logger.info "Btree#initialize: key %s val %s path %s" % [@key.to_s, @attributes[@key], path_to_index]
+      end
+
+      def create!
+        insert!
+      end
+
+      def insert!
+        root_node = Node.new min_degree, path_to_index, attributes, true
+        if root_node.full?
+          Rdb.logger.debug "Btree#insert! root node full"
+          new_root_node = Node.new min_degree, path_to_index, attributes, true
+          root_node.move_to! new_root_node
+          new_root_node.split_child 0, root_node
+          index = 0
+          Rdb.logger.debug "Btree#insert! attributes[key] %s" % attributes[key].to_s
+          Rdb.logger.debug "Btree#insert! new root node keys %s" % new_root_node.keys.join(' ')
+          if new_root_node.keys[0] < attributes[key]
+            index += 1
+          end
+          Rdb.logger.debug "Btree#insert! index for new el %d" % index
+          Rdb.logger.debug "Btree#insert! new root node children %s" % new_root_node.children_paths(true).join(' ')
+          child_node = new_root_node.children[index]
+          child_node.data = attributes
+          child_node.insert_non_full attributes[key]
+        else
+          Rdb.logger.debug "Btree#insert! insert into root node"
+          root_node.insert_non_full attributes[key]
+        end
+        attributes[key]
+      end
+
+      def search key
+        root_node = Node.new min_degree, path_to_index, attributes, true
+        root_node.search key
+      end
+
+      def path_to_index
+        File.join(path_to_database, collection_name, key.to_s)
+      end
+
+      def self::get_last_id path
+        return unless Dir.exist? path
+        children_and_keys = Dir.children(path)
+        children = children_and_keys.select { |fname| File.directory?(File.join(path, fname))}.collect(&:to_i).sort
+        if children.size > 0
+          get_last_id(File.join(path, children.last.to_s))
+        else
+          children_and_keys.select { |fname| fname.include? 'data_'}.
+            collect { |fname| fname.match(/\d+/)[0].to_i}.compact.max.to_i
+        end
+      end
+
+      class Node
+
+        attr_accessor :t, :path_to_node, :data, :is_root
+
+        def initialize t, path_to_node, data = nil, is_root = false
+          @path_to_node = path_to_node
+          @t = t
+          @data = data
+          @is_root = is_root
+          setup_dirs
+        end
+
+        def search key
+          index = 0
+          while index < num_of_keys && key > keys[index]
+            index += 1
+          end
+
+          if key == keys[index] 
+            return Rdb::StorageEngines::Json.new({}, File.join(path_to_node,"data_#{key}.json")).read
+          end
+
+          return nil if is_leaf?
+          children[index].search key
+        end
+
+        def insert key, index
+          fname = File.join(path_to_node, "data_#{key}.json")
+          Rdb::StorageEngines::Json.new(data, fname).store!
+        end
+
+        def insert_non_full key
+          Rdb.logger.debug "Btree#insert_non_full key %s" % key.to_s
+          Rdb.logger.debug "Btree#insert_non_full all keys: %s" % keys.join(' ')
+          index = num_of_keys - 1
+          if is_leaf?
+            while index >= 0 && keys[index] > key do
+              index -= 1
+            end
+            insert key, index
+          else
+            while index >= 0 && keys[index] > key do
+              index -= 1
+            end
+            child_path = children_paths[index + 1]
+            child_node = Node.new t, child_path, data
+            Rdb.logger.debug "Btree#insert_non_full selected child node %s" % child_path
+            if child_node.num_of_keys == 2*t - 1
+              Rdb.logger.debug "Btree#insert_non_full going to split child node"
+              split_child index + 1, child_node
+              Rdb.logger.debug "Btree#insert_non_full keys %s index %d" % [keys.join(' '), index]
+              if keys[index + 1] < key
+                index += 1
+              end
+              child_path = children_paths(true)[index + 1]
+              child_node = Node.new t, child_path, data
+            end
+            child_node.insert_non_full key
+          end
+        end
+
+        def split_child index, child_node
+          Rdb.logger.debug "Btree#split_child index %d" % index
+          Rdb.logger.debug "Btree#split_child child to split path %s" % child_node.path_to_node
+          new_child_path = File.join(path_to_node, (index + 1).to_s)
+          Rdb.logger.debug "Btree#split_child new child path %s" % new_child_path
+          new_child = Node.new t, new_child_path, data
+          Rdb.logger.debug "Btree#split_child child node keys %s" % child_node.keys.join(' ')
+          child_node.keys.last(t - 1).each do |child_key|
+            unless File.join(child_node.path_to_node, "data_%d.json" % child_key) == File.join(new_child.path_to_node, "data_%d.json" % child_key)
+              Rdb.logger.debug "Btree#split_child move keys from " + File.join(child_node.path_to_node, "data_%d.json" % child_key) + " to " +
+                File.join(new_child.path_to_node, "data_%d.json" % child_key)
+              FileUtils.mv File.join(child_node.path_to_node, "data_%d.json" % child_key),
+                File.join(new_child.path_to_node, "data_%d.json" % child_key)
+            else
+                Rdb.logger.debug "Btree#split_child move keys same path, skipped " + File.join(child_node.path_to_node, "data_%d.json" % child_key) + " to " +
+                File.join(new_child.path_to_node, "data_%d.json" % child_key)
+            end
+          end
+
+          Rdb.logger.debug "Btree#split_child going to move children to %s" % new_child_path
+          Rdb.logger.debug "Btree#split_child %s" % child_node.children(true).map(&:path_to_node).join(' ')
+          Rdb.logger.debug "Btree#split_child last t of them %d" % t
+            child_node.children(true).last(t).each do |child|
+              child.move_to! new_child
+            end
+
+          child_key = child_node.keys[t - 1]
+          unless child_node.path_to_node == path_to_node
+            Rdb.logger.debug "Btree#split_child finaly move from " + File.join(child_node.path_to_node, "data_%d.json" % child_key) + " to " + 
+              File.join(path_to_node, "data_%d.json" % child_key)
+            FileUtils.mv File.join(child_node.path_to_node, "data_%d.json" % child_key),
+                  File.join(path_to_node, "data_%d.json" % child_key)
+          else
+            Rdb.logger.debug "Btree#split_child finaly skipped same from " + File.join(child_node.path_to_node, "data_%d.json" % child_key) + " to " + 
+              File.join(path_to_node, "data_%d.json" % child_key)
+          end
+
+        end
+
+        def children reload = true
+          Rdb.logger.debug "Btree#children init"
+          return @children if defined?(@children) && !reload
+          @children = children_paths(reload).collect { |path| Node.new(t, path)}
+        end
+
+        def children_paths reload = false
+          return @children_paths if defined?(@children_paths) && !reload
+          @children_paths = Dir.children(path_to_node).select { |fname| File.directory?(File.join(path_to_node, fname))}.sort_by(&:to_i).
+            collect { |fname| File.join(path_to_node, fname)}
+        end
+
+        def next_child_id
+          is_leaf? ? 1 : children_paths.last.to_i + 1
+        end
+
+        def move_to! node
+          next_child_id = (node.is_root || node.is_leaf?) ? 0 : node.children_paths.size
+          Rdb.logger.debug "Btree#move_to! next child id children lookup %s " % node.children_paths.join(' ')
+          path_to_child_tmp = File.join(node.path_to_node, next_child_id.to_s + ".tmp")
+          path_to_child = File.join(node.path_to_node, next_child_id.to_s)
+          Rdb.logger.debug "Btree#move_to! of %s to %s" % [path_to_node, path_to_child]
+          Dir.mkdir(path_to_child_tmp, 0700) unless Dir.exist? path_to_child_tmp
+          Rdb.logger.debug "Btree#move_to! move all children and keys to new dir"
+          keys.each do |child_key|
+            Rdb.logger.debug "Btree#move_to! move keys from " + File.join(path_to_node, "data_%d.json" % child_key) + " to " +
+              File.join(path_to_child_tmp, "data_%d.json" % child_key)
+            FileUtils.mv File.join(path_to_node, "data_%d.json" % child_key),
+              File.join(path_to_child_tmp, "data_%d.json" % child_key)
+          end
+          children_paths.each do |child_path|
+            Rdb.logger.debug "Btree#move_to! move child from " + child_path + " to " + 
+              path_to_child_tmp
+            FileUtils.mv child_path,
+              path_to_child_tmp
+          end
+          FileUtils.mv path_to_child_tmp, path_to_child
+          Dir.rmdir(path_to_node) rescue nil
+          Rdb.logger.debug "Btree#move_to! set path_to_node %s" % path_to_child
+          self.path_to_node = path_to_child
+        end
+
+        def keys
+          Dir.children(path_to_node).select { |fname| fname.include? 'data_'}.
+            collect { |fname| fname.match(/\d+/)[0].to_i}.sort
+        end
+
+        def full?
+          num_of_keys == 2*t - 1
+        end
+
+        def num_of_keys
+          keys.size
+        end
+
+        def is_leaf?
+          children_paths(true).size.zero?
+        end
+
+        def setup_dirs
+          Rdb.logger.debug "Btree#setup_dirs setup dir %s" % path_to_node unless Dir.exist? path_to_node
+          Dir.mkdir(path_to_node, 0700) unless Dir.exist? path_to_node
+          children_paths
+        end
+      end
+    end
+  end
+end

data/lib/rdb/indexes/hash.rb

@@ -0,0 +1,6 @@
+module Rdb
+  module Indexes
+    class Hash < Rdb::Index
+    end
+  end
+end

data/lib/rdb/orm.rb

@@ -0,0 +1,85 @@
+# the ORM mapper, it's not included in main code
+#
+# Example of usage:
+#
+=begin
+
+require_relative 'rdb'
+require_relative 'rdb/orm'
+
+class Plane
+  include Rdb::Orm
+  rdb_mount 'planes', {id: Integer, code: String, weight: Integer}, {id: Rdb::Indexes::Btree}, '/home/rustam/rdata'
+end
+
+names = %w(rose velvet pink blue charley delta bravo)
+
+300000.times do |x|
+  code = "%s%d%s" % [names.sample, rand(1000), names.sample]
+  Plane.create(code: code, weight: rand(1000))
+end
+
+Plane.find_by(id: 1123)
+
+x = Plane.new
+x.code = "superjet3000"
+x.weight = 2572
+x.save
+
+Plane.find_by(id: x.id)
+
+=end
+
+module Rdb
+  module Orm
+
+    def self.included base
+      base.include InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module InstanceMethods
+      def save
+        result = self.class.create attributes
+        result.each do |key, value|
+          self.send("#{key}=", value)
+        end
+      end
+
+      def attributes
+        field_names.inject({}) do |result, key|
+          result[key] = self.send(key)
+          result
+        end
+      end
+    end
+
+    module ClassMethods
+      def rdb_mount name, fields, indexes, path_to_database
+        @rdb = Rdb.open(
+          name: name, 
+          fields: fields, 
+          indexes: indexes, 
+          path_to_database: path_to_database)
+        attr_accessor *fields.keys
+        define_method(:field_names) { fields.keys }
+      end
+
+      # search by key field only
+      def find_by condition
+        if result = @rdb[*condition.flatten]
+          instance = new()
+          result.each do |key, value|
+            instance.send("#{key}=", value)
+          end
+          instance
+        end
+      end
+
+      def create attributes
+        @rdb << attributes
+      end
+    end
+
+  end
+end

data/lib/rdb/storage_engine.rb

@@ -0,0 +1,7 @@
+# the storage engine interface
+module Rdb
+  class StorageEngine
+  end
+end
+
+require 'rdb/storage_engines/json'

data/lib/rdb/storage_engines/json.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+module Rdb
+  module StorageEngines
+    class Json < Rdb::StorageEngine
+
+      def initialize data, filename
+        @data = data
+        @filename = filename
+      end
+
+      def content
+        @data.to_json
+      end
+
+      def store!
+        File.open(@filename, 'w') { |file| file.write(content) }
+      end
+
+      def read 
+        JSON.parse File.read(@filename)
+      end
+    end
+  end
+end

data/lib/rdb/version.rb

@@ -0,0 +1,3 @@
+module Rdb
+  VERSION = "0.1.0"
+end

data/rdb.gemspec

@@ -0,0 +1,24 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rdb/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rudb"
+  spec.version       = Rdb::VERSION
+  spec.authors       = ["rustik"]
+  spec.email         = ["vasil.brazil@gmail.com"]
+
+  spec.summary       = %q{Rustik db}
+  spec.description   = %q{Ruby implementation of database with btree and ORM mapper}
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  required_ruby_version = '~> 2.5'
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: rudb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- rustik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Ruby implementation of database with btree and ORM mapper
+email:
+- vasil.brazil@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rdb.rb
+- lib/rdb/collection.rb
+- lib/rdb/document.rb
+- lib/rdb/error.rb
+- lib/rdb/index.rb
+- lib/rdb/indexes/btree.rb
+- lib/rdb/indexes/hash.rb
+- lib/rdb/orm.rb
+- lib/rdb/storage_engine.rb
+- lib/rdb/storage_engines/json.rb
+- lib/rdb/version.rb
+- rdb.gemspec
+homepage: 
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Rustik db
+test_files: []