active-orient 0.6 → 0.42

data/lib/rest_disabled.rb

@@ -1,24 +0,0 @@
-=begin #nodoc#
-If properties are allocated on class-level, they can be preinitialized using
-this method.
-This is disabled for now, because it does not seem nessesary
-=end
-
-def preallocate_class_properties o_class
-  p= get_class_properties( o_class )['properties']
-  unless p.nil? || p.blank?
-    predefined_attributes = p.map do | property |
-      [ property['name'] ,
-      case property['type']
-      when 'LINKMAP'
-        Array.new
-      when 'STRING'
-        ''
-      else
-        nil
-      end  ]
-    end.to_h
-  else
-    {}
-  end
-end

data/linkmap.md

@@ -1,75 +0,0 @@
-# Joining Tables 
-
-The most important difference between OrientDB and a Relational Database is that relationships are represented by LINKS instead of JOINs.
-
-For this reason, the classic JOIN syntax is not supported. OrientDB uses the "dot (.) notation" to navigate LINKS
-(OrientDB-documation)
-
-This is supported by ActiveOrient in a very convient way.
-
-## Playing with Arrays and Linkmaps
-
-Linkmaps are the OrientDB equivalent to joined tables 
-Formally, they are ordinary arrays.
-
-They can be created schemaless
-
-```ruby
-DB.create_class :industry
-DB.create_class :property
-property_record=  Property.create  con_id: 12346, property: []
-industries =  ['Construction','HealthCare','Bevarage']
-industries.each{| industry | property_record.property <<  Industry.create( label: industry ) }
-
-Property.last
- => #<Property:0x00000001d1a938 @metadata={"type"=>"d", (...)},  
-    @attributes={"con_id"=>12346, "property"=>["#34:0", "#35:0", "#36:0"],
-    "created_at"=>"2017-02-01T06:28:17.332 01:00", "updated_at"=>"2017-02-01T06:28:17.344 01:00"}> 
- ```
-
-Stored data in this array is accessible via
-
-```ruby
-p =  Property.last
-p.property.label
- => ["Construction", "HealthCare", "Bevarage"]
-p.property[2].label
- => "Bevarage" 
-p.property.label[2]
-  => "Bevarage" 
-p.property[2].label[2]
- => "v" 
-
-p.property.remove_at 2
-p.property.label
-  => ["Construction", "HealthCare"] 
-
-p.property[2] = Industry.where(label:'Bevarage').first
-p.property.label
- => ["Construction", "HealthCare", "Bevarage"] 
-```
-
-The Elements of the Array can be treated like common ruby Arrays. Manipulations are
-performed in ruby-spac. Simply call
-```ruby
-p.update
-```
-to transfer the changes into the database. This approach can be extended to linked records as well
-
-```ruby
-p.property[2].label = 'zu'
-p.property[2].update
-p.property.label
- => ["Construction", "HealthCare", "zu"]
-Industry.last.label
- => "zu"
-
-
-```
-
-
-
-
-(to be continued)
-
-

data/namespace.md

