active-orient 0.42 → 0.79

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ed8d14a983f8e3d067830ef41396d2cef289b46b
-  data.tar.gz: f848a337d6b4cd07e591d902402547f1f225b01f
+SHA256:
+  metadata.gz: 7aeeeec320281d1ed65f73145b3d3008890c3ab46c480b480157cd2cd08dbace
+  data.tar.gz: 11d73a72a7510e5e6d8c93677504923141e78dd192ede941e4a042d4225f8dac
 SHA512:
-  metadata.gz: 4616d3587af1744fc6047b9aab929ae60911248029c310329c27cc36e3a545ed33c77fbe3d1f90b1b29346bf779dbe643497293d79618d06b3f6f950b6b6c464
-  data.tar.gz: 56a0f4ead290409aae2fde9e7af73d546cab19b3762d5d64d6bf4215ea23d2f71025c716a959f746a180125cb4c12c2e9cac492efd57ef3e2148c8a517e30a80
+  metadata.gz: c88ddae001fbdfbeba888d579235eb84d579f5e61c53591e4ef5cd1802a47c41f9e40d929c6f294a6b11a44f777ea41eb5b8f598342c15d72a2654eb273fc0d2
+  data.tar.gz: '0984f9cb17fe34c58047ad1e1144786f17bc5a760e2df883c4a9c8588eebd73cba7933b80d6c4a681c00927a791e986ca99303ae8fb9178c6705c652342b1842'

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+*~

data/Gemfile

@@ -1,15 +1,23 @@
 source "https://rubygems.org"
 gemspec
-gem 'activesupport' ,  "~>4.2"
-gem 'activemodel'
-gem 'rest-client' # , :git => 'git://github.com/rest-client/rest-client.git'
-gem 'nokogiri', '~> 1.6.6' #, :git => 'git://github.com/sparklemotion/nokogiri.git'
+gem 'activesupport' # ,  "~>4.2"
+gem 'activemodel' #,   "~>4.2"
+#gem 'activemodel-serializers-xml'
+gem 'rest-client'  , :git => 'https://github.com/rest-client/rest-client.git'
+#gem 'nokogiri', '~> 1.6.6' #, :git => 'git://github.com/sparklemotion/nokogiri.git'
+#gem 'orientdb' , :path => '/home/topo/orientdb-jruby' , :platforms => :jruby
+gem 'sdoc'
+#gem 'orientdb' , :git => 'git://github.com/topofocus/orientdb-jruby.git', :branch => '2.1.2', :platforms => :jruby
 group :development, :test do
+	gem "awesome_print"
 	gem "rspec"
+	gem 'rspec-legacy_formatters'
 	gem 'rspec-its'
+	gem 'rspec-given'
 	gem 'rspec-collection_matchers'
 	gem 'rspec-context-private'
-	gem 'guard'
+#	gem 'guard-jruby-rspec', :platforms => :jruby, :git => 'git://github.com/jkutner/guard-jruby-rspec.git'
+	gem 'guard'#, :platforms => :ruby
 	gem 'guard-rspec'
 ##	gem 'database_cleaner'
 	gem 'rb-inotify'

data/Guardfile

@@ -1,7 +1,6 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
-
-guard :rspec, cmd: "bundle exec rspec" do
+def fire
   require "ostruct"
 
   # Generic Ruby apps
@@ -12,10 +11,19 @@ guard :rspec, cmd: "bundle exec rspec" do
 
 
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^spec/usecase/(.+).rb$})
+#  watch(%r{^spec/usecase/(.+)\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+#  watch(%r{^examples/time_graph/spec/(.+)_spec\.rb$}) 
+  watch('examples/time_graph/spec/create_time_spec.rb') 
   watch('spec/spec_helper.rb')  { "spec" }
 
-  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})  { "spec" }
 end
 
+
+interactor :simple
+if RUBY_PLATFORM == 'java' 
+guard( 'jruby-rspec') {fire}  #', :spec_paths => ["spec"]
+else
+guard( :rspec, cmd: "bundle exec rspec") { fire }
+end

data/README.md

