active-orient 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e808c07b0d7ea4b6ab44772dcfbed8521f1dbe1b
+  data.tar.gz: d1dc78cd6f6b0b5b8da14512e54e39777479b31c
+SHA512:
+  metadata.gz: da1131e98ac909ba6e77526f52a6c9ae608eabe9d9a0d5d3dc2bb2a702fb7454493a2de516746e00f2d6f1f60c1bb4191393f49a28da470a3f3e87c763b624cb
+  data.tar.gz: 883ea6e68bfe1fc3a88dc4b7d9173a1a454c6141d6dfb234286aab3de1677666a0a115a022acd36049ed9cbf490abfd153287a547c67dddb9115671daf4bf9a8

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,16 @@
+source "https://rubygems.org"
+gemspec
+gem 'activesupport' ,  "~>4.2"
+gem 'activemodel'
+gem 'rest-client', :git => 'git://github.com/rest-client/rest-client.git'
+group :development, :test do
+	gem "rspec"
+	gem 'rspec-its'
+	gem 'rspec-collection_matchers'
+	gem 'rspec-context-private'
+	gem 'guard'
+	gem 'guard-rspec'
+##	gem 'database_cleaner'
+	gem 'rb-inotify'
+	gem 'pry'
+end

data/Guardfile

@@ -0,0 +1,21 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "ostruct"
+
+  # Generic Ruby apps
+  rspec = OpenStruct.new
+  rspec.spec = ->(m) { "spec/#{m}_spec.rb" }
+  rspec.spec_dir = "spec"
+  rspec.spec_helper = "spec/spec_helper.rb"
+
+
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^spec/usecase/(.+).rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 topofocus
+
+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,275 @@
+# ActiveOrient
+Use OrientDB to persistently store dynamic Ruby-Objects and use database queries to manage even very large
+datasets.
+
+The Package ist tested with Ruby 2.2.1 and Orientdb 2.1.
+
+
+To start you need a ruby 2.x Installation and a working OrientDB-Instance.  
+Clone the project and run bundle install/ bundle update,
+then modify »config/connect.yml«. 
+Its adviserable to generate the rdoc-documentation with executing
+```
+rdoc 
+```
+from the source directory of AcitiveOrient and then to load the doc-directory into any browser.
+
+For a quick start, go to the home directory of the package and start an irb-session
+
+then
+
+```ruby
+  require './config/boot'
+  r = ActiveOrient::OrientDB.new  database: 'First'
+   => #<ActiveOrient::OrientDB:0x000000048d0488 @res=#<RestClient::Resource:0x00000004927288 
+       @url="http://localhost:2480", @block=nil, 
+       @options={:user=>"xx", :password=>"***"}>, @database="First", @classes=[]> 
+```
+
+»r« is the Database-Instance itself.  Obviously the database is  empty.
+
+
+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
+
+    r.delete_class   M                   # universal removal-of-the-class-method
+ ```
+
+
+»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'
+ ```
+
+#### 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.
+
+```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
+
+```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.
+
+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:
+
+#  or
+ query = OrientSupport::OrientQuery.new {paramter}
+ M.get_documents query: query
+
+```
+
+Basic graph-support:
+
+
+
+```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
+```
+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.
+
+```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
+```
+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  }
+
+
+```
+base_document.links behaves like a ruby-array. 
+
+If you got an undirectional graph
+
+   a --> b ---> c --> d
+
+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
+```
+
+#### Execute SQL-Commands
+At least - 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
+ 
+ 
+ 

data/acitve-orient.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name        = "active-orient"
+  s.version	= File.open('VERSION').read.strip
+  s.authors     = [" Hartmut Bischoff"]
+  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.platform	= Gem::Platform::RUBY
+  s.required_ruby_version = '>= 2.2.0'
+  s.date 	= Time.now.strftime "%Y-%m-%d"
+  s.test_files  = `git ls-files -- {spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+   
+  s.add_development_dependency "bundler", "~> 1.8"
+  s.add_development_dependency "rake", "~> 10.0"
+  s.add_dependency 'activesupport'
+#  s.add_dependency 'rest-client', :git => 'git://github.com/rest-client/rest-client.git'
+
+end

data/config/boot.rb

@@ -0,0 +1,24 @@
+require 'bundler/setup'
+require 'yaml'
+project_root = File.expand_path('../..', __FILE__)
+require "#{project_root}/lib/support.rb"
+require "#{project_root}/lib/base.rb"
+require "#{project_root}/lib/base_properties.rb"
+
+require "#{project_root}/lib/model.rb"
+require "#{project_root}/lib/orient.rb"
+require "#{project_root}/lib/rest.rb"
+#require "#{project_root}/lib/graph.rb"
+
+# require all the models and libraries
+libs= Dir.glob(File.join( project_root, "lib",'**', "*rb")) 
+result = libs.reverse.collect { |file| [file, require( file )] }
+
+logger =  Logger.new '/dev/stdout'
+#REST::Graph.logger =  logger
+ActiveOrient::Model.logger =  logger
+ActiveOrient::OrientDB.logger =  logger
+
+
+
+

data/config/connect.yml

@@ -0,0 +1,13 @@
+---
+:orientdb:
+ :server: localhost
+ :port: 2480
+ :database: hc_database
+ :admin:
+   :user: hctw
+   :pass: hc
+ :auth:
+   :user: topo
+   :pass: focus
+
+# hfx: 101

data/lib/base.rb

@@ -0,0 +1,220 @@
+module  ActiveOrient
+  require 'active_model'
+  #
+  # Base class for tableless IB data Models, extends ActiveModel API
+  class Base
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    include ActiveModel::Validations
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::Xml
+    include ActiveModel::Serializers::JSON
+    
+
+    ##Every Rest::Base-Object is stored in the @@rid_store
+    ## The Objects are just references to the @@rid_store.
+    ## any Change of the Object is thus synchonized to any allocated variable
+    #
+    @@rid_store =  Hash.new
+
+    def self.display_riid
+      @@rid_store
+    end
+    def self.remove_riid obj
+      @@rid_store[obj.riid]=nil 
+    end
+    def self.get_riid link
+
+    end
+    def self.store_riid obj
+      if obj.rid.present? && obj.riid.all?{|x| x.present? && x>=0} # only positive values are stored
+	  ## return the presence of a stored object as true by the block
+	  ## the block is only executed if the presence is confirmed
+	  ##  Nothing is returned from the class-method
+	if @@rid_store[obj.riid].present? 
+	  yield  if block_given?  	    
+	end
+	 @@rid_store[obj.riid] = obj
+	 @@rid_store[obj.riid]  # return_value
+      else
+	obj # no rid-value: just return the obj
+      end
+    end
+
+
+    define_model_callbacks :initialize
+
+    mattr_accessor :logger
+    # If a opts hash is given, keys are taken as attribute names, values as data.
+    # The model instance fields are then set automatically from the opts Hash.
+    def initialize attributes={}, opts={}
+      logger.progname= "ActiveOrient::Base#initialize"
+      #possible_link_array_candidates = link_candidates = Hash.new
+      @metadata = HashWithIndifferentAccess.new
+#      @edges = HashWithIndifferentAccess.new
+    
+      run_callbacks :initialize do
+#	puts "initialize::attributes: #{attributes.inspect}"
+
+	attributes.keys.each do | att |
+	  unless att[0] == "@"	    # @ identifies Metadata-attributes
+	    att =  att.to_sym if att.is_a?(String)    
+	    unless self.class.instance_methods.detect{|x| x == att }
+	      self.class.define_property att, nil 
+#	      logger.debug { "property #{att.to_s} assigned to #{self.class.to_s}" }
+	    else
+#	      logger.info{ "property #{att.to_s}  NOT assigned " }
+	    end
+	  end
+	end
+
+	if attributes['@type'] == 'd'  # document 
+	  @metadata[ :type    ] = attributes.delete '@type'
+	  @metadata[ :class   ] = attributes.delete '@class' 
+	  @metadata[ :version ] = attributes.delete '@version' 
+	  @metadata[ :fieldTypes ] = attributes.delete '@fieldTypes' 
+	  if attributes.has_key?( '@rid' )
+	    rid = attributes.delete '@rid' 
+	    cluster, record = rid[1,rid.size].split(':') 
+	    @metadata[ :cluster ] =  cluster.to_i
+	    @metadata[ :record ] = record.to_i
+	  end
+
+	  #### edges -- remove in_ and out_ and de-capitalize the remaining edge
+	  if @metadata[ :fieldTypes ].present? && (@metadata[ :fieldTypes ] =~ /=g/)
+	    edges = @metadata['fieldTypes'].split(',').find_all{|x| x=~/=g/}.map{|x| x.split('=').first}
+	    edges.each do |edge|
+	      operator, *base_edge =  edge.split('_')
+	      base_edge = base_edge.join('_')
+	      unless self.class.instance_methods.detect{|x| x == base_edge }
+		## define two methods: out_{Edge}/{in_Edge} -> edge. 
+		self.class.define_property base_edge, nil 
+		self.class.send :alias_method, base_edge.underscore, edge  #  
+#		logger.debug { "#{link}:: edge #{edge} assigned to #{self.class.to_s} and remaped to #{base_edge.underscore}" }  
+
+	      end
+	    end
+	  end
+	end
+
+
+	  self.attributes = attributes # set_attribute_defaults is now after_init callback
+	end
+	ActiveOrient::Base.store_riid self
+      end
+
+    # ActiveModel API (for serialization)
+
+    def attributes
+      @attributes ||= HashWithIndifferentAccess.new
+    end
+
+    def attributes= attrs
+      attrs.keys.each { |key| self.send("#{key}=", attrs[key]) }
+    end
+
+    # ActiveModel-style read/write_attribute accessors
+    # Here we define the autoload mechanism
+    def [] key
+
+      iv= attributes[key.to_sym]
+  #    iv.from_orient unless iv.nil?
+      if  iv.is_a?(String) && iv.rid? #&& @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?( key.to_s+"=x" )
+     # puts "autoload: #{iv}"
+	ActiveOrient::Model.autoload_object  iv
+      elsif iv.is_a?(Array) # && @metadata[:fieldTypes].present? && @metadata[:fieldTypes].match( key.to_s+"=[znmgx]" )
+     # puts "autoload: #{iv.inspect}"
+	OrientSupport::Array.new self, *iv.map{|y| (y.is_a?(String) && y.rid?) ? ActiveOrient::Model.autoload_object(  y ) : y  }
+      else
+
+	iv
+      end
+    end
+
+    def update_attribute key, value
+      @attributes[key] = value
+    end
+=begin
+Here we define how the attributes are initialized 
+Key and val are set by the RestCliend
+=end
+    def []= key, val
+      val = val.rid if val.is_a? ActiveOrient::Model
+#      if val.is_a?(Array) # && @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?( key.to_s+"=n" )
+#	if @metadata[ :fieldTypes ] =~ /out=x,in=x/
+#	puts "VAL is a ARRAY"
+#	else
+#	  puts "METADATA: #{ @metadata[ :fieldTypes ]}  "
+#	end
+#	val# = val.map{|x|  if val.is_a? ActiveOrient::Model then val.rid else val end }
+#      end
+      attributes[key.to_sym] = case val
+	 when Array
+	   if  val.first.is_a?(Hash)
+	     v=val.map do |x| 
+	       if x.is_a?( Hash ) 
+		 HashWithIndifferentAccess.new(x)
+	       else
+		 x 
+	       end
+	     end
+	     OrientSupport::Array.new( self, *v )
+	   else
+	     OrientSupport::Array.new( self, *val )
+	   end
+	 when Hash
+	    HashWithIndifferentAccess.new(val) 
+	 else
+	   val
+	 end
+      
+    end
+
+    def to_model
+      self
+    end
+
+
+
+    ### Noop methods mocking ActiveRecord::Base macros
+    
+    def self.attr_protected *args
+    end
+
+    def self.attr_accessible *args
+    end
+
+    ### ActiveRecord::Base association API mocks
+
+    def self.belongs_to model, *args
+      attr_accessor model
+    end
+
+    def self.has_one model, *args
+      attr_accessor model
+    end
+
+    def self.has_many models, *args
+      attr_accessor models
+
+      define_method(models) do
+        self.instance_variable_get("@#{models}") ||
+          self.instance_variable_set("@#{models}", [])
+      end
+    end
+
+    def self.find *args
+      []
+    end
+
+    ### ActiveRecord::Base callback API mocks
+
+    define_model_callbacks :initialize, :only => :after
+
+    ### ActiveRecord::Base misc
+
+    def self.serialize *properties
+    end
+
+  end # Model
+end # module