active-orient 0.5 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5968de1064555bed8ecadc417fbad4f4af9c78d1
-  data.tar.gz: 3f06f99417522ab20a776412f5b2eca1295664f2
+  metadata.gz: 1c3fb207d23e5c1cd30e95105075370967fb4a6b
+  data.tar.gz: 6f606ff9a666368ddcaa51dd0e3ca7f7edf3bfa2
 SHA512:
-  metadata.gz: 05ae6ba2fd2e933661e6f36fc1db77bef5ecd944b90f490c4d8d49d737b97aaf82ac61c0bcdff4055ac393fde2fe70e54228a30afdbef28d61134f0081f84779
-  data.tar.gz: 854f1efe44dd9a4056b5a37d882ed887487f7b7d734447c5d289648b118444e126352da92d2bf74935ce304f4eeecc92faed329f80a54fb85fbdb0a2b0f394ef
+  metadata.gz: 371a9c4ad68cad3f4efc701c3965e1f946bce6f610b4ea7245f3f168a6417185dc7829395387a07f97e55f92c02829a7e72999f824ffffff92e99f17090e1113
+  data.tar.gz: 2f4c7e0a6a74a34c5f605ae6b9ee094eb4c2ff51827c1beb5d77be04caceba6c7ed2149edd093be0ee9b9004afa6bdc4fdc203d4c1e5122d648c7b87aebfb961

data/Gemfile

@@ -1,7 +1,8 @@
 source "https://rubygems.org"
 gemspec
-gem 'activesupport' ,  "~>4.2"
-gem 'activemodel',   "~>4.2"
+gem 'activesupport' # ,  "~>4.2"
+gem 'activemodel' #,   "~>4.2"
+#gem 'activemodel-serializers-xml'
 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 'orientdb' , :path => '/home/topo/orientdb-jruby' , :platforms => :jruby

data/README.md

@@ -2,17 +2,33 @@
 Use OrientDB to persistently store dynamic Ruby-Objects and use database queries to manage even very large
 datasets.
 
-You need a ruby 2.3  or a jruby 9.1x Installation and a working OrientDB-Instance (Version 2.2 prefered).
+#### Other Documents
+- [Experiments with Joins / Linkmaps ](./linkmap.md)
+
+- [Experiments with the GratefulDeadConcerts Sample Database](./gratefuldeadconcerts.md)
+
+- [Namespace Support](./namespace.md)
+
+- [TimeGraph Implementation](examples/time_graph.md)
+
+- [Rails 5-Integration](./rails.md)
+
+You need a ruby 2.3, 2.4  or a jruby 9.1x Installation and a working OrientDB-Instance (Version 2.2 prefered).
 The jruby-part is experimental.
 
-For a quick start, clone the project, run bundle install & bundle update, update config/connect.yml, create the documentation by calling »rdoc«
-and start an irb-session: 
+### Quick Start
+
+ - clone the project, 
+ - run bundle install & bundle update, 
+ - update config/connect.yml, 
+ - create the documentation by calling »rdoc«
+ - start an irb-session by calling  
 ```
 cd bin
 ./active-orient-console test   # or d)develpoment, p)roduction environment as defined in config/connect.yml
 ```
 
-»ORD« is the Database-Instance itself. If the Database noticed is not present, it is created on startup.
+«ORD» or «DB» is the Database-Instance itself. If the Database noticed is not present, it is created on startup.
 A simple SQL-Query is submitted by providing a Block to »execute«
  ```ruby
  result =  ORD.execute { "select * from Stock" } 
@@ -71,9 +87,10 @@ All database-classes are preallocated after connecting to the database. Thus you
 
 If the "rid" is known, any Object can be retrieved and correctly allocated by
 ```ruby
-  the_object =  ActiveOrient::Model.autoload_object "xx:yy" # or "#xx:yy"
+  the_object =  V.autoload_object "xx:yy" # or "#xx:yy"
   --->  {ActiveOrient::Model} Object 
 ```
+The database-class  «V» is present in any case. Any model-class can be used, even the parent »ActiveOrient::Model«
 
 #### Properties
 The schemaless mode has many limitations. ActiveOrient offers a Ruby way to define Properties and Indexes
@@ -126,6 +143,12 @@ A »normal« Query is submitted via
 
 ```
 