@@ -1,325 +1,112 @@
 # ActiveOrient
 Use OrientDB to persistently store dynamic Ruby-Objects and use database queries to manage even very large
-datasets.
+datasets. **OrientDB Version 3 is required**
 
-The Package ist tested with Ruby 2.2.1 and Orientdb 2.1.
+For changes from Version OrientDB 2.2 -> [Wiki](../..//wiki/Changes-2.2--to------3.0)
+### Quick Start
 
+You need a ruby 2.5/2.6  Installation and a working OrientDB-Instance (Version 3.0.17 or above).
 
-To start you need a ruby 2.x Installation and a working OrientDB-Instance.  
-Install the Gem the usual way
-
-For a quick start, go to the home directory of the package and start an irb-session
-
-```ruby
-  require 'bundler/setup'
-  require 'active-orient'
+- clone the project, 
+ - run bundle install ; bundle update, 
+ - update config/connect.yml,
+ - create the documentation:
+ ```
+   sdoc . -w2 -x spec -x example
+   ```
+   and point the browser to ~/active-orient/doc/index.htm
+   
+-  read the [Wiki](./../../wiki/Initialisation)
+ - and start an irb-session by calling  
 ```
-
-First, the Database-Server has to be specified. Then we can connect to a database.
-Assuming, the server is located on localhost, we just define »default-server«
-```ruby
-   ActiveOrient::OrientDB.default_server= { user: 'your user', password: 'your password' }
-
-
-  r = ActiveOrient::OrientDB.new  database: 'First'
-   => I, [2015-08-18T09:49:18.858758 #88831]  INFO -- OrientDB#Connect: Connected to database First
-   => #<ActiveOrient::OrientDB:0x000000048d0488 @res=#<RestClient::Resource:0x00000004927288 
-       @url="http://localhost:2480", @block=nil, 
-       @options={:user=>"xx", :password=>"***"}>, @database="First", @classes=[]> 
+cd bin
+./active-orient-console t)est   # or d)develpoment, p)roduction environment as defined in config/connect.ym
 ```
 
-»r« is the Database-Instance itself.  Obviously the database is  empty.
+### Philosophy
 
 
-Let's create some classes 
-
- ```ruby
-    M = r.open_class          'classname'  # 
-    M = r.create_class        'classname'  # creates or opens a basic document-class
-    M = r.create_vertex_class 'classname'  # creates or opens a vertex-class 
-    M = r.create_edge_class   'classname'  # creates or opens an edge-class, providing bidirectional links between documents
+OrientDB is basicly an Object-Database. It shares the concept of Inheritance with OO-Languages, like Ruby. 
+ 
+Upon initialisation `ActiveOrient`reads the complete structure of the database, creates corresponding ruby-classes (including inheritance) and then loads user defined methods from the `Model Directory`. A separate schema definition is not neccessary. 
 
-    r.delete_class   M                   # universal removal-of-the-class-method
- ```
+`ActiveOrient`queries the OrientDB-Database, provides a cache to speed things up and provides handy methods to simplify the work with OrientDB. Like Active-Record it represents the "M" Part of the MCV-Design-Pattern. There is explicit Namespace support. Its philosophie resembles the [Hanami Project](https://github.com/hanami/hanami). 
 
 
-»M« is the ActiveOrient::Model-Class itself, a constant pointing to the class-definition of the ruby-class.
-Its a shortcut for »ActiveOrient::Model::{Classname} and is reused if defined elsewhere.
 
-If a schema is used, properties can be created and retrieved as well
- ```ruby
-  r.create_properties( M ) do
-     {	symbol: { propertyType: 'STRING' },
-		con_id: { propertyType: 'INTEGER' },
-       	details: { propertyType: 'LINK', linkedClass: 'Contracts' }
-      }
 
-  r.get_class_properties  M 
- ```
- or
- ```ruby
- M.create_property  'symbol'
- M.create_property  'con_id', type: 'integer'
- M.create_property  'details', type: 'link', other_class: 'Contracts'
+#### CRUD
+The CRUD-Process (create, read = query, update and remove) is performed as
+```ruby	
+    # create the class
+    ORD.create_class :m
+    # create a record
+    M.create name: 'Hugo', age: 46, interests: [ 'swimming', 'biking', 'reading' ]
+    # query the database
+    hugo = M.where( name: 'Hugo' ).first
+    # update the dataset
+    hugo.update father: M.create( name: "Volker", age: 76 )  # we create an internal link
+    hugo.father.name	# --> volker
+    # change array elements
+    hugo.interests << "dancing"  # --> [ 'swimming', 'biking', 'reading', 'dancing' ]
+    M.remove hugo 
+    M.delete_class	# removes the class from OrientDB and deletes the ruby-object-definition
  ```
+ 
 
 #### Active Model interface
- 
-Every OrientDB-Database-Class is mirrord as Ruby-Class. The Class itself is defined  by
-```ruby
-  M =  r.create_class 'classname' 
-  M =  r.create_class { superclass_name:  'classname'  }
-  Vertex =  r.create_vertex_class 'classname' 
-  Edge   =  r.create_edge_class   'classname' 
-```
-and is of TYPE ActiveOrient::Model::{classname}
 
-As for ActiveRecord-Tables, the Class itself provides methods to inspect and to filter datasets form the database.
+As for ActiveRecord-Tables, the Model-class itself provides methods to inspect and filter datasets form the database.
 
 ```ruby
   M.all   
   M.first
   M.last
-```
-returns an Array containing all Documents/Edges of the Class; the first and the last Record.
-```ruby
-  M.where  town: 'Berlin'
-```
-performs a query on the class and returns the result as Array
+  M.where town: 'Berlin'
+  M.like "name =  G*"
 
-```ruby
   M.count where: { town: 'Berlin' }
 ```
-gets the number of datasets fullfilling the search-criteria. Any parameter defining a valid
-SQL-Query in Orientdb can be provided to the count, where, first and last-method.
+»count« gets the number of datasets fulfilling the search-criteria. Any parameter defining a valid SQL-Query in Orientdb can be provided to the »count«, »where«, »first« and »last«-method.
 
-A »normal« Query is submitted via 
+A »normal« Query is submitted via
 ```ruby
-  M.get_documents projection: { projection-parameter }
-		  distinct: { some parameters }
-		  where: { where-parameter }
-		  order: { sorting-parameters }
-		  group_by: { one grouping-parameter}
-		  unwind:
-		  skip:
-		  limit:
+  M.get_records projection: { projection-parameter },
+		  distinct: { some parameters },
+		  where: { where-parameter },
+		  order: { sorting-parameters },
+		  group_by: { one grouping-parameter},
+		  unwind:  ,
+		  skip:    ,
+		  limit:  
 
 #  or
- query = OrientSupport::OrientQuery.new {paramter}
- M.get_documents query: query
+ query = OrientSupport::OrientQuery.new {paramter}  
+ M.query_database query
 
 ```
 
-Basic graph-support:
-
-
-
+To update several records, a class-method »update_all« is defined.
 ```ruby
-  vertex_1 = Vertex.create  color: "blue"
-  vertex_2 = Vertex.create  flower: "rose"
-  Edge.create_edge attributes: { :birthday => Date.today }, from: vertex_1, to: vertex_2
+  M.update_all connected: false   	# add a property »connected» to each record
+  M.update_all set:{ connected: true },  where: "symbol containsText 'S'" 
 ```
-connects the vertices and assigns the attributes to the edge
-
-
-#### Links
-
-A record in a database-class is defined by a »rid«. Every Model-Object comes with a handy »link«-method.
-
-In OrientDB links are used to realise unidirectional  1:1 and 1:n relationships.
 
-ActiveOrient autoloads Model-objects when they are accessed. As a consequence, 
-if an Object is stored in Cluster 30 and id 2, then "#30:2" fully qualifies the ActiveOrient::Model object.
+Graph-support:
 
 ```ruby
-  TestLinks = r.create_class 'Test_link_class'
-  TestBase = r.create_class 'Test_base_class'
-
-  link_document =  TestLinks.create  att: 'one attribute' 
-  base_document =  TestBase.create  base: 'my_base', single_link: link_document 
-```
-base_document.single_link just contains the rid. When accessed, the ActiveOrient::Model::Testlinkclass-object is autoloaded and 
-``` ruby
-   base_document.single_link.att
+  ORD.create_vertex_class :the_vertex
+  ORD.create_edge_class :the_edge
+  vertex_1 = TheVertex.create  color: "blue"
+  vertex_2 = TheVertex.create  flower: "rose"
+  TheEdge.create_edge attributes: {:birthday => Date.today }, from: vertex_1, to: vertex_2
 ```
-reads the stored content of link_document. 
-
-To store a list of links to other Database-Objects a simple Array is allocated
-``` ruby
-  # predefined linkmap-properties
-  base_document =  TestBase.create links: []
-  ( 0 .. 20 ).each{ |y|  base_document.links << TestLinks.create  nr: y  }
-  end
-  #or in schemaless-mode
-  base_document =  TestBase.create links: (0..20).map{|y|  TestLinks.create  nr: y  }
+It connects the vertices and assigns the attributes to the edge.
 
+To query a graph,  SQL-like-Queries and Match-statements can be used (see below). 
 
-```
-base_document.links behaves like a ruby-array. 
-
-If you got an undirectional graph
+#### Other Documents
 
-   a --> b ---> c --> d
+- [Rails 5-Integration](./rails.md)
 
-the graphelements can be explored by joining the objects ( a.b.c.d ), or (a.b[5].c[9].d )
 
-#### Edges
-
-Edges are easily handled
-```ruby
-  Vertex = r.create_vertex_class 'd1'
-  Eedge = r.create_edge_class   'e1'
-
-  start =  Vertex.create  something: 'nice' 
-  the_end   =  Vertex.create  something: 'not_nice' 
-  the_edge = Edge.create_edge  attributes:  { transform_to: 'very bad' },
-			       from: start,
-			       to: the_end
- 
-  (...)
-  the_edge.delete
-```
-
-There is a basic support for traversals throught a graph.
-The Edges are accessed  by their names (downcase).
-
-```ruby
-  start.e1[0]
-  --> #<ActiveOrient::Model::E1:0x000000041e4e30 
-	@metadata={"type"=>"d", "class"=>"E1", "version"=>60, "fieldTypes"=>"out=x,in=x", 
-		   "cluster"=>16, "record"=>43}, 
-        @attributes={"out"=>"#31:23", "in"=>"#31:15", "transform_to"=>"very bad" }>
-```
-The Attributes "in" and "out" can be used to move across the graph
-```ruby
-   start.e1[0].out.something 
-   ---> "not_nice
-   start.e1[0].in.something 
-   ---> "nice
-```
-#### Queries
-Contrary to traditional SQL-based Databases OrientDB handles  subqueries very efficient. 
-In addition, OrientDB supports precompiled statements (let-Blocks).
-
-ActiveOrient is equipped with a simple QueryGenerator: ActiveSupport::OrientQuery. 
-It works in two modi: a comprehensive and a subsequent one
-```ruby
-  
-  q =  OrientSupport::OrientQuery.new
-  q.from = Vertex  
-  q.where << a: 2
-  q.where << 'b > 3 '
-  q.distinct = :profession
-  q.order =  { :name => :asc }
-
-```
-is equivalent to
-```ruby
-  q =  OrientSupport::OrientQuery.new from:  Vertex , 
-				      where: [{ a: 2 }, 'b > 3 '],
-				      distinct:  :profession,
-				      order:  { :name => :asc }
-  q.to_s
-  => select distinct( profession ) from Vertex where a = 2 and b > 3  order by name asc
-```
-Both modes can be mixed.
-
-If subqueries are nessesary, they can be introduced as OrientSupport::OrientQuery or as »let-block«.
-```ruby
-  q =  OrientSupport::OrientQuery.new from: 'ModelQuery'
-  q.let << "$city = adress.city"
-  q.where = "$city.country.name = 'Italy' OR $city.country.name = 'France'"
-  q.to_s
-  => select from ModelQuery let $city = adress.city where $city.country.name = 'Italy' OR $city.country.name = 'France' 
-```
-or
-```ruby
-  q =  OrientSupport::OrientQuery.new
-  q.let << { a:  OrientSupport::OrientQuery.new( from: '#5:0' ) }
-  q.let << { b:  OrientSupport::OrientQuery.new( from: '#5:1' ) }
-  q.let << '$c= UNIONALL($a,$b) '
-  q.projection << 'expand( $c )'
-  q.to_s
-  => select expand( $c ) let $a = ( select from #5:0 ), $b = ( select from #5:1 ), $c= UNIONALL($a,$b)
-```
-
-
-
-
-#### Execute SQL-Commands
-Sql-commands can be executed as batch
-
-The ActiveOrient::Query-Class provides a Query-Stack and an Records-Array which keeps the results.
-The ActiveOrient::Query-Class acts as Parent-Class for aggregated Records (without a @rid), which are ActiveOrient::Model::Myquery Objects. If a Query returns a database-record, the correct ActiveOrient::Model-Class is instantiated.
-
-```ruby
-   ach = ActiveOrient::Query.new
-    
-   ach.queries << 'create class Contracts ABSTRACT'
-   ach.queries << 'create property Contracts.subcategory link'
-   ach.queries << 'create property Contracts.details link'
-   ach.queries << 'create class Stocks extends Contracts'
-   ach.queries << 'create class Futures extends Contracts'
-   result = ach.execute_queries transaction: false
-   
-   
-
-```
-  queries the database as demonstrated above. In addition, the generated query itself is added to the »queries«-Stack and the result can be found in sample_query.records.
-  
-This feature can be used as a substitute for simple functions
-
-```ruby
- roq = ActiveOrient::Query.new
- roq.queries =["select name, categories.subcategories.contracts from Industries  where name containstext     …'ial'"]
- roq.execute_queries.each{|x|  puts x.name, x.categories.inspect }
- --> Basic Materials 	[["#21:1"]]
- --> Financial  	[["#21:2"]]
- --> Industrial 	[["#23:0", "#23:1"]]
-```
-
-OrientDB supports the execution of SQL-Batch-Commands. 
-( http://orientdb.com/docs/2.0/orientdb.wiki/SQL-batch.html )
-This is supported simply by using a Array as Argument for ActiveOrient::Query.queries
-
-Therefor complex queries can be simplified using database-variables 
-```ruby
-   ach = ActiveOrient::Query.new
-   ach.queries << [ "select expand( contracts )  from Openinterest"
-	            "let con = select expand( contracts )  from Openinterest; ",
-		    "...", ... ]
-   result = ach.execute_queries 
-```
-
-The contract-documents are accessible with 
-```ruby
-  r.get_document '21:1'
-  --><Stocks: con_id: 77680640 currency: EUR details: #18:1 exchange: SMART local_symbol: BAS 
-     primary_exchange: IBIS subcategory: #14:1 symbol: BAS>
-```
-or
-```ruby
-    my_query = ActiveOrient::Query.new
-    ['Contracts', 'Industries', 'Categories', 'Subcategories'].each do |table|
-        my_query.queries = [ "select count(*) from #{table}"]
- 
-        count = my_query.execute_queries
-        # count=> [#<ActiveOrient::Model::Myquery:0x00000003b317c8 
-        #		@metadata={"type"=>"d", "class"=>nil, "version"=>0, "fieldTypes"=>"count=l"},
-        #		@attributes={"count"=>4 } ] --> an Array with one Element, therefor count.pop 
-        puts "Table #{table} \t #{count.pop.count} Datasets "
-    end
-    -->Table Contracts 	 	56 Datasets 
-    -->Table Industries 	 8 Datasets 
-    -->Table Categories 	22 Datasets 
-    -->Table Subcategories 	35 Datasets 
-
-```
-
-Note that the fetched Object is of type »Stocks« (ActiveOrient::Model::Stocks).
-
-The ActiveOrient-API documentation can be found here: https://github.com/orientechnologies/orientdb-docs/wiki/OrientDB-ActiveOrient
-and the ActiveModel-documentation is here: http://www.rubydoc.info/gems/activemodel
- 
- 
-