highland 0.0.1

data/README.md

@@ -0,0 +1,12 @@
+HighlandDB is a lightweight NoSQL database for custom Ruby based applications. It creates the database in the application directory, stores data in special highland files and utilizes asymptotically efficient algorythms for working with existing data.
+
+![Highland Logo](https://raw.github.com/mac-r/highland/master/logo.png)
+
+[![Build Status](https://secure.travis-ci.org/mac-r/highland.png)](https://travis-ci.org/mac-r/highland)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/mac-r/highland)
+
+## Learn more about Highland:
+[Installation](https://github.com/mac-r/highland/wiki/Installation)  |  [Querying](https://github.com/mac-r/highland/wiki/Querying) | [Making a Contribution](https://github.com/mac-r/highland/issues?milestone=&page=1&state=open)
+
+## Requirements:
+ ruby 1.9.3

data/bin/highland

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'gli'
+include GLI::App
+require 'rio'
+
+##
+# This are console colors.
+class Colors
+  COLOR1 = "\e[1;36;40m"
+  COLOR2 = "\e[1;35;40m"
+  NOCOLOR = "\e[0m"
+  RED = "\e[1;31;40m"
+  GREEN = "\e[1;32;40m"
+  DARKGREEN = "\e[0;32;40m"
+  YELLOW = "\e[1;33;40m"
+  DARKCYAN = "\e[0;36;40m"
+end
+
+class String
+  def color(color)
+    return color + self + Colors::NOCOLOR
+  end
+end
+
+##
+# This is an executable file, 
+# which includes all coomands available from the terminal.
+
+##
+# Returns the version of Highland, further it should return
+# the list of commands and examples of HighlandDB API.
+command :help do |c|
+  c.action do |global_options,options,args|
+    puts "Highland v. 0.0.1"
+  end
+end
+
+##
+# Creates new database in the 
+command :init do |c|
+  c.action do |global_options,options,args|
+    puts "Highland: init called!".color(Colors::GREEN)
+    db_root = Dir::pwd + "/highland_db/"
+    puts db_root
+    exec_root = Dir::pwd
+    begin
+      Dir::mkdir(db_root)
+      puts "\tcreated highland root"
+     rescue
+      raise TypeError, "Highland: couldn't create the database!".color(Colors::RED)
+    end
+
+    # creating directories
+    Dir::mkdir("#{db_root}/db")
+    puts "\tprepared db folder"
+
+    # creating files
+    manifesto_content = "collections:\n"
+    File.open("#{db_root}/manifesto.yml", 'w') {|f| f.write(manifesto_content) }
+    puts "\tprepared Manifesto"
+    File.open("#{exec_root}/root", 'w') {|f| f.write("Highland dependency!") }
+    puts "\tprepared root file"
+
+  end
+end
+
+exit run(ARGV)
+
+

data/lib/highland/collection_methods.rb

@@ -0,0 +1,201 @@
+module Highland
+
+  ##
+  # CollectionMethods are mostly the API of Highland. Methods marked
+  # with "API:" are the ones, which are recommended to use day by day.
+  module CollectionMethods
+    
+    ##
+    # Initializes collection (loads virtual hash and helper).
+    def init_collection(collection)
+      init_file(collection)
+      load_vhash(@file)
+      load_vhelper
+    end
+
+    ##
+    # API: Creates new element in collection. 
+    # [example: your code] Users.create(:age => 26, :name => 'Chris')
+    # [example: what happens] Creates user in Users collection.
+    def create(*params)
+      id = rand(999999999999999999)     
+      rec = {}
+      params[0].each_key do |key|
+        rec[key.to_s] ||= {}
+        rec[key.to_s]["type"] = params[0][key].class.to_s.downcase
+        rec[key.to_s]["value"] = params[0][key]
+      end
+      element = {id => rec}
+      insert_vhash(element)
+      insert_vhelper(element)
+      insert_shash(element)
+      return element
+    end
+
+    ##
+    # API: Returns array of elements according to the query.
+    # [example: your code #1] Users.where(:name => 'Helen', :age => 20)
+    # [example: your code #2] Users.where(:age => 20)
+    # [example: what happens] Will return Array of HighlandObjects, which
+    #                         fit the query constraints.
+    def where(*params)
+      hash = find_db(*params)
+      output = objectize(hash)
+      return output
+    end
+
+    ##
+    # API: Returns the first element according to the query.
+    # [example: your code #1] Users.first(:name => 'Bill', :age => 80)
+    # [example: your code #2] Users.first(:age => 80)
+    # [example: what happens] Will return the first HighlandObject, which
+    #                         fits the query constraints.
+    def first(*params)
+      where(*params).first
+    end
+
+    ##
+    # API: Returns all elements from the collection, you can also specify
+    # details of your request. Look at examples below
+    # [example: your code #1] Users.all(:name => 'Fake', :age => 20)
+    # [example: your code #2] Users.all(:age => 20)
+    # [example: your code #3] Users.all
+    # [example: what happens] Will return all HighlandObjects of collection
+    #                         or some of them according to the query.
+    def all(*params)
+      return where(*params) if params[0].class == Hash
+      return objectize(@vhash)
+    end
+
+    ##
+    # API: Allows you to find elements in collection. It's more powerful
+    # than "where" if you want to find several elements by id or by other keys.
+    # [example: your code #1] Users.find([id,id,...,id])
+    # [example: your code #2] Users.find(:age => [20,21,22])
+    # [example: your code #3] Users.find(:age => [28])
+    # [example: your code #4] Users.find(:age => 20)
+    # [example: what happens] Will return HighlandObjects
+    #                         according to the query.
+    def find(*params)
+      output = []
+      if params[0].class == Hash
+        params[0].each_key do |key|
+          [params[0][key]].flatten.each {|el| output = output + all(key => el)}
+        end          
+      else
+        params.each {|id| output += where(id)}
+      end
+      return output
+    end
+
+    ##
+    # API: Define the key and it will return all elements from collection.
+    # If the order is not specified - it's ascending. Look at examples
+    # of possible syntax.
+    # [example: your code #1] Users.sort(:age)
+    # [example: your code #2] Users.sort(:age => "asc")
+    # [example: your code #3] Users.sort(:age => "desc")
+    # [example: what happens] Will return HighlandObjects
+    #                         according to the defined order.
+    def sort(*params)
+      column = (params[0].class == Hash)?(params[0].keys.first):(params[0])
+      sorted = if params[0].class == Hash and params[0][column] == "desc"
+        distinct(column).sort{|x,y| y <=> x}
+      else
+        distinct(column).sort
+      end
+      output = []
+      sorted.each {|s| @vhelper[column.to_s][s].each{|id| output += find(id)}}
+      return output
+    end
+
+    
+    
+    
+    
+
+    ##
+    # API: Define keys and it will return all elements from collection.
+    # If the order is not specified - it's ascending. Look at examples
+    # of possible syntax.
+    # [example: your code #1] Users.count(:name => 'Fake', :age => 20)
+    # [example: your code #2] Users.count(:name => 'Fake')
+    # [example: your code #3] Users.count(:age => 21)
+    # [example: your code #4] Users.count
+    # [example: what happens] Will return quantity of files
+    #                         according to the defined query.
+    def count(*params)
+      return find_db(*params).keys.length if params[0].class == Hash
+      return @vhash.keys.length
+    end
+
+    ##
+    # API: is a synonim for "count".
+    def size(*params)
+      count(*params)
+    end
+
+    ##
+    # API: Allows to get all values of a specified key inside collection.
+    # It's a good way to get all ids as well.
+    # [example: your code #1] Users.distinct(:name)
+    # [example: your code #2] Users.distinct(:id)
+    # [example: what happens] Will return all values of a specified key.
+    def distinct(column)
+      return @vhelper[column.to_s].keys if column.to_s != "id"
+      return @vhash.keys if column.to_s == "id"
+    end
+
+    ##
+    # API: Updates the element of collection.
+    # [example: your code] Users.update(:id => some_id,:age => 40, :name => "Kate")
+    # [example: what happens] Will update relative values for element with id equal "some_id".    
+    def update(*params)
+      update_db(*params)
+    end 
+
+    ##
+    # API: Removes the element of collection.
+    # [example: your code] Users.remove(:age => 25, :name => "Bob")
+    # [example: what happens] Removes the element from table according to the query.
+    def remove(*params)
+      delete(*params)
+    end 
+
+    ##
+    # API: Clears the collection. Static and virtual hashes get empty.
+    # [example: your code] Users.clear
+    # [example: what happens] Now Users collection is empty.
+    def clear
+      clear_virtual
+      clear_static
+      reload_virtual
+    end
+
+    ##
+    # It's one of core methods, which works as a factory for HighlandObjects.
+    def objectize(hash)
+      output = []      
+      build_object
+      hash.each_key do |id|        
+        o = HighlandObject.new
+        o.instance_variable_set(:@id, id)        
+        o.singleton_class.send(:define_method, :id) { @id }        
+        hash[id].each_key do |key|
+          instance = "@#{key}"
+          o.instance_variable_set(instance.to_sym, hash[id][key]["value"])                  
+          o.singleton_class.send(:define_method, key) { eval(instance) }          
+        end
+        output << o
+      end
+      return output
+    end
+
+    ##
+    # Objectize method helper.
+    def build_object
+      Object.const_set("HighlandObject", Class.new) unless defined?(HighlandObject)
+    end
+
+  end
+end

data/lib/highland/core_extensions.rb

@@ -0,0 +1,13 @@
+class Hash
+  def remove!(*keys)
+    keys.each{|key| self.delete(key) }
+    self
+  end
+
+  def remove(*keys)
+    self.dup.remove!(*keys)
+  end
+end
+
+class HighlandObject < Array
+end

data/lib/highland/database_methods.rb

@@ -0,0 +1,171 @@
+require 'rio'
+require File.join(File.dirname(__FILE__), "core_extensions" )
+
+module Highland
+
+  ##
+  # DatabaseMethods are not the part of the user API. These methods
+  # are the fundamentals of the one. They work with static hashes and
+  # manage virtual ones. It's not recommended to work with these
+  # methods directly.
+  module DatabaseMethods
+
+    ##
+    # Defines @file instance variable.
+  	def init_file(shash)
+  	  @file = shash
+      generate_hl if File.exists?(@file) == false
+  	end
+
+    ##
+    # Creates static hash in the database folder.
+    def generate_hl
+      File.new(@file, "w")
+    end
+
+    ##
+    # Loads virtual hash.
+    def load_vhash(shash)
+      init_file(shash)
+      data = "{#{rio(@file).contents}}"
+      @vhash = eval(data)
+    end
+
+    ##
+    # Assigns the latest information about columns the @columns.
+    def update_columns
+      @columns = @vhelper.keys
+    end
+  
+    ##
+    # Loads virtual helper.
+    def load_vhelper
+      @vhelper = {}
+      @vhash.each_key do |id|
+        @vhash[id].each_key do |column|
+          @vhelper[column] ||= {}
+          item = @vhash[id][column]["value"]
+          @vhelper[column][item] ||= []
+          @vhelper[column][item] << id
+        end
+      end
+      update_columns
+    end
+
+    ##
+    # Inserts hash element into the virtual hash.
+    def insert_vhash(element)
+      element.each_key do |key|
+        @vhash[key] = element[key]
+      end
+    end
+
+    ##
+    # Inserts hash element into the virtual helper.
+    def insert_vhelper(element)
+      element.each_key do |id|
+        element[id].each_key do |column|
+          @vhelper[column] ||= {}
+          item = element[id][column]["value"]
+          @vhelper[column][item] ||= []
+          @vhelper[column][item] << id
+        end
+      end
+      update_columns
+    end
+
+    ##
+    # Finds hash elements according to the query.
+    def find_db(*query)
+      if query[0].class == Fixnum
+        id = query[0]
+        output = {}
+        output[id] = @vhash[id] if @vhash[id] != nil
+        return output
+      end
+      if query[0].class == Hash
+      	q = query[0]
+        ids = []
+        q.each_key do |column|
+          ids << @vhelper[column.to_s][q[column]]
+        end
+        res = ids.inject(ids.first){ |sim,cur| sim & cur }
+        return {} if res.class != Array or res == []
+        output = {}
+        res.each do |id|
+          next if @vhash[id] == nil
+          output[id] = @vhash[id]
+        end
+        return output
+      end
+    end
+
+    ##
+    # Inserts hash element into the static hash.
+    def insert_shash(element)
+      File.open(@file, 'a') do |file|
+        element.each_key do |id|
+          file.puts "#{id} => #{element[id]},"
+        end        
+      end
+    end
+
+    ##
+    # Clears virtual hash and virtual helper.
+    def clear_virtual
+      @vhash, @vhelper = {}, {}
+    end
+
+    ##
+    # Reloads virtual hash and virtual helper.
+    def reload_virtual
+      clear_virtual
+      load_vhash(@file)
+      load_vhelper
+    end
+
+    ##
+    # Clears static hash (collection).
+    def clear_static
+      File.truncate(@file, 0)
+    end
+
+    ##
+    # Deletes element from collection.
+    def delete(*query)
+      find_db(*query).each_key do |id|
+        @vhash.remove!(id)
+      end
+      load_vhelper
+      clear_static
+      insert_shash(@vhash)
+      return true
+    end
+
+    ##
+    # Updates element.
+    def update_db(*query)
+      id = query[0][:id]
+      query[0].each_key do |key|
+        next if key == :id
+        @vhash[id][key.to_s]["value"] = query[0][key] if @vhash[id].has_key?(key.to_s)
+      end
+      load_vhelper
+      clear_static
+      insert_shash(@vhash)
+      return true      
+    end
+
+    ##
+    # Returns virtual hash.
+    def return_vhash
+      @vhash
+    end
+    
+    ##
+    # Returns virtual helper.
+    def return_vhelper
+      @vhelper
+    end
+  end
+end

data/lib/highland/environment.rb

@@ -0,0 +1,136 @@
+require 'yaml'
+
+module Highland
+  
+  ##
+  # Environment is the initial set of methods, which gets loaded
+  # after you include highland in your file. It depends
+  # on the set of static files inside highland_db folder. If you
+  # write "require 'highland'" in your file and noothing works then
+  # it means that you didn't initialize your database in the folder
+  # of your application ($ highland init).
+  module Environment
+    self.extend Highland::Environment
+    @@klasses = []
+    @@stringklasses = []
+    @@db_path = ""
+
+    ##
+    # Load initializes the class variable @@db_path and loads collections.
+    # You shouldn't call this method. It's done automatically. If you want
+    # to specify the path to your database - write custom path in DB_PATH
+    # before "require 'highland'".
+    def load
+      @@db_path = find_root(Dir::pwd) if defined?(DB_PATH) == nil
+      @@db_path = DB_PATH if defined?(DB_PATH) == "constant"
+      load_collections
+    end
+    
+    ##
+    # Build is an alternative for load method. Allows you to redefine class
+    # variable. It's not recommended to use this method.
+    def build(file)
+      @@db_path = find_root(expander(file)) if defined?(DB_PATH) == nil
+      load_collections
+    end
+
+    ##
+    # Gets the list of static collections, compares it with the manifesto.yml.
+    # If manifesto.yml doesn't include some static collections - this collections
+    # get deleted. If manifesto.yml has collections which do not exist then these
+    # collections are automatically created. After this - virtual hashes are loaded.
+    def load_collections   
+      collections = get_collections
+      static = get_static
+      create_missing(collections, static)
+      delete_unused(collections, static)
+      classes = define_classes(collections)
+      load_virtuals(classes)
+    end
+
+    ##
+    # Gets names of collections from manifesto.yml.
+    def get_collections
+      return YAML.load_file(@@db_path + "manifesto.yml")["collections"]
+    end
+
+    ##
+    # Gets all static hashes (collections) from the database folder.
+    def get_static
+      return Dir[@@db_path + "db/*.hl"].map do |file|
+        File.basename(file,".hl").downcase
+      end
+    end
+
+    ##
+    # Creates all the missing static hashes, which are mentioned in manifesto.
+    def create_missing(collections, static)
+      collections.each do |c|
+        File.open(@@db_path + "db/#{c.downcase}.hl", "w") if static.include?(c.downcase) == false
+      end
+    end
+
+    ##
+    # Deletes all static collections, which are not mentioned in the manifesto.
+    def delete_unused(collections, static)
+      static.each do |c|
+        File.delete(@@db_path + "db/#{c.downcase}.hl") if collections.map(&:downcase).include?(c.downcase) == false
+      end      
+    end
+
+    ##
+    # Creates classes for relevant collections and provides them with API.
+    def define_classes(collections)      
+      collections.each do |collection|
+        if @@klasses.include?(collection) == false
+          new_class = Object.const_set(collection, Class.new)
+          new_class.extend Highland::CollectionMethods
+          new_class.extend Highland::DatabaseMethods
+          @@stringklasses << new_class
+          @@klasses << collection
+        end
+      end
+      return @@stringklasses           
+    end
+
+    ##
+    # Loads virtual hash and virtual helper for each collection.
+    def load_virtuals(classes)
+      classes.each do |klass|
+        target = klass.to_s.downcase
+        klass.init_collection(@@db_path + "db/#{target}.hl")
+      end
+    end
+
+    ##
+    # Returns true if the input path is the application root.
+    def root?(path)
+      root_objects = ["gemfile", "procfile", "readme", "root"]  
+      current_objects = Dir[path + "/*"].map do |file|
+        File.basename(file).downcase
+      end
+      dir = ""
+      current_objects.each do |co| 
+         dir = (root_objects.include?(co) == true)? "ROOT" : "NOT ROOT"
+         break if dir == "ROOT"
+      end
+      return true if dir == "ROOT"
+      return false if dir == "NOT ROOT"  
+    end
+
+    ##
+    # Expands the path of input file.
+    def expander(file)
+      return File.expand_path(File.dirname(file))
+    end    
+    
+    ##
+    # Recursive method, which tries to find the application root.
+    def find_root(path)
+      path = File.expand_path('..', path) if root?(path) == false
+      find_root(path) if root?(path) == false
+      return path + "/highland_db/" if root?(path) == true
+    end
+    
+  end
+end

data/lib/highland/highland.rb

@@ -0,0 +1,13 @@
+require 'highland/environment'
+require 'highland/collection_methods'
+require 'highland/database_methods'
+
+##
+# Highland is a lightweight NoSQL database. Enjoy!
+module Highland
+  include Environment
+  include DatabaseMethods
+  include CollectionMethods  
+end
+
+Highland::Environment.load

data/lib/highland.rb

@@ -0,0 +1 @@
+require 'highland/highland'

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: highland
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Max Makarochkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rio
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple database initially built as a default Ajaila database, which can
+  be installed in less than a minute.
+email: maxim.makarochkin@gmail.com
+executables:
+- highland
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/highland.rb
+- bin/highland
+- lib/highland/collection_methods.rb
+- lib/highland/core_extensions.rb
+- lib/highland/database_methods.rb
+- lib/highland/environment.rb
+- lib/highland/highland.rb
+- README.md
+homepage: http://github.com/mac-r/highland
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Lightweight NoSQL database inside your Ruby app.
+test_files: []