arcadedb 0.4 → 0.5.2

data/lib/arcade/api/operations.rb

@@ -9,7 +9,7 @@ module Arcade
   $ Arcade::Api.drop_database   <a string>  # returns true if successfull
 
   $ Arcade::Api.create_document <database>, <type>,  attributes
-  $ Arcade::Api.execute( <database> ) { <query> }
+  $ Arcade::Api.execute( <database>  [, session_id:  some_session_id ]) { <query> }
   $ Arcade::Api.query( <database> ) { <query> }
   $ Arcade::Api.get_record <database>,  rid  #  returns a hash
 
@@ -32,13 +32,20 @@ module Arcade
       get_data 'databases'
     end
 
+    # ------------------------------ database?        ------------------------------------------------- #
+    #  returns true if the database exists                                                              #
+
+    def self.database? name
+      get_data "exists/#{name}"
+    end
+
     # ------------------------------ create database  ------------------------------------------------- #
     #  creates a database if not present                                                                #
     def self.create_database name
       return if databases.include?( name.to_s )
       payload = { "command" => "create database #{name}" }
         post_data  "server", payload
-    rescue HTTPX::HTTPError => e
+    rescue  Arcade::QueryError => e
       logger.fatal "Create database #{name} through \"POST create/#{name}\" failed"
       logger.fatal  e
       raise
@@ -50,29 +57,10 @@ module Arcade
       return unless databases.include?( name.to_s )
       payload = {"command" => "drop database #{name}" }
        post_data  "server",  payload
-    rescue HTTPX::HTTPError => e
+    rescue Arcade::QueryError => e
       logger.fatal "Drop database #{name} through \"POST drop database/#{name}\" failed"
       raise
     end
-    # ------------------------------  create document ------------------------------------------------- #
-    # adds a document to the specified database table
-    #
-    # specify database-fields as hash-type parameters
-    #
-    # i.e   Arcade::Api.create_document 'devel', 'documents',  name: 'herta meyer', age: 56, sex: 'f'
-    #
-    # returns the rid of the inserted dataset
-    #
-    def self.create_document database, type, **attributes
-      payload = { "@type" => type }.merge( attributes )
-      logger.debug "C: #{payload}"
-      options = if session.nil?
-         payload
-                else
-        payload.merge headers: { "arcadedb-session-id" => session }
-                end
-      post_data "document/#{database}", options
-    end
 
     # ------------------------------  execute         ------------------------------------------------- #
     # executes a sql-query in the specified database
@@ -84,21 +72,40 @@ module Arcade
     # Arcade::Api.execute( "devel" ) { 'select from test  ' }
     #  =y [{"@rid"=>"#57:0", "@type"=>"test", "name"=>"Hugo"}, {"@rid"=>"#60:0", "@type"=>"test", "name"=>"Hubert"}]
     #
-    def self.execute database, query=nil, session_id= nil
-      pl = query.nil? ? provide_payload(yield) : provide_payload(query)
-      if session_id.nil? && session.nil?
+    def self.execute database, session_id: nil
+      pl = provide_payload(yield)
+      if session_id.nil?
         post_data "command/#{database}" , pl
       else
-        post_transaction "command/#{database}" , pl, session_id || session
+        post_transaction "command/#{database}" , pl, session_id: session_id
       end
     end
 
     # ------------------------------  query           ------------------------------------------------- #
     # same for idempotent queries
-    def self.query database, query
-      post_data   "query/#{database}" , provide_payload(query)
+    def self.query database, query, session_id: nil
+#      if session_id.nil?
+        get_data   "query/#{database}/sql/" + provide_payload(query, action: :get)[:query]
+ #     else
+ #       post_transaction "query/#{database}" , provide_payload(query), session_id: session_id
+ #     end
     end
 
+    # ------------------------------  create Document   ------------------------------------------------- #
+    # adds a record ( document, vertex or edge ) to the specified database type
+    #
+    # specify database-fields as hash-type parameters
+    #
+    # i.e   Arcade::Api.create_record 'devel', 'documents',  name: 'herta meyer', age: 56, sex: 'f'
+    #
+    # returns the rid of the inserted dataset
+    #
+    def self.create_document database, type, session_id: nil, **attributes
+        content = "CONTENT #{ attributes.to_json }"
+        result = execute( database, session_id: session_id ){ "INSERT INTO #{type} #{content} "}
+        result.first[:@rid]   #  emulate the »old« behavior of the /post/create_document api endpoint
+    end
+    
     # ------------------------------  get_record      ------------------------------------------------- #
     # fetches a record by providing  database and  rid
     # and returns the result as hash