@@ -1,111 +0,0 @@
-## Namespace Support
-
-Consider a project, where different tasks are clearly separated. 
-
-A common case is, to concentrate any gathering of raw data in a separate module, maybe even in a gem.
-
-ActiveOrient enables this by switching the "ActiveOrient::Model.namespace" directive.
-
-In out case, the "ib-ruby" gem gets data through an api 
-The gem provides the logic to convert the raw-data from the server to ActiveOrient::Model-Objects.
-Its located in the model-directory of the gem.
-
-Just by including the gem in the Gemfile and requiring the gem, anything is available in our project.
-
-The gem defines the ActiveOrient-Environment as follows:
-```ruby
-module IB                                
-module ORD                             
-include ActiveOrient::Init          # namespace support
-mattr_accessor :login 
-
-# establishes a connection to the Database and returns the Connection-Object (an ActiveOrient::OrientDB.         …instance)
-def self.connect                  
-
-  c = { :server => 'localhost', :port  => 2480,	:protocol => 'http',       
-	:user   => 'root',   :password => 'root', :database => 'temp'  }.merge login.presence || {}
-  ActiveOrient.default_server= { user: c[:user], password: c[:password] , server: c[:server], port: c[:port]  }
-  ActiveOrient.database = c[:database]
-  logger =  Logger.new '/dev/stdout'
-  ActiveOrient::Init.define_namespace { IB } 
-  project_root = File.expand_path('../..', __FILE__)
-
-  ActiveOrient::Model.model_dir =  "#{project_root}/models"
-  ActiveOrient::OrientDB.new  preallocate: true  # connect via http-rest
-
-(...)
-  ```
-The gem scans through all database classes present, and allocates only those, where a model-file
-is found in the model-directory. 
-
-This takes place by requiring 'ib-ruby' in 'config/boot.rb'
-
-```ruby
-  76 #read the configuration and model-files from the ib-ruby gem directotry
-  77 require 'ib/ord'
-  78 IB::ORD.login= ActiveOrient.default_server.merge database: ActiveOrient.database
-  79 require 'ib-ruby'  # automatically connects to the database
-  80 
-  81 # set the model-file for the time-graph
-  82 module TG
-  83 end
-  84 ActiveOrient::Model.model_dir =  "#{project_root}/model"
-  85 ActiveOrient::Init.define_namespace { TG }
-  86 puts "Namespace changed: #{ActiveOrient::Model.namespace}"
-  87 ActiveOrient::OrientDB.new  preallocate:  true
-
-```
-
-After row 80, the namspace is changed to "TG" (TimeGraph).  The example provides a gem as well. Just 
-»require 'orientdb_time_graph'« and call »TG.connect« to include it properly.
-
-The code above shows how to integrate the classes within the structure of the project. The difference is the placement
-of the model-files. With the gem, they are located in the root-directory of the gem. The other approach looks in the model-directory of the project (model/tg).
-
-Before we start, we  switch to the object-layer, where we want to define the working-classes. Their 
-logic is defined in model-files in 'model'. And we want to make shure, that all database-classes are allocated
-to ruby classes. 
-
-```ruby
-97   ActiveOrient::Init.define_namespace :object
-98   ActiveOrient::Model.keep_models_without_file = true
-99   ORD = ActiveOrient::OrientDB.new  preallocate: true
-```
-
-**note** The preallocation-algorithm trys to load any class. If »ActiveOrient::Model.keep_models_without_file«
-is set to false, classes are allocated only, if a model-file is present. As a consequence, any appropopiate
-model-file is loaded. 
-
-Any  previously allocated class can thus be extended, providing a proper model-file. For example: If we 
-allocated a class «Contract« in the namspace »IB«, methods for this class are included from the model-dir specified in the gem *and* in the actual-model-directory ( in this case: model/ib/contract.rb ). 
-
-
-As a result something like this appears:
-
-```
-DB-Class  -> Ruby-Object
-		V ->  V
-		E ->  E
-contract ->  		IB::Contract
-bag				->  IB::Bag
-forex			->  IB::Forex
-future			->  IB::Future
-option			->  IB::Option
-stock			->  IB::Stock
-account			->  IB::Account
-bar				->  IB::Bar
-contract_detail ->  IB::ContractDetail
-day_of	  ->  TG::DAY_OF
-time_of	  ->  TG::TIME_OF
-time_base ->  TG::TimeBase
-monat	  ->  TG::Monat
-stunde	  ->  TG::Stunde
-tag	  ->  TG::Tag
-
-new_test  ->  NewTest
-
-```
-
-By changing the namespace-scope with  'ActiveOrient::Init.define_namespace'  its always possible to 
-change properties, include links and edges or to add  and remove classes in the Sub-Modules.
-

data/old_lib_functions/two_general_class.rb

