hoaxdb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c7768d5652b3e5c33b611b48f182cd748b587e9fba398ba0fe4cc86242111f95
+  data.tar.gz: 3a714dd387f5ab77dcd334201921f49e237ce2ea5c551e3fce8230353a9fe488
+SHA512:
+  metadata.gz: 18040158b426bcf35355d21eebaf5e14389bc1e67d5f41e228e10664c593c9b4f4716ca2b94a5b6fab5b9b61516434ceeaaecc827b77e349038deaea8a799e39
+  data.tar.gz: 2aad20d569865209d388575050034185c1f08ad0a34c8d124ec73a74af23c020b1c5ae215aa9b0a8bd81c50b1055d992e06bcca6724d72d039a5cf1a7f9e5244

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+lib/hash.rb
+lib/data.db
+lib/e.xml

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.4.4
+before_install: gem install bundler -v 1.16.3

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 hashdb.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 njaneambrose
+
+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,67 @@
+# Hoaxdb
+
+Hoaxdb is a simple implementation of a database written in 100% pure ruby. It offers an interface to insert,update,query and delete records like any other databse but does not offer complex features of a database. You set specific data types for your fields and you can also have default values on top of that it validates the records you enter. In terms of queries you can choose specific fields, limits and also sort according to a specific field which can be ascending or descending. Queries are written using ruby hence no external knowledge is needed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hoaxdb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hoaxdb
+
+## Usage
+
+Using the hoaxdb is very simple once you have installed it, the following are the basics:
+#### Creating a table
+
+ ```ruby
+ require 'hoaxdb'
+    db = Hoaxdb.new('products.db') #This reads an existing database or creates a database
+    db.create_table("products",{
+       "name"=>{"type"=>"String","default"=>""}, #setting default prevents nil values
+       "price"=>{"type"=>"Float","default"=>0.0}
+    })
+```
+
+#### Inserting a record
+
+```ruby  
+products.insert({"name"=>"Iphone","price"=>100.67}) #insert a record
+```
+    
+#### Updating  a record
+
+```ruby
+products.update('this["name"].eql? "Iphone"',{"quantity"=>200})
+```
+    
+#### Selecting records    
+
+```ruby
+products.select_if('this["name"].eql? "Iphone"')
+```
+     
+#### Deleting records
+
+```ruby
+products.del_if('this["name"].eql? "Iphone"')
+```
+
+More information is available via rdoc when the gem is installed
+    
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/njaneambrose/hoaxdb.
+
+## 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,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hashdb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/hoaxdb.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hoaxdb/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hoaxdb"
+  spec.version       = Hoaxdb::VERSION
+  spec.authors       = ["njaneambrose"]
+  spec.email         = ["njaneambrose@gmail.com"]
+
+  spec.summary       = %q{An implementation of a NoSQl database in pure ruby}
+  spec.description   = %q{This is simple database based on a Hash that uses JSON for storage.It offers interfaces to create,update,delete and query records with a variety of options for queries}
+  spec.homepage      = "https://github.com/njaneambrose/hoaxdb"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/hoaxdb.rb