@@ -112,7 +119,7 @@ module Arcade
       rid =  rid.join(':')
       rid = rid[1..-1] if rid[0]=="#"
       if rid.rid?
-      get_data  "document/#{database}/#{rid}"
+        get_data( "query/#{database}/sql/" + URI.encode_uri_component("select from #{rid}")) &.first
       else
         raise Error "Get requires a rid input"
       end
@@ -133,21 +140,17 @@ module Arcade
     #
     def self.property database, type, **args
 
-      begin_transaction database
+      s= begin_transaction database
       success = args.map do | name, format |
-        r= execute(database) {" create property #{type.to_s}.#{name.to_s} #{format.to_s} " } &.first
-        puts "R: #{r.inspect}"
-        if r.nil?
-          false
-        else
-          r[:operation] == 'create property'
-        end
+        r= execute(database, session_id: s) {" create property #{type.to_s}.#{name.to_s} #{format.to_s} " } &.first
+        r.nil? ?  false : r[:operation] == 'create property'
       end.uniq
       if success == [true]
-        commit database
+        commit database, session_id: s
         true
       else
-        rollback database
+        rollback database log: false, session_id: s
+        false
       end
 
 
@@ -160,9 +163,6 @@ module Arcade
       unique_requested = "notunique" if  properties.delete("notunique" )
       automatic = true if
       properties << name  if properties.empty?
- #    puts " create index  #{type.to_s}[#{name.to_s}] on #{type} ( #{properties.join(',')} ) #{unique_requested}"
-      #    VV 22.10: providing an index-name raises an  Error (  Encountered " "(" "( "" at line 1, column 44. Was expecting one of:     <EOF>      <SCHEMA> ...     <NULL_STRATEGY> ...     ";" ...     "," ...   )) )
-      #    named  indices droped for now
       success = execute(database) {" create index IF NOT EXISTS on #{type} (#{properties.join(', ')}) #{unique_requested}" } &.first
 #      puts "success: #{success}"
        success[:operation] == 'create index'
@@ -176,9 +176,6 @@ module Arcade
        Database.logger
      end
 
-    def self.session
-      @session_id
-    end
 
     def self. provide_payload( the_yield, action: :post )
       unless the_yield.is_a? Hash
@@ -189,7 +186,11 @@ module Arcade
                                 the_yield.map do | key,  value |
                                   case key
                                   when :query
-                                   action == :post ? [ :command, value ] : [ :query, value ]
+                                    if action == :post
+                                      [ :command, value ]
+                                    else
+                                      [ :query, URI.encode_uri_component(value )]
+                                    end
                                   when :limit
                                     [ :limit , value ]
                                   when :params
@@ -207,7 +208,7 @@ module Arcade
                                       [ :serializer, value.to_sym ]
                                     end
                                   when :language
-                                    if [:sql, :cypher, :gremlin, :neo4j ].include? value.to_sym
+                                    if [:sql, :cypher, :gremlin, :neo4j, :sqlscript, :graphql, :mongo ].include? value.to_sym
                                       [ :language,  value.to_sym ]
                                     end
                                   end # case
@@ -216,42 +217,11 @@ module Arcade
 
 
 
-    # returns the json-response   ## retiered
-    def self.analyse_result r, command
-      if r.success?
-          return nil  if r.status == 204  # no content
-          result = JSON.parse( r.response_body, symbolize_names: true )[:result]
-          if result == [{}]
-           []
-          else
-            result
-          end
-        elsif r.timed_out?
-          raise Error "Timeout Error", caller
-          []
-        elsif r.response_code > 0
-          logger.error  "Execution Failure – Code: #{ r.response_code } – #{r.status_message} "
-          error_message = JSON.parse( r.response_body, symbolize_names: true )
-          logger.error  "ErrorMessage:  #{ error_message[:detail]} "
-          if error_message[:detail] =~ /Duplicated key/
-            raise IndexError, error_message[:detail]
-          else
-          # available fields:  :detail, :exception, error
-            puts  error_message[:detail]
-            #raise  error_message[:detail], caller
-          end
-        end
-    end
     def self.auth
        @a ||= { httpauth: :basic,
          username: Config.admin[:user],
          password: Config.admin[:pass] }
     end
 
