active-orient 0.4 → 0.80

data/lib/support.rb

@@ -1,347 +0,0 @@
-class String
-  def to_classname
-    if self[0] =='$'
-      self[1..-1]
-    else
-      self.camelize 
-    end
-  end
-  def to_orient
-    self.gsub /%/, '(percent)'
-
-  end
-    def rid? 
-      self =~  /\A[#]{,1}[0-9]{1,}:[0-9]{1,}\z/   
-    end
-    def from_orient
-	if rid? 
-	  ActiveOrient::Model.autoload_object  self
-	else
-	  self
-	end
-    end
-    ## this enables the universal use of an rid-string as pseudonym for a ActiveOrient::Model
-    alias :reload! from_orient
-end
-class NilClass
-  def to_orient
-   self 
-  end
-end
-class Symbol
-  def to_orient
-    self.to_s.to_orient
-  end
-  def from_orient
-    self
-  end
-end
-
-class Numeric
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
-
-class Time 
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
-class Date
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
-
-class TrueClass
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
-class FalseClass
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
-
-class Array
-    def to_orient
-      map &:to_orient
-    end
-    def from_orient
-      map &:from_orient
-    end
-end
-class Hash #WithIndifferentAccess
-  def from_orient
-    substitute_hash = HashWithIndifferentAccess.new
-    keys.each{ |k| puts self[k].inspect }
-    keys.each{| k | substitute_hash[k] =  self[k].from_orient  }
-    substitute_hash	      
-
-  end
-  def to_orient
-    substitute_hash = Hash.new
-    keys.each{| k | substitute_hash[k] =  self[k].to_orient  }
-    substitute_hash	      
-
-  end
-
-    def nested_under_indifferent_access
-        HashWithIndifferentAccess.new self
-    end
-end
-
-
-module OrientSupport
-
-  module Support
-=begin
-supports 
-
-where: 'string'
-where: { property: 'value', property: value, ... }
-where: ['string, { property: value, ... }, ... ]
-
-
-Used by update and select
-=end
-
-    def compose_where *arg
-      arg=arg.flatten
-      return "" if arg.blank? || arg.size == 1 && arg.first.blank?
-     "where " + arg.map do |issue|
-       case issue
-       when String
-	  issue
-       when Hash
-	 generate_sql_list issue
-      end
-     end.join( ' and ' )
-    end
-    def generate_sql_list attributes={}
-      attributes.map do | key, value |
-	case value
-	when Numeric
-	  key.to_s << " = " << value.to_s 
-	else #  String, Symbol, Date, Time, Trueclass, Falseclass ...
-	  key.to_s << ' = ' << "\'#{ value }\'"
-	end
-      end.join( ' and ' )
-    end
-    end  # module
-
-
-    class OrientQuery
-
-    include Support
-
-      def initialize  **args
-	@projection = []
-	@misc = []
-	@let  = []
-	@where = []
-	@order = []
-	args.each do | k,v|
-	  case k
-	   when :projection
-	    @projection << v
-	   when :let
-	    @let << v
-	   when :order
-	    @order << v
-	   when :where
-	    @where << v
-	  else
-	    self.send k, v
-	  end
-	end
-      end
-
-      def method_missing method, *arg, &b
-	@misc << method.to_s << " " << arg.map(&:to_s).join(' ')
-      end
-
-      def misc
-	@misc.join(' ') unless @misc.empty?
-      end
-
-      def subquery
-	nil
-      end
-
-      def compose
-	[ "select", projection_s,  from, let_s, where_s , subquery,  misc, order_s , group_by, unwind, skip ].compact.join(' ')
-      end
-
-      alias :to_s  :compose
-=begin
-from can either be a Databaseclass to operate on or a Subquery providing data to query further 
-=end
-      def from arg=nil
-	if arg.present?
-	  @database = case arg 
-		      when Class
-			arg.new.classname
-		      when ActiveOrient::Model
-			classname
-		      when String
-			arg
-		      when Symbol
-			arg
-		      when OrientQuery
-			arg
-		      end
-	  compose  # return the complete query
-	else # read from
-	  "from " <<  @database.to_s  unless @database.nil?
-	  end
-	end
-      alias :from= :from
-      def database_class= arg
-	@database =  arg if @database.present?
-	if @from.is_a? OrientQuery
-	  @from.database_class= arg
-	end
-      end
-      def database_class
-	if @database.present?
-	  @database
-	elsif @from.is_a? OrientQuery
-	  @from.database_class
-	else
-	  nil
-	end
-      end
-
-
-=begin
-Call where without a parameter to request the saved where-string
-
-to create the where-part of the query a string, a hash or an Array is supported
-
-where: "r > 9"                          --> where r > 9
-where: {a: 9, b: 's'}                   --> where a = 9 and b = 's'
-where:[{ a: 2} , 'b > 3',{ c: 'ufz' }]  --> where a = 2 and b > 3 and c = 'ufz'
-=end
-      attr_accessor :where
-      def where_s
-	compose_where @where
-      end
-
-
-      attr_accessor :let
-      def let_s
-	unless @let.empty?
-	  "let " << @let.map do |s|
-	   case s
-	  when Hash
-	    s.map{ |x,y| "$#{x} = ( #{y} )"}.join( ', ')
-	  when Array
-	    s.join(',  ')
-	  else
-	    s
-	  end
-	  end.join(', ')
-	end
-      end
-
-      def distinct d
-	@projection << case d
-			    when String, Symbol
-			        "distinct( #{d.to_s} )"  
-			    when Array
-			        "distinct( #{d.first} ) as #{d.last}"
-			    when Hash
-			        "distinct( #{d.first.first} ) as #{d.first.last}"
-			    else
-			      ""
-			    end 
-	compose  # return the hole query
-      end
-      alias :distinct= :distinct
-
-      attr_accessor :projection
-      def projection_s
-
-	  @projection.map do | s |
-		case s
-			  when Hash
-			    s.map{ |x,y| "#{x} as #{y}"}.join( ', ')
-			  when Array
-			    s.join(', ')
-			  else
-			    s
-			  end
-	  end.join( ', ' )
-
-      end
-
-
- #     def where= w
-
- #     end
-#        select_string = ("select " + select_string + distinct_string + ' from ' + class_name(o_class) ).squeeze(' ')
-#	where_string =  compose_where( where )
-      def group_by g=nil
-	@group = "group_by  #{g.to_s}" if g.present?
-	# only a string is allowed
-	@group  # return_value
-      end
-      def unwind u=nil
-	@unwind = "unwind  #{u.to_s}" if u.present?
-	# only a string is allowed
-	@unwind  # return_value
-      end
-
-      def skip n=nil
-	@skip= n if n.present?
-	"skip #{@skip}" if @skip.present?
-      end
-
-      attr_accessor :order
-
-      def order_s 
-	unless @order.empty?
-	 # the [@order] is nessesary to enable query.order= "..." oder query.order= { a: :b }  
-	  "order by " << [@order].flatten.map do | o |
-	    case o
-	    when  Hash 
-	      o.map{ |x,y| "#{x} #{y}" }.join( " " )
-	    else
-	      o.to_s
-	    end  # case
-	  end.join(', ')
-	else
-	  ''
-	end
-      end
-#	misc_string = if skip > 0 && limit > 0 
-#			" skip: #{skip} "
-#		      else
-#			""
-#		      end
-#	#
-#
-#      def compose
-#
-#      end
-
-    end
-  end # module

data/test.rb

@@ -1,4 +0,0 @@
-$:.unshift File.expand_path('.')
-require 'config/boot'
-
-

data/usecase.md

@@ -1,91 +0,0 @@
-## Usecase
-Below some typical features are summarized by example
-
-Start a irb-session and initialize ActiveOrient
- ```ruby
-topo@gamma:~/new_hctw$ irb
-2.2.1 :001 > require './config/boot'
-  Using development-environment
-  -------------------- initialize -------------------- => true 
-2.2.1 :002 > ActiveOrient::Model.orientdb = ror = ActiveOrient::OrientDB.new
-    => #<ActiveOrient::OrientDB:0x000000046f1a90 @res=#<RestClient::Resource:0x000000046c0af8 @url="http://localhost:2480", @block=nil, @options={:user=>"hctw", :password=>"**"}>, @database="hc_database", @classes=[]> 
-```
-#### Object Mapping
-Lets create a class, put some content in it and perform basic oo-steps.
-
-Attributes(Properties) do not have to be formaly declared. However it is nessessary to introduce them properly. This is done with the »attributes«-Argument during the initialisation step or via
-»update«  
-
-``` ruby
-  A =  r.create_class 'my_a_class'
-  => ActiveOrient::Model::Myaclass
-  a = A.new_document attributes: { test: 45}
-  a.update set: { a_array: aa= [ 1,4,'r', :r ]  , 
-                  a_hash: { :a => 'b', b: 2 } }
-  a.to_human
-  => <Myaclass: a_array: [1, 4, "r", :r] a_hash: {:a=>"b", :b=>2} test: 45>
-
-```
-Then the attibutes/properties can be handled as normal ruby objects ie.
- 
-``` ruby
-  a.a_array << "a new element"
-  a.a_hash[ :a_new_element ] =  "value of the new element"
-  a.test += 3
-  a.test =  567
-  a.update
-```
-Objects are synchronized with the database with »update«. To revert changes, a »reload!« method is available. 
-
-#### Contracts-Example
-Assume a Database, which is defined as
-```
-  create class Industries
-  create class Categories
-  create class SubCategories
-  create class OpenInterest ABSTRACT
-  create class Stocks extends Contracts
-  create class Futures extends Contracts
-  create class Options extends Contracts
-  create class Forexes extends Contracts
-  create property Industries.categories linkset
-  create property Categories.subcategories linkset
-  create property Categories.industry link
-  create property SubCategories.category link
-  create property SubCategories.contracts linkset
-
-  create property Contracts.subcategory link
-  create property Contracts.details link
-  create property OpenInterest.contracts linkset
-
-```
-This defines some conventional relations:
-
-OpenInterest -> Contracts <- Subcategory <- Category <- Industry
-
-with some oo-Behavior
-```ruby
-2.2.1 :003 > ror.class_hierachie base_class: 'Contracts'
- => ["Forexes", "Futures", "Options", "Stocks"] 
-```
-
-then the following ORM-behavior is implemented:
- ```ruby
-topo@gamma:~/new_hctw$ irb
-2.2.1 :001 > require './config/boot'
-  Using development-environment
-  -------------------- initialize -------------------- => true 
-2.2.1 :002 > ActiveOrient::Model.orientdb = ror = ActiveOrient::OrientDB.new
- => #<ActiveOrient::OrientDB:0x000000046f1a90 @res=#<RestClient::Resource:0x000000046c0af8 @url="http://localhost:2480", @block=nil, @options={:user=>"hctw", :password=>"**"}>, @database="hc_database", @classes=[]> 
-2.2.1 :003 > OpenInterest =  ror.open_class 'Openinterest'
- => ActiveOrient::Model::Openinterest 
-2.2.1 :004 > first_open_interest = OpenInterest.first
- => #<ActiveOrient::Model::Openinterest:0x0000000443ede8 @metadata={"type"=>"d", "class"=>"Openinterest", "version"=>5, "fieldTypes"=>"fetch_date=t,contracts=z", "cluster"=>13, "record"=>0}, @attributes={"fetch_date"=>"2015-06-02 00:00:00", "contracts"=>["#21:36", "#21:35", "#21:34", "#21:33", "#21:32", "#21:31", "#21:30", "#21:29", "#21:28", "#21:27", "#21:26", "#21:25", "#21:24", "#21:23", "#21:22", "#21:21", "#21:51", "#21:49", "#21:50", "#21:47", "#21:48", "#21:45", "#21:46", "#21:43", "#21:44", "#21:41", "#21:42", "#21:39", "#21:40", "#21:37", "#21:38", "#21:4", "#21:3", "#21:0", "#21:17", "#21:18", "#21:19", "#21:20", "#21:13", "#21:14", "#21:15", "#21:16", "#21:9", "#21:10", "#21:11", "#21:12", "#21:5", "#21:6", "#21:7", "#21:8"], "created_at"=>2015-07-01 15:27:41 +0200, "updated_at"=>2015-07-01 15:27:41 +0200}> 
-2.2.1 :005 > first_open_interest.contracts.first.subcategory.category.industry
- => #<ActiveOrient::Model::Industries:0x00000004af88f0 @metadata={"type"=>"d", "class"=>"Industries", "version"=>8, "fieldTypes"=>"categories=n", "cluster"=>17, "record"=>1}, @attributes={"categories"=>["#15:13", "#15:4", "#15:1"], "name"=>"Basic Materials", "created_at"=>2015-07-01 15:27:58 +0200, "updated_at"=>2015-07-01 15:27:58 +0200}> 
-
-2.2.1 :006 > first_open_interest.contracts.first.subcategory.category.industry.name
- => "Basic Materials"
-```
-
-