@@ -0,0 +1,265 @@
+require "hoaxdb/version"
+require "hoaxdb/table"
+require "zlib"
+require "json"
+require "thread"
+
+module Hoaxdb
+#=Introduction
+#Hoaxdb is a small implementation of a database using a Hash and JSON for storage written in 100% pure ruby. It allows you to create, update, query and delete records.
+#It also allows you to set specific data types for your fields, default values and validates input. In terms of queries you can set limits, select specific fields, sort by a field and also set a limit for the query.
+#==Field rules
+# Use string keys like ["products"] not [:products] due to JSON nature of storage
+#==Data types
+#The currently supported data types are
+#   Hash, DateTime, Date, Boolean, Float, Integer, Array & String
+#==Saving your work
+# #=> Never forget to call  
+# db.commit 
+# #=> to save the current changes
+#==Querying rules:
+#   1. "this" is used to refrence the current row e.g: this["price"] indicates the current row price
+#   2. The syntax this[.. is used for queries if not * for all rows
+#   3. For equality use .eql? not ==..
+#check the querying section for examples
+#==Updating rules:
+#   1. All rules for querying above apply
+#   2. To edit the current value use $ e.g an Array do: {"array"=>"$.push('value')"}, $ refrences the current value and must be called in a string as the first character
+#check the updating section for examples
+#
+#====CAUTION: Do not use Hoaxdb for extreme loads due to speed
+#
+#==Creating a table
+#Creating a table is very easy as first you need to connect to a database file then:
+#   require 'hoaxdb'
+#   db = Hoaxdb.new('products.db') #This reads an existing database or creates a database
+#   db.create_table("products",{
+#       "name"=>{"type"=>"String","default"=>""}, #setting default prevents nil values
+#       "price"=>{"type"=>"Float","default"=>0.0},
+#       "quantity"=>{"type"=>"Integer","default"=>100},
+#       "shipped"=>{"type"=>"Date"}
+#   })
+#This creates a simple table with three fields
+#==Inserting Records
+#The next step is just a simple as the one above, this is a continuation from above:
+#   products = db.table("products") #this connects to the products table
+#   products.insert({"name"=>"Iphone","price"=>100.67,"shipped"=>Date.new(2018,6,30)}) #insert a record
+#   products.insert({"name"=>"Cable Tvs","price"=>390.67,"shipped"=>Date.new(2018,9,12),"quantity"=>400}) #insert another record
+#   p products.data  #=> [{"name"=>"Iphone","price"=>100.67,"quantity"=>100,shipped=>"2018-6-30"},{"name"=>"Cable Tvs","price"=>390.67,"quantity"=>400,shipped=>"2018-9-12"}]
+#==Querying records
+#   #=>select_if('condtion * for all',[array of the fields you want * for all],limit -1 for no limit,"sort field must be in the fields array",desc=true/false)
+#   #=> condition * indicates all rows
+#   products.select_if('*',["name","price"]) #=> [{"name"=>"Iphone","price"=>100.67},{"name"=>"Cable Tvs","price"=>390.67}]
+#   products.select_if('*',["name","price"],-1,"price") #=> [{"name"=>"Cable Tvs","price"=>390.67},{"name"=>"Iphone","price"=>100.67}]
+#   products.select_if('*',["name","price"],-1,"price",true) #=> [{"name"=>"Iphone","price"=>100.67},{"name"=>"Cable Tvs","price"=>390.67}]
+#   products.select_if('this["price"] > 300',['name','price']) #=> [{"name"=>"Cable Tvs","price"=>390.67}]
+#   products.max("price") #=> 390.67
+#   products.min("price") #=> 100.67
+#   products.avg("price") #=> 245.67
+#   products.sum("price") #=> 491.34
+#==Updating records
+#   #=> table.update('condition * for all',{new values})
+#   #=> condition * indicates all rows
+#   #Incase of a 15% price increase in products do this to update
+#   products.update('*',{"price"=>"$ = this[\"price\"]*1.15"}) #=> Here you see how the $ symbol is used to update the existing value
+#   products.update('this["name"].eql? "Iphone"',{"quantity"=>200})
+#==Deleting records
+#   #=> table.del_if('condition')
+#   products.del_if('this["name"].eql? "Iphone"')
+#   p products.data #=> [{"name"=>"Cable Tvs","price"=>390.67,"quantity"=>400,shipped=>"2018-9-12"}]
+#==Adding fields
+#   products.add_column("remaining",{"type"=>"Integer","default"=>0})
+#   p products.base  #=> [{"name"=>{"type"=>"String","default"=>""},"price"=>{"type"=>"Float","default"=>0.0},"quantity"=>{"type"=>Integer","default"=>100}, "shipped"=>{"type"=>"Date","default"=>nil},{"remaining"=>{"type"=>"Integer","default"=>0}}]
+#==Deleting fields
+#   products.drop_column("remaining")
+#   p products.base #=> [{"name"=>{"type"=>"String","default"=>""},"price"=>{"type"=>"Float","default"=>0.0},"quantity"=>{"type"=>Integer","default"=>100}, "shipped"=>{"type"=>"Date","default"=>nil}]
+    class Db
+    def initialize(a)
+        @file = a
+        @a  = {}
+        thr = Thread.new do 
+            if File::exists? a
+                begin
+                    Zlib::GzipReader.open(@file) do |gz|
+                        x = JSON.parse(gz.read)
+                        x.each{|k,v| @a.store(k,v)}
+                    end
+                rescue Zlib::Error
+                    raise "We could not read any keys from #{a} the database may be corrupted"
+                rescue JSON::ParserError    
+                    @a = {}
+                end 
+            else
+                Zlib::GzipWriter.open(a).close  
+            end
+        end
+        thr.join    
+    end
+    def create_table(name,base)
+        if @a.has_key? name
+            raise "Table #{name} already exists"
+        end
+        tbase = name + "_base"
+        @a.store(tbase,{})
+        x = Table.new(name,base)
+        @a[tbase] = base
+        @a.store(name,[])
+    end
+    def drop_table(name)
+        tbase = name + "_base"
+        @a.delete(name)
+        @a.delete(tbase)
+    end
+    def table(name)
+        if @a.has_key? name and !name.match(/_base$/)
+            tbase = name + "_base"
+            x = Table.new(name,@a[tbase])
+            x.inject(@a[tbase],@a[name])
+            return x
+        elsif name.match(/_base$/)
+            raise "#{name} cannot be edited directly"
+        else
+            raise "Table #{name} does not exist"
+        end
+    end 
+#Lists all the tables in the database
+    def tables
+        tables = []
+        @a.keys.each{|e| if !e.match(/_base$/) then tables.push(e) end}
+        tables
+    end
+#Deletes all tables in the database
+    def clear
+        @a.clear
+    end
+#This saves chages made in the current session
+#  db.commit #saves the database  
+    def commit
+        thr = Thread.new do
+            Zlib::GzipWriter.open(@file) do |gz|
+                gz.write(JSON.generate(@a))
+            end
+        end 
+        thr.join    
+    end
+#This writes your database to a file in json format
+#  db >> "data.json"  
+    def >>(a)
+        f = File.open(a,'w')
+        f << @a.to_json
+        f.close
+    end
+#This returns the path to your database
+#  db.path  
+    def path
+        @file
+    end
+#This renames your database
+#  db.rename("hash.db")  
+    def rename(a)
+        File.rename(@file,a)
+        @file = a
+    end
+#This deletes your database
+#  db.del 
+    def del
+        File.delete(@file)
+    end
+#This returns JSON from selected table
+#  db.get_json("products")
+    def get_json(a)
+        x = {}
+        x.store(a,@a[a])
+        JSON.generate(x)
+    end
+#This returns XML from a selected table
+#   db.get_xml("products")   
+    def get_xml(a)
+        r = ""
+        if ishash(@a[a])
+            r = self.hash_to_xml(a,@a[a])
+        elsif isarray(@a[a])
+            r = self.array_to_xml(a,@a[a])
+        else
+           r = "<#{a}>#{@a[a]}</#{a}>"
+        end
+        r    
+    end    
+#This offloads the hoaxdb to a file other than the current file and  can also be used for backup pourposes
+#  db.offload("backup.db")
+    def offload(a)
+        Zlib::GzipWriter.open(a) do |gz|
+            gz.write(JSON.generate(@a))
+        end
+    end
+#This reloads data from the file and discards unsaved changes  
+    def reload
+        @a.clear
+        if File::exists? @file
+            begin
+                Zlib::GzipReader.open(@file) do |gz|
+                    x = JSON.parse(gz.read)
+                    x.each{|k,v| @a.store(k,v)}
+                end
+            rescue Zlib::Error
+                raise "We could not reload #{@file} it may be corrupted"
+            rescue JSON::ParserError
+            end    
+        else
+            Zlib::GzipWriter.open(a).close  
+        end
+    end
+    def isarray(e)
+        if e.class == Array
+            return true
+        else
+            return false
+        end    
+    end    
+    def ishash(e)
+        if e.class == Hash
+            return true
+        else
+            return false
+        end    
+    end
+    def array_to_xml(k,a)
+        sub = "<#{k}>"
+        a.each{|o|
+            if isarray(o)
+                sub << array_to_xml("array",o);
+            elsif ishash(o)
+                sub << hash_to_xml("hash",o)
+            else
+                sub << "<s#{k}>#{o}</s#{k}>"
+            end    
+        }
+        sub << "</#{k}>"
+        sub    
+    end 
+    def hash_to_xml(x,k)
+        sub = "<#{x}>"
+        k.each do |q,v|
+            if isarray(v)
+                sub << array_to_xml(q,v);
+            elsif ishash(v)
+                sub << "<#{q}>"
+                v.each{|t,b|
+                    if isarray(b)
+                        sub << array_to_xml(t,b)
+                    elsif ishash(b)
+                        sub << hash_to_xml(t,b);
+                    else
+                        sub << "<#{t}>#{b}</#{t}>"
+                    end
+                }
+                sub << "</#{q}>"
+            else
+               sub << "<#{q}>#{v}</#{q}>" 
+            end    
+        end
+        sub << "</#{x}>"
+        sub
+    end   
+    end
+end