-#  not tested
-    def self.delete_data command
-      result  = HTTPX.delete Config.base_uri + command, auth
-      analyse_result(result, command)
-    end
   end
 end

data/lib/arcade/api/primitives.rb

@@ -8,7 +8,13 @@ module Arcade
    # persistent http handle to the database
 
     def http
-      break_on = -> (response) { response.status == 500  }
+#     break_on = -> (response) { response.status == 500  }
+      #     Version 23.12: Persistent connection are inactive after 3 sec.
+      #     Implemented a walk around, that renews the connection after 2 sec. of inactivity
+      t = Time.now
+      @t ||= Time.now
+      @http = nil if t-@t > 2
+      @t = t
       @http ||= HTTPX.plugin(:basic_auth).basic_auth(auth[:username], auth[:password])
                   .plugin(:persistent)
                   .plugin(:circuit_breaker)
@@ -17,8 +23,16 @@ module Arcade
 
     # ------------------------------  get data -------------------------------------------------------- #
     def get_data command
-      response = http.get( Config.base_uri + command )
-      response.raise_for_status
+      case response = http.get( Config.base_uri + command )
+        in {status: 200..299}
+          # success
+        JSON.parse( response.body, symbolize_names: true )[:result]
+         in {status: 400..}
+         raise Arcade::QueryError.new **response.json( symbolize_names: true  )
+      else
+        #   # http error
+             raise   response
+      end
 
       JSON.parse( response.body, symbolize_names: true )[:result]
       #      alternative to `raise for status `
@@ -41,56 +55,77 @@ module Arcade
 
     # ------------------------------ post data -------------------------------------------------------- #
     def post_data command,  payload
-#      http = HTTPX.plugin(:basic_auth)
- #                 .basic_auth(auth[:username], auth[:password])
-      response = http.post( Config.base_uri + command, json:  payload )
-      response.raise_for_status
-      JSON.parse( response.body, symbolize_names: true )[:result]
+        case response = http.post( Config.base_uri + command, json:  payload )
+        in {status: 200..299}
+          # success
+        JSON.parse( response.body, symbolize_names: true )[:result]
+         in {status: 400..}
+           detail = response.json( symbolize_names: true )[:detail]
+           if  detail =~ /Please retry the operation/ 
+             logger.error "--------------------------------"
+             logger.error " ----> Operation repeated <---- "
+             logger.error detail
+             logger.error "The query --> #{payload.inspect}"
+             logger.error "--------------------------------"
+             sleep 1
+             post_data command,  payload
+           else
+             raise Arcade::QueryError.new **response.json( symbolize_names: true  )
+           end
+      else
+        #   # http error
+             raise   response
+      end
+  #    response.raise_for_status
     end
 
     # ------------------------------ transaction      ------------------------------------------------- #
     #
+    # The payload, optional as a JSON, accepts the following parameters:
+    # isolationLevel:  READ_COMMITTED (default)  or REPEATABLE_READ.  (not implemented)
+    #
     def begin_transaction database
       result  = http.post Config.base_uri + "begin/#{database}"
-      @session_id = result.headers["arcadedb-session-id"]
       # returns the session-id
+      result.headers["arcadedb-session-id"] 
     end
 
     # ------------------------------ post transaction ------------------------------------------------- #
-    def post_transaction command, params, session_id= @session_id
-     # http = HTTPX.plugin(:basic_auth)
-     #             .basic_auth(auth[:username], auth[:password])
-     #             .with( headers: { "arcadedb-session-id"=>session }, debug_level: 1)
+    def post_transaction command, params, session_id:
       http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
-      response = http_a.post( Config.base_uri + command, json:  params )
-      response.raise_for_status
-      JSON.parse( response.body, symbolize_names: true )[:result]
-
+      puts "params #{params.inspect}"
+      case response = http_a.post( Config.base_uri + command, json:  params )
+        in {status: 200..299}
+          # success
+        JSON.parse( response.body, symbolize_names: true )[:result]
+         in {status: 400..}
+           ## debug
+#          puts "Command: #{command}"
+#           puts "params: #{params}"
+#           puts response.json( symbolize_names: true  )
+           raise Arcade::QueryError.new **response.json( symbolize_names: true  )
+      else
+        #   # http error
+             raise   response
+      end
     end
 
     # ------------------------------ commit           ------------------------------------------------- #
-    def commit database, session_id = @session_id
+    def commit database, session_id:
       http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
       response = http_a.post( Config.base_uri + "commit/#{database}" )
