arcadedb 0.3.1 → 0.3.3

data/lib/support/model.rb

@@ -0,0 +1,84 @@
+module Arcade
+  module Support
+    module Model
+
+      def resolve_edge_name *edge_names
+        edge_names.map do | edge_name |
+          case  edge_name
+          when nil
+            ""
+          when Class
+            "'" + edge_name.database_name + "'"
+          when String
+            "'" + edge_name + "'"
+          end
+        end.join(',')
+      end
+
+
+    #  used by array#allocate_model
+      def _allocate_model response=nil, auto = Config.autoload
+
+      if response.is_a? Hash
+        # save rid to a safe place
+        temp_rid = response.delete :"@rid"
+
+        return response if temp_rid.rid?.nil?
+        # extract type infos  and convert to database-name
+        type           = response.delete :"@type"
+        cat            = response.delete :"@cat"
+        n, type_name = type.camelcase_and_namespace
+        n = self.namespace if n.nil?
+        # autoconvert rid's in attributes to model-records  (exclude edges!)
+        if auto && !(cat.to_s =='e')
+          response.transform_values! do  |x|
+            case x
+            when String
+              x.rid? ?  x.load_rid : x
+            when Array
+              x.map do| y |
+                if y.is_a?(Hash) && y.include?(:@type)   # if embedded documents are present, load them
+                  y.merge( rid: '#0:0' ).allocate_model(false)
+                elsif y.rid?                             # if links are present, load the object
+                  y.load_rid(false) # do not autoload further records, prevents from recursive locking
+                else
+                  y
+                end
+              end
+            when Hash
+              if x.include?(:@type)
+                x.merge( rid: '#0:0' ).allocate_model(false)
+              else
+                x.transform_values!{|z|  z.rid? ?  z.load_rid(false) : z }
+              end
+            else
+              x
+            end
+          end
+        end
+        # choose the appropriate class
+        klass=  Dry::Core::ClassBuilder.new(  name: type_name, parent:  nil, namespace:  n).call
+        #
+      begin
+        # create a new object of that  class with the appropriate attributes
+        new = klass.new  **response.merge( rid: temp_rid || "#0:0" )  # #0:0 --> embedded model records
+      rescue ::ArgumentError => e
+        raise  "Allocation of class #{klass.to_s} failed"
+      end
+        # map additional attributes to `input`
+        v =  response.except  *new.attributes.keys
+        v.empty? ?  new  :  new.new( values: v.except( :"@in", :"@out" ) )
+     elsif response.is_a? Array
+       puts "Allocate_model..detected array"
+       ## recursive behavior, just in case
+       response.map{ | y | _allocate_model y }
+     elsif response.rid?
+       # Autoload rid's
+       response.load_rid
+     else
+       response
+      end
+    end
+    end
+  end
+end

data/lib/support/object.rb

@@ -0,0 +1,20 @@
+module Arcade
+  module Support
+    module Object
+      # this is the rails method
+       def present?
+         !blank?
+       end
+
+       # File activesupport/lib/active_support/core_ext/object/blank.rb, line 46
+       def presence
+          self if present?
+       end
+       # File activesupport/lib/active_support/core_ext/object/blank.rb, line 19
+       def blank?
+         respond_to?(:empty?) ? !!empty? : !self
+       end
+    end
+  end
+end
+Object.include Arcade::Support::Object

data/lib/support/sql.rb