@@ -1,139 +0,0 @@
-# NEW
-
-def create_general_class classes, behaviour = "NORMALCLASS", extend_class, properties: nil
-  if @classes_available.nil?
-    @classes_available = get_database_classes requery: true
-    @classes_available = @classes_available.map!{|x| x.downcase}
-  end
-
-  begin
-    consts = Array.new
-
-    if classes.is_a? Array
-      if behaviour == "NORMALCLASS"
-        classes.each do |singleclass|
-          consts |= create_general_class singleclass, properties: properties
-        end
-      else
-        classes.each do |singleclass|
-          consts |= create_general_class singleclass, "EXTENDEDCLASS", extend_class, properties: properties
-        end
-      end
-
-    elsif classes.is_a? Hash
-      classes.keys.each do |superclass|
-        consts |= create_general_class superclass, "SUPERCLASS"
-        consts |= create_general_class classes[superclass], "EXTENDEDCLASS", superclass, properties: properties
-      end
-
-    else
-      name_class = classes.to_s.camelize
-      unless @classes_available.include?(name_class.downcase)
-
-        if behaviour == "NORMALCLASS"
-          command = "CREATE CLASS #{name_class}"
-        elsif behaviour = "SUPERCLASS"
-          command = "CREATE CLASS #{name_class} ABSTRACT"
-        elsif behaviour = "EXTENDEDCLASS"
-          name_superclass = extend_class.to_s.camelize
-          command = "CREATE CLASS #{name_class} EXTENDS #{name_superclass}"
-        end
-
-        execute transaction: false do
-          { type:     "cmd",
-            language: "sql",
-            command:  command}
-        end
-
-        @classes_available << name_class.downcase
-
-        # Add properties
-        unless properties.nil?
-          create_properties temp_class, properties
-        end
-
-      end
-      temp_class = ActiveOrient::Model.orientdb_class(name: name_class)
-      consts << temp_class
-      return consts
-    end
-  rescue RestClient::InternalServerError => e
-    logger.progname = 'RestCreate#CreateGeneralClass'
-    response = JSON.parse(e.response)['errors'].pop
-    logger.error{"#{response['content'].split(':').last }"}
-    nil
-  end
-end
-alias create_classes create_general_class
-
-# OLD
-
-def create_general_class classes, properties: nil
-    begin
-      get_database_classes requery: true
-      consts = Array.new
-      execute transaction: false do
-        class_cmd = -> (s,n) do
-      	  n = n.to_s.camelize
-      	  consts << ActiveOrient::Model.orientdb_class(name: n)
-          classes_available = get_database_classes.map{|x| x.downcase}
-      	  unless classes_available.include?(n.downcase)
-      	    {type: "cmd", language: 'sql', command: "CREATE CLASS #{n} EXTENDS #{s}"}
-          end
-    	  end  ## class_cmd
-
-    	  if classes.is_a?(Array)
-    	    classes.map do |n|
-    	      n = n.to_s.camelize
-    	      consts << ActiveOrient::Model.orientdb_class(name: n)
-            classes_available = get_database_classes.map{|x| x.downcase}
-        	  unless classes_available.include?(n.downcase)
-    		      {type: "cmd", language: 'sql', command: "CREATE CLASS #{n}"}
-    	      end
-    	    end
-    	  elsif classes.is_a?(Hash)
-    	    classes.keys.map do |superclass|
-    	      items = Array.new
-    	      superClass = superclass.to_s.camelize
-            unless get_database_classes.flatten.include?(superClass)
-    	        items << {type: "cmd", language: 'sql', command:  "CREATE CLASS #{superClass} ABSTRACT"}
-            end
-    	      items << if classes[superclass].is_a?(String) || classes[superclass].is_a?(Symbol)
-    		      class_cmd[superClass, classes[superclass]]
-    	      elsif classes[superclass].is_a?(Array)
-    		      classes[superclass].map{|n| class_cmd[superClass, n]}
-    	      end
-            items  # returnvalue
-    	    end.flatten
-    	  end.compact # erase nil-entries, in case the class is already allocated
-      end
-    # refresh cached class-informations
-      classes_available = get_database_classes requery: true
-
-    # Add properties
-      unless properties.nil?
-        classes_available.map!{|x| x.downcase}
-        consts = Array.new
-        if classes.is_a?(Hash)
-          superclass = classes.keys[0]
-          classes = [classes[superclass]]
-        end
-        classes.each do |n|
-          if classes_available.include?(n.downcase)
-            temp_class = ActiveOrient::Model.orientdb_class(name: n)
-            create_properties temp_class, properties
-            consts << temp_class
-          end
-        end
-      end
-
-    # returns an array of allocated Constants/Classes
-      consts
-    rescue RestClient::InternalServerError => e
-      logger.progname = 'RestCreate#CreateGeneralClass'
-      response = JSON.parse(e.response)['errors'].pop
-      logger.error{"#{response['content'].split(':').last }"}
-      nil
-    end
-  end
-  alias create_classes create_general_class