-      response.raise_for_status
-      @session_id =  nil
       response.status  #  returns 204 --> success
-                       #          403 --> incalid credentials
+                       #          403 --> invalid credentials
                        #          500 --> Transaction  not begun
 
     end
 
     # ------------------------------ rollback         ------------------------------------------------- #
-    def rollback database, session_id = @session_id, publish_error=true
-    #  http = HTTPX.plugin(:basic_auth)
-    #              .basic_auth(auth[:username], auth[:password])
-    #              .with( headers: { "arcadedb-session-id"=>session_id }, debug_level: 1)
+    def rollback database, session_id: , log: true
       http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
       response = http_a.post( Config.base_uri + "rollback/#{database}" )
-      response.raise_for_status
-      @session_id =  nil
-      logger.error  "A Transaction has been rolled back"  # if publish_error
-      response.status
+      logger.info  "A Transaction has been rolled back"   if log
+      response.status    # returns 500 !
     end
   end
  end

data/lib/arcade/base.rb

@@ -1,4 +1,5 @@
 module Arcade
+
   class Base  < Dry::Struct
 
     extend Arcade::Support::Sql
@@ -20,6 +21,9 @@ module Arcade
     ## ----------------------------------------- Class Methods------------------------------------ ##
     #                                                                                               #
     class << self
+     def descendants
+         ObjectSpace.each_object(Class).select { |klass| klass < self }
+     end
 
       # this has to be implemented on class level
       # otherwise it interfere  with attributes
@@ -27,6 +31,16 @@ module Arcade
         self.name.snake_case
       end
 
+      def begin_transaction
+        db.begin_transaction
+      end
+      def  commit
+        db.commit
+      end
+      def rollback
+        db.rollback
+      end
+
       def create_type
         the_class = nil   # declare as local var
         parent_present = ->(cl){ db.hierarchy.flatten.include? cl }
@@ -67,7 +81,7 @@ module Arcade
           the_command =  command[0 .. -2]  #  remove '\n'
           next if the_command == ''
         #  db.logger.info "Custom Setup:: #{the_command}"
-          db.execute { the_command }
+          db.transmit { the_command }
         end unless custom_setup.nil?
 
         rescue RollbackError => e
@@ -118,9 +132,11 @@ module Arcade
       #        (not supported (jet): [RETURN <expression>] [FROM <query>] )
 
       def insert **attributes
-        db.insert type: database_name, **attributes
+        db.insert type: database_name, session_id: attributes.delete(:session_id), **attributes
       end
 
+      alias  create insert
+
       ## ----------------------------------------- create       ---------------------------------- ##
       #
       #  Adds a record to the database
@@ -128,21 +144,21 @@ module Arcade
       #  returns the model dataset
       #  ( depreciated )
 
-      def  create **attributes
-        s = Api.begin_transaction db.database
-        attributes.merge!( created: DateTime.now ) if timestamps
-        record = insert **attributes
-        Api.commit db.database, s
-        record
-      rescue QueryError => e
-        db.logger.error "Dataset NOT created"
-        db.logger.error "Provided Attributes: #{ attributes.inspect }"
-       #  Api.rollback db.database   --->  raises "transactgion not begun"
-      rescue  Dry::Struct::Error => e
-        Api.rollback db.database
-        db.logger.error "#{ rid } :: Validation failed, record deleted."
-        db.logger.error e.message
-      end
+     # def  create **attributes
+     #   s = Api.begin_transaction db.database
+     #   attributes.merge!( created: DateTime.now ) if timestamps
+     #   record = insert **attributes
+     #   Api.commit db.database, s
+     #   record
+     # rescue HTTPX::HTTPError => e
+     #   db.logger.error "Dataset NOT created"
+     #   db.logger.error "Provided Attributes: #{ attributes.inspect }"
+     #   Api.rollback db.database  # --->  raises "transactgion not begun"
+     # rescue  Dry::Struct::Error => e
+     #   Api.rollback db.database
+     #   db.logger.error "#{ rid } :: Validation failed, record deleted."
+     #   db.logger.error e.message
+     # end
 
       def count  **args
         command = "count(*)"
@@ -219,9 +235,9 @@ module Arcade
       #  is equivalent to
       #  Strategie.all.find{|y| y.symbol == 'Still' }
       def find **args