@@ -0,0 +1,74 @@
+#require 'active_support/inflector'
+
+module Arcade
+  module Support
+    module Sql
+
+=begin
+supports
+  where: 'string'
+  where: { property: 'value', property: value, ... }
+  where: ['string, { property: value, ... }, ... ]
+
+Used by update and select
+
+_Usecase:_
+  compose_where 'z=34', u: 6
+  => "where z=34 and u = 6" 
+=end
+
+      def compose_where *arg , &b
+        arg = arg.flatten.compact
+
+        unless arg.blank? 
+          g= generate_sql_list( arg , &b)
+          "where #{g}" unless g.empty?
+        end
+      end
+
+=begin
+designs a list of "Key =  Value" pairs combined by "and" or the binding  provided by the block
+   ORD.generate_sql_list  where: 25 , upper: '65'
+    => "where=25 and upper='65'"
+   ORD.generate_sql_list(  con_id: 25 , symbol: :G) { ',' }
+    => "con_id=25 , symbol='G'"
+
+If »NULL« should be addressed, { key: nil } is translated to "key = NULL"  (used by set:  in update and upsert),
+{ key: [nil]  } is translated to "key is NULL" ( used by where )
+
+=end
+      def generate_sql_list attributes = {},  &b
+        fill = block_given? ? yield : 'and'
+        case attributes
+        when ::Hash
+          attributes.map do |key, value|
+            case value
+            when nil
+              "#{key}=NULL"
+            when ::Array
+              if value == [nil]
+                "#{key} is NULL"
+              else	
+                "#{key} in #{value.to_db}"
+              end
+            when Range
+              "#{key} between #{value.first.to_or} and #{value.last.to_or} "
+            else #  String, Symbol, Time, Trueclass, Falseclass ...
+              "#{key}=#{value.to_or}"
+            end
+          end.join(" #{fill} ")
+        when ::Array
+          attributes.map{|y| generate_sql_list y, &b }.join( " #{fill} " )
+        when String
+          attributes
+        when Symbol, Numeric
+          attributes.to_s
+        end
+      end
+
+
+      # used both in Query and MatchConnect
+      # while and where depend on @q, a struct
+    end  # module
+  end # module
+end # modul

data/lib/support/string.rb

@@ -0,0 +1,116 @@
+module Arcade
+  module Support
+    module String
+      #modified version of
+       # https://stackoverflow.com/questions/63769351/convert-string-to-camel-case-in-ruby
+      # returns an Array [ Namespace(first character upcase)  , Type(class, camelcase) ]
+      #
+      #  if the namespace is not found, joins all string-parts
+      def camelcase_and_namespace
+        if  self.count("_")  >= 1 || self.count('-') >=1
+          delimiters = Regexp.union(['-', '_'])
+          n,c= self.split(delimiters).then { |first, *rest| [first.tap {|s| s[0] = s[0].upcase}, rest.map(&:capitalize).join]  }
+          ## if base is the first part of the type-name, probably Arcade::Base is choosen a namespace. thats wrong
+          namespace_present = unless n == 'Base'
+                                Object.const_get(n)  rescue  false # Database.namespace
+                              else 
+                                false
+          end
+          # if no namespace is found, leave it empty and return the capitalized string as class name
+          namespace_present && !c.nil? ? [namespace_present,c] : [Database.namespace, n+c]
+        else
+          [ Database.namespace, self.capitalize ]
+        end
+      end
+
+      def snake_case
+        n= if split('::').first == Database.namespace.to_s
+           split('::')[1..-1].join
+         else
+           split("::").join
+         end
+       n.gsub(/([^\^])([A-Z])/,'\1_\2').downcase
+      end
+
+  # borrowed  from ActiveSupport::Inflector
+      def underscore
+        word = self.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+      def capitalize_first_letter
+        self.sub(/^(.)/) { $1.capitalize }
+      end
+  # a rid is either #nn:nn or nn:nn
+      def rid?
+        self =~ /\A[#]{,1}[0-9]{1,}:[0-9]{1,}\z/
+      end
+#  return a valid rid (format: "nn:mm") or nil
+      def rid
+        self["#"].nil? ? "#"+ self : self if rid? 
+      end
+
+      def where **args
+        if rid?
+          from_db.where **args
+        end
+      end
+      def to_a
+        [ self ]
+      end
+
+      def quote
+        str = self.dup
+        if str[0, 1] == "'" && str[-1, 1] == "'"
+          self
+        else
+          last_pos = 0
+          while (pos = str.index("'", last_pos))
+            str.insert(pos, "\\") if pos > 0 && str[pos - 1, 1] != "\\"
+            last_pos = pos + 1
+          end
+          "'#{str}'"
+        end
+      end
+
+      ## Load the database object if the string is a rid
+      # (Default: No Autoloading of rid-links)
+      def load_rid autocomplete = false
+        db.get( self ){  autocomplete }  if rid?  rescue nil
+      end
+
+      # updates the record    ### retired in favour of Arcade::Base.update
+   #   def update **args
+        ## remove empty Arrays and Hashes.
+        ## To remove attributes, use the remove syntax, do not privide empty fields to update!
+   #     args.delete_if{|_,y|( y.is_a?(Array) || y.is_a?(Hash)) && y.blank? }
+   #     return nil if args.empty?
+   #     Arcade::Query.new( from: self , kind: :update, set: args).execute
+   #   end
+
+      def to_human
+        self
+      end
+      private
+      def db
+        Arcade::Init.db
+      end
+    end
+  end
+end
+
+String.include Arcade::Support::String
+
+module Types
+  include Dry.Types()
+
+  # include in attribute definitions
+  Rid = String.constrained( format:  /\A[#]{1}[0-9]{1,}:[0-9]{1,}\z/ )
+  Blockchain =  String.constrained( format: /^(algo|eth|btc)$/ )  #  add other blockchain symbols here
+  Email = String.constrained( format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i )
+
+end

data/rails/arcade.rb

@@ -0,0 +1,20 @@
+
+## This is an init-script intended to be copied to
+## rails-root/config/initializers
+
+module Arcade
+  ProjectRoot =  Rails.root 
+  puts "Root: #{Rails.root}"
+  puts "Alternative: #{File.expand_path("../",__FILE__)}"
+end
+## Integrate a namespaced model
+#module HC
+#
+#end
+
+
+
+
+
+
+

data/rails/config.yml

@@ -0,0 +1,10 @@
+---
+:active_orient:
+## Namespace: Prefix of Model-Objects. :self -> ActiveOrient::Model::{name}
+##				       :object => No Prefix
+##				       :active_orient => ActiveOrient::{name}
+ :namespace: :object
+## model_dir: Path to model-files relative to the root of the application
+## ie. app/model  or model
+ :model_dir: 'lib/orient'
+

data/rails/connect.yml

@@ -0,0 +1,17 @@
+---
+:orientdb:
+ :server: localhost # 172.28.50.109 
+ :port: 2480
+ :logger: stdout           # 'file' or 'stdout'
+ :database: 
+   :development: GratefulDeadConcerts
+   :production: hcn_data
+   :test:  temp
+ :admin:
+   :user: root
+   :pass: root
+ :auth:
+   :user: root
+   :pass: root
+
+# hfx: 101

data/rails.md

@@ -0,0 +1,147 @@
+# ArcadeDB and Rails
+
+The usage of ArcadeDB in Rails requires just a few steps.
+Based on a Rails 7 installation
+
+```ruby
+  rvm install 3.1 
+  rvm use 3.1
+  gem install bundler
+  gem install rails
+  rails -v   # Rails 7.xx
+```
+
+Create your working directory and initialize the system
+
+```ruby
+mkdir rails_project; cd rails_project
+rails new -OCT -css {tailwind, sass, bulma etc} .
+```
+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
+./bin/dev
+```
+should work at this stage.
+
+## Modify the Gemfile
+Inform rails to use arcadedb
+
+```
+echo " gem 'arcadedb' , :path => '/home/your_cloned_active_orient_path/activeorient' " >> Gemfile
+# or
+
+echo " gem 'arcadedb' , :git => 'https://github.com/topofocus/arcadedb.git' " >> Gemfile
+
+```
+
+Run the  bundler
+
+```
+bundle install & bundle update
+```
+## Copy Initializer and Configuration Files
+change to the base-dir of the gem
+-->  bundle show active-orient
+then copy 
+
+* rails/arcade.rb   to  config/initializers  in the rails-project dir
+* rails/.arcade.yml  to config/   in the rails project
+
+and modify the arcade.yml-file accordingly. 
+
+
+The database is present in the rails console, and 
+```ruby
+rails c
+puts DB.types
+
+
+```
+should display details.
+
+
+**Notice** The spring-facility is running in the background. Stop the server prior reloading
+the console ( ./bin/spring stop ). 
+
+## Model-files
+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'. Change to your needs.
+Don't use the app directory, as its autoloaded too early. 
+
+Upon startup, present model-classes are destroyed and overridden by present files in the autoload directory. 
+
+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 ]  # -->  "select distinct( type ) as a  " 
+13          query_database( this_query ).a  # returns an array of types, i.e. ["artist", "song"] 
+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. 
+
+## Routing
+
+for now, restful routing has some restrictions.
+
+Rails-routing is depending on the "id"-attribute. Even if this is remapped to rid, the ressources-entries in "config/routes.rb" have to be modified by
+
+```ruiby
+resources  :{controller}, id: /[^\/]+/
+```
+this enables the usage of id: "xx:yy" 
+
+In the controller the record is fetched as usual:
+```ruby
+def show
+    @{your coice} = {ActiveOrient-Model-Class}.autoload_object params[:id]
+end
+```
+
+
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arcadedb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Hartmut Bischoff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-16 00:00:00.000000000 Z
+date: 2023-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,7 +113,52 @@ email: topofocus@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- arcade.yml
+- arcadedb.gemspec
+- bin/+
+- bin/console
+- examples/books.rb
+- examples/relation_1__1.rb
+- examples/relation_1__n.rb
+- examples/relation_n_n.rb
+- lib/arcade.rb
+- lib/arcade/api/operations.rb
+- lib/arcade/api/version.rb
+- lib/arcade/base.rb
+- lib/arcade/database.rb
+- lib/arcade/errors.rb
+- lib/arcade/logging.rb
+- lib/arcade/version.rb
+- lib/config.rb
+- lib/init.rb
+- lib/match.rb
+- lib/model/basicdocument.rb
+- lib/model/basicedge.rb
+- lib/model/basicvertex.rb
+- lib/model/document.rb
+- lib/model/edge.rb
+- lib/model/vertex.rb
+- lib/models.rb
+- lib/query.rb
+- lib/support/class.rb
+- lib/support/conversions.rb
+- lib/support/model.rb
+- lib/support/object.rb
+- lib/support/sql.rb
+- lib/support/string.rb
+- rails.md
+- rails/arcade.rb
+- rails/config.yml
+- rails/connect.yml
 homepage: https://github.com/topofocus/arcadedb
 licenses:
 - MIT
@@ -133,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.6
 signing_key: 
 specification_version: 4
 summary: Ruby Interface to ArcadeDB