data/rails.md

@@ -1,125 +0,0 @@
-# Active Orient and Rails
-
-The usage of Orientdb via ActiveOrient in Rails requires just a few steps.
-Based on a Rails 5 installation
-
-```ruby
-  rvm install 2.4
-  rvm use 2.4
-  gem install bundler
-  gem install nokogiri
-  gem install rails
-  rails -v   # Rails 5.0.1
-
-```
-
-create your working directory and initialize the system
-
-```ruby
-mkdir rails_project; cd rails_project
-rails -OCT .
-```
-This initializes a Rails-Stack, without active-record, action-cable and the test-suite.
-(We will use rspec later)
-
-This can be checked by inspecting «/config/application.rb «
- 
-```ruby
-rails s puma
-```
-should work at this stage.
-
-## Modify the Gemfile
-Inform rails to use orientdb and active-orient
-
-```
-echo " gem 'active-orient' , :path => '/home/your_cloned_active_orient_path/activeorient' " >> Gemfile
-# or
-
-echo " gem 'active-orient' , :git => 'https://github.com/topofocus/active-orient.git' " >> Gemfile
-```
-
-After that, copy 
-
-* __active_orient/rails/activeorient.rb__   to   /config/initializers  in the rails-project dir
-* __active_orient/rails/connect.yml__ to /config
-* __active_orient/rails/config.yml__ to /config
-
-and modify the yml-files accordingly.
-
-Run the  bundler
-
-```
-bundle install & bundle update
-```
-
-The database should be present in the rails console, and 
-```ruby
-rails c
-
-V.count
-V.first
-E.count
-puts ActiveOrient::Model.allocated_classes.map{|x,y| "#{"%15s"% x} ->  #{y.to_s}" }.join("\n")
-
-```
-should work.
-
-**Notice** The spring-facility is running in the background. Stop the server prior reloading
-the console ( ./bin/spring stop ). 
-
-The final step is to generate Model-Files. In «/config/config.yml» the «:model_dir»-var points to
-the location of the model-files. The default is 'lib/orient'. 
-
-Upon startup this directory is scanned for autoloading database-files. 
-
-After envoking the rails console, the logfile displays sucessfully loaded and missing files, ie.
-
-```
-14.01.(08:28:45) INFO->ModelClass#RequireModelFile:..:model-file not present: /home/topo/workspace/orient-rails/lib/orient/followed_by.rb
-14.01.(08:28:45) INFO->ModelClass#RequireModelFile:..:/home/topo/workspace/orient-rails/lib/orient/v.rb sucessfully loaded
-```
-
-## Model-file Example
-
-To query the GratefulDeadConcerts Database, «v.rb» hosts the essential model methods.
-As always, use «def self.{method}« for class methods and simply «def {method}» for methods working on the record level.
-
-```
-1 class V 
-2        def  self.artists **attributes 
-3          names 'artist', **attributes
-4        end
-5        
-6        def  self.songs **attributes 
-7          names 'song', **attributes
-8        end
-9        
-10        def self.types
-11          oo =  OrientSupport::OrientQuery
-12          this_query = oo.new  distinct: [:type, :a ]
-13          query_database( this_query ).a
-14        end
-15 private
-16        def  self.names  type, sort: :asc, limit: 20, skip: 0
-17          puts "in names"
-18          oo =  OrientSupport::OrientQuery
-19          query_database  oo.new( where: {type: type }, 
-20                                 order: { name: sort } ,
-21                                 limit: limit ,
-22                                 skip: skip )
-23        end
-24 end
-
-```
-
-Now 
-
-```ruby
-  V.types
-  V.artists limit: 15, skip: 34, sort: :desc 
-```
-queries the database, fetches 15 artists and can be used everywhere.
-
-
-