-        f= where(**args).first
-        f= where( "#{ args.keys.first } like #{ args.values.first.to_or }" ).first if f.nil? || f.empty?
-        f
+        where(**args).first
+#        f= where( "#{ args.keys.first } like #{ args.values.first.to_or }" ).first if f.nil? || f.empty?
+#        f
       end
       # update returns a list of updated records
       #
@@ -282,16 +298,19 @@ module Arcade
         Query.new( **{ from: self }.merge(args) )
       end
 
-      # immutable support
-      # to make a database type immutable add
+      # ## Immutable Support
+      #
+      # To make a database type immutable add  
       #  `not_permitted :update, :upsert, :delete`
       # to the model-specification
       #
+      # Even after applying `not_permitted` the database-type can be modified via class-methods.
+      #
       def not_permitted *m
         m.each do | def_m |
-          define_method(  def_m ) do | v = nil |
-          raise ArcadeImmutableError "operation not permitted", caller
-        end
+          define_method( def_m ) do | v = nil |
+            raise  Arcade::ImmutableError.new( "operation  #{def_m} not permitted" )
+          end
         end
       end
 
@@ -354,8 +373,6 @@ module Arcade
     end
 
     def to_human
-
-
 		"<#{ self.class.to_s.snake_case }" + rid? ? "[#{ rid }]: " : " " + invariant_attributes.map do |attr, value|
 			v= case value
 				 when Base
@@ -367,6 +384,9 @@ module Arcade
 				 end
 			"%s : %s" % [ attr, v]  unless v.nil?
 		end.compact.sort.join(', ') + ">".gsub('"' , ' ')
+
+    rescue TypeError => e
+      attributes
     end
 
 
@@ -376,26 +396,44 @@ module Arcade
       to_human
     end
 
+
+    def html_attributes
+      invariant_attributes
+    end
+
+    def in_and_out_attributes
+      _modul, _class =  self.class.to_s.split "::"
+      the_class =  _modul == 'Arcade' ? _class : self.class.to_s
+      the_attributes = { :"CLASS" => the_class, :"IN" => self.in.count, :"OUT" =>  self.out.count, :"RID" => rid  }
+    end
+
     def to_html  # iruby
+      in_and_out = ->(r) { "[#{r}] : {#{self.in.count}->}{->#{self.out.count }}"    }
+      the_rid =  rid? && rid != "0:0" ? in_and_out[rid] : ""
       _modul, _class =  self.class.to_s.split "::"
       the_class =  _modul == 'Arcade' ? _class : self.class.to_s
-      IRuby.display IRuby.html "<b style=\"color: #50953DFF\"><#{ the_class}</b>"
-      + rid? ? "[#{ rid }]: " : " " + invariant_attributes.map do |attr, value|
-        v= case value
-           when Base
-             "< #{ self.class.to_s.snake_case }: #{ value.rid } >"
-           when Array
-             value.map{|x| x.to_s}
-           else
-             value.from_db
-           end
-        "%s : %s" % [ attr, v]  unless v.nil?
-      end.compact.sort.join(', ') + ">".gsub('"' , ' ')
+      #    the_attribute = ->(v) do
+      #      case v
+      #        when Base
+      #          "< #{ self.class.to_s.snake_case  }: #{ v.rid  } >"
+      #        when Array
+      #          v.map{|x| x.to_s}
+      #        else
+      #          v.to_s
+      #        end
+      #    end
+      #     last_part = invariant_attributes.map do |attr, value|
+      #       [ attr, the_attribute[value] ].join(": ")
+      #   end.join(', ') 
+
+      # IRuby.display( [IRuby.html("<span style=\"color: #50953DFF\"><b>#{the_class}</b><#{ the_class }</b>#{the_rid}</span><br/> ")  , IRuby.table(html_attributes) ] )
+      IRuby.display IRuby.html("<span style=\"color: #50953DFF\"><b>#{the_class}</b><#{ the_class }</b>#{the_rid}</span>< #{ html_attributes.map{|_,v|  v }.join(', ')  } >")
     end
 
+
     def update **args
       Query.new( from: rid , kind: :update, set: args).execute
-      refresh
+      refresh   # return the updated record (the object itself is untouched!)
     end
 
     # inserts or updates a embedded document
@@ -406,40 +444,56 @@ module Arcade
                 obj.to_or
               end
 #      if send( name ).nil? || send( name ).empty?