+To update several records, a class-method »update_all« is defined.
+```ruby
+  M.update_all connected: false   	# add a property »connected» to each record
+  M.update_all set:{ connected: true },  where: "symbol containsText 'S'" 
+```
+
 Graph-support:
 
 ```ruby
@@ -195,10 +218,32 @@ Edges provide bidirectional Links. They are easily handled
   the_edge = TheEdge.create attributes: {transform_to: 'very bad'},
 			       from: start,
 			       to: the_end
+```
+Edges are connected to vertices by »in« and »out«-Methods.
+Inherence is supported.
+
+i.e.
+```ruby
+  ORD.create_class( top_edge ) { THE_EDGE }
+  ORD.create_class( on_top_edge ) { TOP_EDGE }
+
+  ON_TOP_Edge.create  from: start, to: the_end
+  start.reload!
+  start.out :the_edge 
+  => [#<TOP_EDGE:0x00000001d92f28 @metadata= ... ]
+```
+
+Edge-links are displayed and retrieved by
+```ruby
+  start.edges	  # :in | :out | :all 
+   => ["#73:0"] 
+  
+  start.edges(:out).map &:from_orient
+  => [#<TOP_EDGE:0x00000001d92f28 @metadata= ... ]
 
-  (...)
-  the_edge.delete # To delete the edge
 ```
+
+
 The create-Method od Edge-Classes takes a block. Then all statements are transmitted in batch-mode.
 Assume, Vertex1 and Vertex2 are Vertex-Classes and TheEdge is an Edge-Class, then
 ```ruby
@@ -214,31 +259,6 @@ Assume, Vertex1 and Vertex2 are Vertex-Classes and TheEdge is an Edge-Class, the
 ```
 connects the vertices and provides a variable "key" and a common "study" attribute to each edge.
 
-There is a basic support for traversals through a graph.
-The Edges are accessed  by their names (downcase).
-```ruby
-  start = TheVertex.where: {something: "nice"}
-  start[0].e1[0]
-  --> #<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[0].e1[0].out.something
-   # ---> "not_nice"
-   start[0].e1[0].in.something
-   # ---> "nice"
-```
-
-(Experimental) In alternative you can "humanize" your code in the following way:
-
-```ruby
-   Vertex.add_edge_link name: "ends",  edge: TheEdge
-   start.ends.something # <-- Similar output as start[0].e1[0].out.something
-```
 
 #### Queries
 
@@ -312,15 +332,15 @@ this executes the query and returns the adressed rid's, which are eventually ret
 #### Match
 
 A Match-Query starts at the given ActiveOrient::Model-Class. The where-cause narrows the sample to certain 
-records. In the simplest version this can be returnd:
+records. In the simplest version this can be returned:
   
 ```ruby
   ORD.create_class :Industry
   Industry.match where:{ name: "Communications" }
-  => #<ActiveOrient::Model::Query:0x00000004309608 @metadata={"type"=>"d", "class"=>nil, "version"=>0, "fieldTypes"=>"Industries=x"}, @attributes={"Industries"=>"#21:1", (...)}>
+  => #<Query:0x00000004309608 @metadata={"type"=>"d", "class"=>nil, "version"=>0, "fieldTypes"=>"Industries=x"}, @attributes={"Industries"=>"#21:1", (...)}>
 ```
 