data/lib/hoaxdb/table.rb

@@ -0,0 +1,297 @@
+require 'date'
+
+module Hoaxdb
+
+class Query
+    def parse(query)
+        query.strip!
+        if query.match(/row\[|@data|@base|[^\>\<]=/)
+            raise "This syntax is not allowed for querying" 
+        else
+            if query.match(/this\[/)
+                query = query.gsub(/this\[/,"row[")
+            elsif query.eql? "*"
+                query = "true"
+            else
+                raise "Unfamiliar query used"
+            end
+        end
+        query
+    end
+    def parse_complex(query)
+        query.strip!
+        if query.match(/@data|@base|;|row/)
+            raise "This syntax is not allowed for querying" 
+        else
+            query = query.gsub(/this\[/,"row[")
+        end
+        query
+    end
+end
+
+class Table
+    def initialize(name,args)
+        @name = name
+        @base = {}
+        if !args.class.eql? Hash
+            raise "Incorrect base for your database"
+        else
+            args.each{|k,v|
+                if self.valid_type(v["type"])
+                    self.validate(v)
+                    @base.store(k,v)
+                else
+                    raise "Invalid data type #{v}"
+                end    
+            }
+        end
+        @data = []
+    end
+    def validate(v)
+        if v["type"].eql? 'Date' or v["type"].eql? 'DateTime' and v["default"]
+            v["default"] = "#{v["default"]}"
+        elsif v["type"].eql? 'Boolean' and !v["default"].nil?
+            if v["default"].class.eql? TrueClass or v["default"].class.eql? FalseClass
+            else
+                raise "Invalid default #{v["default"]} to #{v["type"]}"
+            end
+        else
+             if !v["default"].nil? and !v["default"].class.eql? eval(v["type"])
+                raise "Invalid default #{v["default"]} to #{v["type"]}"
+            end
+        end
+        if v["default"].nil? then v["default"] = nil end
+    end
+    def data
+        @data.clone
+    end
+    def base
+        @base.clone
+    end
+    def fields
+        @base.keys
+    end
+    def valid_type(type)
+        types = ['String','Integer','Float','DateTime','Date','Boolean','Array','Hash']
+        found = false
+        types.each{|e| if e.eql? type then found = true;break end}
+        found
+    end
+    def load(data)
+        data.each do |row|
+            row.each do |k,v|
+                if !v.nil?
+                    if @base[k]['type'].eql? 'Date'
+                        row[k] = Date.parse(v)
+                    elsif @base[k]['type'].eql? 'DateTime'
+                        row[k] = DateTime.parse(v)
+                    elsif !@base[k]['type'].eql? 'String' and v.class.eql? String
+                        row[k] = eval(v)
+                    end
+                end  
+            end
+        end
+        data
+    end
+    def load_hash(data)
+         data.each do |k,v|
+            if !v.nil?
+                if @base[k]['type'].eql? 'Date'
+                    data[k] = Date.parse(v)
+                elsif @base[k]['type'].eql? 'DateTime'
+                    data[k] = DateTime.parse(v)
+                elsif !@base[k]['type'].eql? 'String' and v.class.eql? String
+                    data[k] = eval(v)
+                end
+            end  
+        end
+    end
+    def dump_array(data)
+        data.each do |row|
+            row.each do |k,v|
+                if @base[k]['type'].eql? 'Date' or @base[k]['type'].eql? 'DateTime'
+                    row[k] = "#{v}"
+                end    
+            end
+        end
+        data
+    end
+    def dump_hash(data)
+        data.each do |k,v|
+            if @base[k]['type'].eql? 'Date' or @base[k]['type'].eql? 'DateTime'
+                data[k] = "#{v}"
+            end    
+        end
+        data
+    end
+    def insert(data)
+        data.each{|k,v|
+            if @base[k]
+                if @base[k]['type'].eql? 'Boolean'
+                    if v.class.eql? FalseClass or v.class.eql? TrueClass
+                        correct = true
+                    else
+                        raise "#{v} is not a Boolean value"
+                    end
+                elsif !v.class.eql? eval(@base[k]['type'])
+                    raise "Incorrect data type for #{v} to #{@base[k]}"     
+                end
+            else
+                raise "This field #{k} is not in #{@name} table"
+            end    
+        }
+        data = self.dump_hash(data)
+        dt = {}
+        @base.each_key{|k|
+            if !data[k] then dt.store(k,@base[k]['default'])
+            else
+                dt.store(k,data[k])
+            end    
+        }
+        @data.push(dt)         
+    end
+    def alter_default(col,default)
+        if default.class.eql? eval(@base[col]['type'])
+            @base[col]['default'] = default
+        else
+            raise "#{default} is not of data type #{@base[col]['type']}"
+        end    
+    end
+    def add_column(col,type)
+        if @base.has_key? col
+            raise "Column #{col} already exists"
+        end
+        if valid_type(type['type'])
+            self.validate(type)
+            @base.store(col,type)
+            @data.each do |row|
+                row.store(col,@base[col]['default'])
+            end
+        end    
+    end
+    def update(query,values)
+        @data = self.load(@data)
+        @data.each{|row|
+            if eval(Query.new.parse(query))
+                values.each{|k,v|
+                    if v.class.eql? String and v[0].eql? "$"
+                        f = Query.new.parse_complex(v.delete("$"))                       
+                        temp = (row[k]).clone
+                        eval("temp#{f}")
+                        if temp.class.eql? eval(@base[k]['type'])
+                            row[k] = temp
+                        else
+                            raise "Invalid data #{temp} to #{@base[k]['type']}"
+                        end
+                    else
+                       if v.class.eql? eval(@base[k]['type'])
+                            row[k] = v
+                       else
+                            raise "Invalid data #{v} to #{@base[k]['type']}"
+                       end
+                    end
+                }
+            end
+        }
+        @data = self.dump_array(@data)
+    end
+    def drop_column(col)
+        @base.delete(col)
+        @data.each do |row|
+            row.delete(col)
+        end
+    end
+    def rename_column(col,ncol)
+        if @base.has_key? col
+            val = @base[col]
+            @base.delete(col)
+            @base.store(ncol,val)
+            @data.each do |row|
+                val = row[col]
+                row.delete(col)
+                row.store(ncol,val)
+            end
+        else
+            raise "Column #{col} does not exist"
+        end
+    end
+    def del_if(query)
+        rm = []
+        @data = self.load(@data)
+        d = Query.new.parse(query)
+        for x in 0...@data.size
+            row = @data[x]
+            if eval(d)
+                rm.push(x)
+            end
+        end
+        rm.reverse.each{|o| @data.delete_at(o)}
+        @data = self.dump_array(@data)
+    end
+    def max(k)
+        if !@base[k]['type'].eql? 'Array' or !@base[k]['type'].eql? 'Hash'
+            max = @data[0][k] || 0
+            @data.each{|row| if row[k] > max then max = row[k] end}
+            return max
+        end
+    end
+    def min(k)
+        if !@base[k]['type'].eql? 'Array' or !@base[k].eql? 'Hash'
+            min = @data[0][k] || 0
+            @data.each{|row| if row[k] < min then min = row[k] end}
+            return min
+        end
+    end
+    def avg(k)
+        if @base[k]['type'].eql? 'Integer' or @base[k]['type'].eql? 'Float'
+            sum = 0
+            @data.each{|row| sum += row[k]}
+            return (sum.to_f/@data.size)
+        else
+            raise "column #{k} is not of type Float or Integer"
+        end
+    end
+    def sum(k)
+        if @base[k]['type'].eql? 'Integer' or @base[k]['type'].eql? 'Float'
+            sum = 0
+            @data.each{|row| sum += row[k]}
+            return sum
+        else
+            raise "column #{k} is not of type Float or Integer"    
+        end
+    end
+    def select_if(query,cols,limit=-1,sort=false,desc=false)
+        result = []
+        @data = self.load(@data)
+        x = Query.new.parse(query)
+        res = @data.select{|row| eval(x)}
+        g = false
+        if cols[0].strip.eql? "*" then g = true end
+        res.each do |row|
+            col = {}
+            if !g
+                cols.each do |e|
+                    col.store(e,row[e])
+                end
+                result.push(col)
+            else
+               result.push(row)
+            end      
+        end   
+        if sort
+            result = result.sort{|a,b| a[sort] <=> b[sort]}   
+        end
+        if desc
+            result.reverse!
+        end
+        if limit != -1 then result = result[0...limit] end
+        @data = self.dump_array(@data)  
+        result = self.load(result)
+        result    
+    end
+    def inject(base,data) #:nodoc:#
+        @base = base
+        @data = data
+    end
+end
+end

data/lib/hoaxdb/version.rb

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

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: hoaxdb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- njaneambrose
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-18 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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: This is simple database based on a Hash that uses JSON for storage.It
+  offers interfaces to create,update,delete and query records with a variety of options
+  for queries
+email:
+- njaneambrose@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- hoaxdb.gemspec
+- lib/hoaxdb.rb
+- lib/hoaxdb/table.rb
+- lib/hoaxdb/version.rb
+homepage: https://github.com/njaneambrose/hoaxdb
+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: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: An implementation of a NoSQl database in pure ruby
+test_files: []