-        db.execute { "update #{ rid } set  #{ name } =  #{ value }" }.first[:count]
+        db.transmit { "update #{ rid } set  #{ name } =  #{ value }" }.first[:count]
 #      end
     end
 
     # updates a single property in an embedded document
     def update_embedded embedded, embedded_property, value
-      db.execute{ " update #{rid} set `#{embedded}`.`#{embedded_property}` =  #{value.to_or}" }
+      db.transmit { " update #{rid} set `#{embedded}`.`#{embedded_property}` =  #{value.to_or}" }
     end
 
-    def update_list list, value
-      value = if value.is_a? Document
+    # Adds List-Elements to embedded List
+    #
+    # Arguments:
+    # * list: A symbol of the list property
+    # * value: A embedded document or a hash
+    # * modus: :auto, :first, :append
+    #
+    # Prefered modus operandi
+    # * the-element.insert  (...) , #{list}:[]
+    # * the_element.update_list list, value: :append
+    #
+    def update_list list, value, modus: :auto
+      value = if value.is_a? Document   # embedded mode
                 value.to_json
               else
                 value.to_or
               end
-      if send( list ).nil? || send( list ).empty?
-        db.execute { "update #{ rid } set  #{ list } =  [#{ value }]" }
+      if modus == :auto
+        modus =  db.query( "select #{list}.size() from #{rid}" ).select_result.first.zero? ? :first : :append
+      end
+
+     if modus == :first
+        db.transmit { "update #{ rid } set  #{ list } = [#{ value }]" }
       else
-        db.execute { "update #{ rid } set  #{ list } += #{ value }" }
+        db.transmit { "update #{ rid } set  #{ list } += #{ value }" }
       end
-      refresh
+     # refresh
     end
 
     # updates a map  property ,  actually adds the key-value pair to the property
+    ## does not work on reduced model records
     def update_map m, key, value
       if send( m ).nil?
-        db.execute { "update #{ rid } set #{ m } = MAP ( #{ key.to_s.to_or } , #{ value.to_or } ) "  }
+        db.transmit { "update #{ rid } set #{ m } = MAP ( #{ key.to_s.to_or } , #{ value.to_or } ) "  }
       else
-        db.execute { "update #{ rid } set #{ m }.`#{ key.to_s }` = #{ value.to_or }" }
+        db.transmit { "update #{ rid } set #{ m }.`#{ key.to_s }` = #{ value.to_or }" }
       end
       refresh
     end
     def delete
-      response = db.execute { "delete from #{ rid }" }
+      response = db.transmit { "delete from #{ rid }" }
       true if response == [{ count: 1 }]
     end
     def == arg

data/lib/{config.rb → arcade/config.rb}

@@ -3,11 +3,11 @@ module Arcade
     extend Dry::Configurable
     # central place to initialize constants
     #
-    # ProjectRoot has to be a Pathname-Object
+    # ProjectRoot should to be a Pathname-Object and has to be defined before `arcadedb`  is required
     #
     #puts "expand: #{File.expand_path(__dir__)}"
-    unless Arcade.const_defined?( :ProjectRoot )
-      Arcade::ProjectRoot = if defined?( Rails.env )
+    unless Object.const_defined?( :ProjectRoot )
+      ::ProjectRoot = if defined?( Rails.env )
                               Rails.root
                             else
                               STDERR.puts "Using default (arcadedb gem)  database credentials and settings"
@@ -15,10 +15,9 @@ module Arcade
                               Pathname.new(  File.expand_path( "../../", __FILE__ ))
       end
     else
-      STDERR.puts "Using provided database credentials and settings fron #{Arcade::ProjectRoot}"
+      STDERR.puts "Using provided database credentials and settings from #{::ProjectRoot}"
     end
 
-
     # initialised a hash  { environment => property }
     setting :username, default: :user,      reader: true,
       constructor:  ->(v) { yml(:environment).map{|x,y|  [x , y[v.to_s]] }.to_h }
@@ -53,7 +52,7 @@ module Arcade
      def self.config_file
 
        configdir =  -> do
-         pr =  ProjectRoot.is_a?(Pathname)?  ProjectRoot : Pathname.new( ProjectRoot )
+         pr =  ::ProjectRoot.is_a?(Pathname)?  ::ProjectRoot : Pathname.new( ::ProjectRoot )
          ( cd =  pr + 'arcade.yml' ).exist? || ( cd =   pr + 'config' + 'arcade.yml' ).exist? || ( cd =   pr + 'config.yml' )
          cd
        end