-The attributes are the return-Values of the Match-Query. Unless otherwise noted, the pluralized Model-Classname is used as attribute in the result-set.
+The attributes are the return-Values of the Match-Query. Unless otherwise noted, the pluralized Model-Classname is used as attribute in the result-set. *Note* that the Match statement returns a »Query«-record. Its up to the usere, to transform the attributes to Model-Objects. This is done by the »to_orient« directive, ie. »xx.Industries.to_orient «
 
 ```ruby
   Industry.match where name: "Communications" 
@@ -343,3 +363,26 @@ accessed starting at Industry defining
 The result-set has two attributes: Industries and Subcategories, pointing to the filtered datasets.
 
 By using subsequent »connect« and »statement« method-calls even complex Match-Queries can be constructed. 
+
+
+#### Other Documents
+- [Experiments with Joins / Linkmaps ](./linkmap.md)
+
+- [Experiment with the GratefulDeadConcerts Sample Database](./gratefuldeadconcerts.md)
+
+- [Namespace Support](./namespace.md)
+
+- [TimeGraph Implementation](examples/time_graph.md)
+
+
+  deactivated behavior: to turn it on, some work on base.rb is required
+``` 
+  start.the_edge  # --> Array of "TheEdge"-instances connected to the vertex
+  start.the_edge.where transform_to: 'good'     # ->  empty array
+  start.the_edge.where transform_to: 'very bad' #-->  previously connectd edge
+  start.something     # 'nice'
+  end.something	      # 'not_nice'
+  start.the_edge.where( transform_to: 'very bad').in.something  # => ["not_nice"] 
+  (...)
+  the_edge.delete # To delete the edge
+```

data/VERSION

@@ -1 +1 @@
-0.5
+0.6

data/active-orient.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.email       = ["topofocus@gmail.com"]
   s.homepage    = 'https://github.com/topofocus/active-orient'
   s.licenses    = ['MIT']
-  s.summary     = 'Pure ruby client for OrientDB based on ActiveModel'
-  s.description = 'Persistent ORM for OrientDB, based on ActiveModel' 
+  s.summary     = 'Pure ruby client for OrientDB(V.2.2) based on ActiveModel'
+  s.description = 'Persistent ORM for OrientDB(V.2.2), based on ActiveModel. Rails 5 compatible' 
   s.platform	= Gem::Platform::RUBY
   s.required_ruby_version = '>= 2.2.5'
   s.date 	= Time.now.strftime "%Y-%m-%d"
@@ -21,8 +21,8 @@ Gem::Specification.new do |s|
    
   s.add_development_dependency "bundler", "~> 1.8"
   s.add_development_dependency "rake", "~> 10.0"
-  s.add_dependency 'activesupport', "~> 4.2"
-  s.add_dependency 'activemodel', "~> 4.2"
+  s.add_dependency 'activesupport'#, "~> 4.2"
+  s.add_dependency 'activemodel'#, "~> 4.2"
   s.add_dependency 'rest-client'  
 
 end

data/bin/active-orient-console

@@ -7,14 +7,14 @@
 require 'logger'
 LogLevel = Logger::WARN
 require File.expand_path(File.dirname(__FILE__) + "/../config/boot")
-  
+
  require 'orientdb' if RUBY_PLATFORM == 'java'
  require 'yaml'
 
 puts "ORD points to the REST-Instance, Database: #{ActiveOrient.database}"
 puts "DB is the API-Instance of the database, DB.db gets the DB-Api-base " if RUBY_PLATFORM == 'java'
 
-puts '-'* 35
+puts '-'* 45
 ns= case ActiveOrient::Model.namespace 
   when Object
     "No Prefix, just ClassName#CamelCase"
@@ -22,11 +22,14 @@ ns= case ActiveOrient::Model.namespace
      ActiveOrient::Model.namespace.to_s + "{ClassName.camelcase}"
     end
 puts "Namespace for model-classes : #{ns}"
-puts "Allocated Classes (Hierarchy) ( Modelclasses are Camelized ):"
-puts '-'* 35
+puts "Present Classes (Hierarchy) "
 
 puts ORD.class_hierarchy.to_yaml
-
+puts ""
+puts "Active Classes  ->  ActiveOrient ClassName"
+puts '-'* 45
+puts ActiveOrient::Model.allocated_classes.map{|x,y| "#{"%15s"% x} ->  #{y.to_s}" }.join("\n")
+puts '-'* 45
 
 include OrientDB
 

data/config/boot.rb

@@ -5,8 +5,6 @@ if RUBY_VERSION == 'java'
 end
 project_root = File.expand_path('../..', __FILE__)
 require "#{project_root}/lib/active-orient.rb"
-# mixin for define_namespace 
-include ActiveOrient::Init
 begin
   connect_file = File.expand_path('../../config/connect.yml', __FILE__)
   config_file = File.expand_path('../../config/config.yml', __FILE__)
@@ -31,9 +29,9 @@ env =  if e =~ /^p/
 puts "Using #{env}-environment"
 
 ActiveOrient::Model.model_dir =  "#{project_root}/#{ configyml.present? ? configyml[:model_dir] : "model" }"
-
+ActiveOrient::Model.keep_models_without_file = true
 # lib/init.rb
-define_namespace yml: configyml, namespace: @namespace
+ActiveOrient::Init.define_namespace yml: configyml, namespace: @namespace
 
 
 log_file =   if config_file.present?

data/config/config.yml

@@ -6,5 +6,5 @@
  :namespace: :object
 ## model_dir: Path to model-files relative to the root of the application
 ## ie. app/model  or model
- :model_dir: 'model'
+ :model_dir: 'lib/model'
 

data/config/connect.yml

@@ -4,9 +4,9 @@
  :port: 2480
  :logger: stdout           # 'file' or 'stdout'
  :database: 
-   :development: DEV
+   :development: GratefulDeadConcerts
    :production: hcn_data
-   :test:  tempera
+   :test:  temp
  :admin:
    :user: hctw
    :pass: hc

data/examples/time_graph.md

@@ -0,0 +1,162 @@
+The Time-Graph Example is outsourced  and lives as a seperate gem.
+
+https://github.com/topofocus/orientdb_time_graph
+
+from the readme: 
+
+# Time Graph 
+
+Simple Time Graph using ActiveOrient/OrientDB. 
+
+*Prerequisites* : 
+* Install and setup OrientDB
+* Run "Bundle install" and "Bundle update"
+* customize config/connect.yml
+
+**or** start a new project and include the gem in the usual manner.
+
+To play around, start the console by
+```
+  cd bin
+  ./active-orient-console t  # test-modus
+```
+The Database is automatically initialized and the following hierarchy is build:
+
+```ruby
+- E				# ruby-class
+- - month_of		      TG::MONTH_OF
+- - day_of		      TG::DAY_OF
+- - time_of		      TG::TIME_OF
+- - grid_of		      TG::GRID_OF
+- V
+- - time_base		      TG::TimeBase
+- - - jahr		      TG::Jahr
+- - - monat		      TG::Monat
+- - - stunde		      TG::Stunde
+- - - tag		      TG::Tag
+```
+This Graph is realized
+
+```ruby
+Jahr -- [Month_of] -- Monat --[DAY_OF]-- Tag --[TIME_OF]-- Stunde
+```
+and populated by calling 
+
+```ruby
+TG::TimeGraph.populate( a single year or a range )  # default: 1900 .. 2050
+```
+If only one year is specified, a Monat--Tag--Stunde-Grid is build, otherwise a Jahr--Monat--Tag one.
+You can check the Status by calling 
+
+```ruby
+TG::TimeGraph.populate 2000 -2003
+TG.info
+-------------- TIME GRAPH ------------------
+Allocated Years : 
+2000; 2001; 2002; 2003 
+
+```
+In the Model-directory, customized methods simplify the usage of the graph.
+
+Some Examples:
+Assuming, you build a standard day-based grid
+
+```ruby
+
+include TG					# we can omit the TG prefix
+
+Jahr[2000]    # --> returns a single object
+=> #<TG::Jahr:0x00000004ced160 @metadata={"type"=>"d", "class"=>"jahr", "version"=>13, "fieldTypes"=>"out_month_of=g", "cluster"=>34, "record"=>101}, @d=nil, @attributes={"value"=>2000, "out_month_of"=>["#53:1209", "#54:1209", "#55:1209", "#56:1209", "#53:1210", "#54:1210", "#55:1210", "#56:1210", "#53:1211", "#54:1211", "#55:1211", "#56:1211"], "created_at"=>Fri, 09 Sep 2016 10:14:30 +0200}>
+
+
+Jahr[2000 .. 2005].value  # returns an array
+ => [2003, 2000, 2004, 2001, 2005, 2002] 
+
+Jahr[2000 .. 2005].monat(5..7).value  # returns the result of the month-attribute (or method)
+ => [[5, 6, 7], [5, 6, 7], [5, 6, 7], [5, 6, 7], [5, 6, 7], [5, 6, 7]] 
+
+Jahr[2000].monat(4, 7).tag(4, 15,24 ).datum  # adresses methods or attributes of the specified day's
+ => [["4.4.2000", "15.4.2000", "24.4.2000"], ["4.7.2000", "15.7.2000", "24.7.2000"]] 
+ ## unfortunatly »Jahr[2000 .. 2015].monat( 3,5 ).tag( 4 ..6 ).datum « does not fits now
+ ## instead »Jahr[2000..2015].map{|y| y.monat( 3,5 ).tag( 4 ..6 ).datum } « does the job.
+```
+
+To filter datasets in that way, anything represented is queried from the database. In contrast to
+a pure ruby implementation, this works for small and large grid's.
+
+Obviously, you can do neat ruby-array playings, which are limited to the usual sizes.
+For example. As »TAG[31]« returns an array, the elements can be treated with ruby flavour:
+
+```ruby
+
+Tag[31][2..4].datum  # display three months with 31 days 
+ => ["31.10.1901", "31.1.1902", "31.5.1902"]
+
+```
+First all Tag-Objects with the Value 31 are queried. This gives »Jan, Mar, May ..«. Then one can inspect the array, in this case by slicing a range.
+
+Not surprisingly, the first occurence of the day is not the earliest date in the grid. Its just the first one,
+fetched from the database.
+
+``` ruby
+Tag[1][1].datum
+=> "1.5.1900"    # Tag[1][0] correctly fetches "1.1.1900"
+Tag[1].last.datum
+ => "1.11.2050"
+ ## however, 
+Jahr[2050].monat(12).tag(1)  # exists:
+=> [["1.12.2050"]]
+```
+
+## Horizontal Connections
+
+Besides the hierarchically TimeGraph »Jahr <-->Monat <--> Tag <--> Stunde«  the Vertices are connected
+horizontally via »grid_to«-Edges. This enables an easy access to the neighbours.
+
+On the TG::TimeBase-Level a method »environment« is implemented, that gathers the adjacent vertices 
+via traverse.
+
+``` ruby
+start =  TG::Jahr[2000].monat(4).tag(7).first.first
+start.environment(3).datum
+ => ["4.4.2000", "5.4.2000", "6.4.2000", "7.4.2000", "8.4.2000", "9.4.2000", "10.4.2000"] 
+
+2.3.1 :003 > start.environment(3,4).datum
+ => ["4.4.2000", "5.4.2000", "6.4.2000", "7.4.2000", "8.4.2000", "9.4.2000", "10.4.2000", "11.4.2000"] 
+ 
+start.environment(0,3).datum
+ => ["7.4.2000", "8.4.2000", "9.4.2000", "10.4.2000"] 
+```
+
+
+
+## Diary
+
+lets create a simple diary
+
+```ruby
+include TG
+TimeiGraph.populate 2016
+ORD.create_vertex_class :termin
+ => Termin
+ORD.create_edge_class   :date_of
+ => DATE_OF
+DATE_OF.uniq_index	# put contrains to the edge-class, accept only one entry per item 
+
+DATE_OF.create from: Monat[8].tag(9).stunde(12), 
+	       to: Termin.create( short: 'Mittagessen', 
+				  long: 'Schweinshaxen essen mit Lieschen Müller', 
+				  location: 'Hofbauhaus, München' )
+ => #<DATE_OF:0x0000000334e038 (..) @attributes={"out"=>"#21:57", "in"=>"#41:0", (..)}> 
+# create some regular events
+# attach breakfirst at 9 o clock from the 10th to the 21st Day in the current month
+DATE_OF.create from: Monat[8].tag(10 .. 21).stunde( 9 ), to: Termin.create( :short => 'Frühstück' )
+ => #<DATE_OF:0x000000028d5688 @metadata={(..) "cluster"=>45, "record"=>8}, 
+			      @attributes={"out"=>"#22:188", "in"=>"#42:0",(..)}>
+
+t = Termin.where short: 'Frühstück'
+t.in_date_of.out.first.datum
+  => ["10.8.2016 9:00", "11.8.2016 9:00", "12.8.2016 9:00", "13.8.2016 9:00", "14.8.2016 9:00", "15.8.2016 9:00", "16.8.2016 9:00", "17.8.2016 9:00", "18.8.2016 9:00", "19.8.2016 9:00", "20.8.2016 9:00", "21.8.2016 9:00"]
+
+```
+