activecypher 0.3.0 → 0.6.0

data/lib/active_cypher/relationship.rb

@@ -47,7 +47,7 @@ module ActiveCypher
     # --------------------------------------------------------------
     # Attributes
     # --------------------------------------------------------------
-    attribute :internal_id, :string
+    attribute :internal_id, :integer
 
     # --------------------------------------------------------------
     # Connection fallback
@@ -59,6 +59,11 @@ module ActiveCypher
     #   WorksAtRelationship.connection  # -> PersonNode.connection
     #
     def self.connection
+      # If a node_base_class is set (directly or by convention), always delegate to its connection
+      if (klass = node_base_class)
+        return klass.connection
+      end
+
       return @connection if defined?(@connection) && @connection
 
       begin
@@ -74,10 +79,51 @@ module ActiveCypher
     class_attribute :_from_class_name,   instance_writer: false
     class_attribute :_to_class_name,     instance_writer: false
     class_attribute :_relationship_type, instance_writer: false
+    class_attribute :_node_base_class,   instance_writer: false
 
     class << self
       attr_reader :last_internal_id
 
+      # DSL for setting or getting the node base class for connection delegation
+      def node_base_class(klass = nil)
+        if klass.nil?
+          # If not set, try convention: XxxRelationship -> XxxNode
+          return _node_base_class if _node_base_class
+
+          if name&.end_with?('Relationship')
+            node_base_name = name.sub(/Relationship\z/, 'Node')
+            begin
+              node_base_klass = node_base_name.constantize
+              if node_base_klass.respond_to?(:abstract_class?) && node_base_klass.abstract_class?
+                self._node_base_class = node_base_klass
+                return node_base_klass
+              end
+            rescue NameError
+              # Do nothing, fallback to nil
+            end
+          end
+          return _node_base_class
+        end
+        # Only allow setting on abstract relationship base classes
+        raise "Cannot set node_base_class on non-abstract relationship class #{name}" unless abstract_class?
+        unless klass.respond_to?(:abstract_class?) && klass.abstract_class?
+          raise ArgumentError, "node_base_class must be an abstract node base class (got #{klass})"
+        end
+
+        self._node_base_class = klass
+      end
+
+      # Prevent subclasses from overriding node_base_class
+      def inherited(subclass)
+        super
+        return unless _node_base_class
+
+        subclass._node_base_class = _node_base_class
+        def subclass.node_base_class(*)
+          raise "Cannot override node_base_class in subclass #{name}; it is locked to #{_node_base_class}"
+        end
+      end
+
       # -- endpoints ------------------------------------------------
       def from_class(value = nil)
         return _from_class_name if value.nil?
@@ -160,8 +206,10 @@ module ActiveCypher
         raise 'Cannot destroy a new relationship' if new_record?
         raise 'Relationship already destroyed'    if destroyed?
 
-        cypher = 'MATCH ()-[r]-() WHERE elementId(r) = $id DELETE r'
-        params = { id: internal_id }
+        adapter = self.class.connection.id_handler
+
+        cypher = "MATCH ()-[r]-() WHERE #{adapter.with_direct_id(internal_id)} DELETE r"
+        params = {}
 
         self.class.connection.execute_cypher(cypher, params, 'Destroy Relationship')
         @destroyed = true
@@ -186,22 +234,31 @@ module ActiveCypher
       rel_ty = self.class.relationship_type
       arrow  = '->' # outgoing by default
 
-      parts  = []
-      parts << 'MATCH (a) WHERE elementId(a) = $from_id'
-      parts << 'MATCH (b) WHERE elementId(b) = $to_id'
-      parts << "CREATE (a)-[r:#{rel_ty}]#{arrow}(b)"
+      adapter = self.class.connection.id_handler
+      parts = []
+
+      # Build the Cypher query based on the adapter
+      id_clause = adapter.with_direct_node_ids(from_node.internal_id, to_node.internal_id)
+      parts << "MATCH (p), (h) WHERE #{id_clause}"
+      parts << "CREATE (p)-[r:#{rel_ty}]#{arrow}(h)"
       parts << 'SET r += $props' unless props.empty? # only if we have props
-      parts << 'RETURN elementId(r) AS rid'
+      parts << "RETURN #{adapter.return_id}"
 
       cypher = parts.join(' ')
-      params = {
-        from_id: from_node.internal_id,
-        to_id: to_node.internal_id,
-        props: props
-      }
+      params = { props: props }
+
+      # Execute Cypher query
+      result = self.class.connection.execute_cypher(cypher, params, 'Create Relationship')
+
+      row = result.first
 
-      row = self.class.connection.execute_cypher(cypher, params, 'Create Relationship').first
-      rid = row && (row[:rid] || row['rid']) or raise 'Relationship creation returned no id'
+      # Try different ways to access the ID
+      rid_sym = row && row[:rid]
+      rid_str = row && row['rid']
+
+      rid = rid_sym || rid_str
+
+      raise 'Relationship creation returned no id' if rid.nil?
 
       self.internal_id = rid
       self.class.instance_variable_set(:@last_internal_id, rid)
@@ -217,11 +274,14 @@ module ActiveCypher
       changes = changes_to_save
       return true if changes.empty?
 
+      adapter = self.class.connection.id_handler
+
       cypher = <<~CYPHER
-        MATCH ()-[r]-() WHERE elementId(r) = $id
+        MATCH ()-[r]-() WHERE #{adapter.with_direct_id(internal_id)}
         SET r += $props
       CYPHER
-      params = { id: internal_id, props: changes }
+
+      params = { props: changes }
 
       self.class.connection.execute_cypher(cypher, params, 'Update Relationship')
       changes_applied

data/lib/active_cypher/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.3.0'
+  VERSION = '0.6.0'
 end

data/lib/activecypher.rb

@@ -101,7 +101,10 @@ loader.ignore("#{__dir__}/active_cypher/railtie.rb")
 loader.ignore("#{__dir__}/active_cypher/generators")
 loader.ignore("#{__dir__}/activecypher.rb")
 loader.ignore("#{__dir__}/cyrel.rb")
-loader.inflector.inflect('activecypher' => 'ActiveCypher')
+loader.inflector.inflect(
+  'activecypher' => 'ActiveCypher',
+  'dsl_context' => 'DSLContext'
+)
 loader.push_dir("#{__dir__}/cyrel", namespace: Cyrel)
 loader.setup
 

data/lib/cyrel/clause/set.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'cyrel/expression'
+require 'cyrel/expression/property_access'
+
 module Cyrel
   module Clause
     # Represents a SET clause in a Cypher query.
@@ -12,6 +15,7 @@ module Cyrel
       #   - Hash: { variable_or_prop_access => value_expression, ... }
       #     e.g., { Cyrel.prop(:n, :name) => "New Name", Cyrel.prop(:r, :weight) => 10 }
       #     e.g., { n: { name: "New Name", age: 30 } } # For SET n = properties or n += properties
+      #     e.g., { Cyrel.plus(:n) => { name: "New Name" } } # For SET n += { name: ... }
       #   - Array: [[variable, label_string], ...] # For SET n:Label
       #     e.g., [[:n, "NewLabel"], [:m, "AnotherLabel"]]
       #   Note: Mixing hash and array styles in one call is not directly supported, use multiple SET clauses if needed.
@@ -47,17 +51,20 @@ module Cyrel
         case assignments
         when Hash
           assignments.flat_map do |key, value|
-            if key.is_a?(Expression::PropertyAccess)
+            case key
+            when Expression::PropertyAccess
               # SET n.prop = value
               [[:property, key, Expression.coerce(value)]]
-            elsif key.is_a?(Symbol) || key.is_a?(String)
-              # SET n = properties or SET n += properties
-              # We need to decide which operator (= or +=). Defaulting to = for now.
-              # User might need to specify via a different method/option.
-              # Let's assume the value is a hash for this case.
+            when Symbol, String
+              # SET n = properties
               raise ArgumentError, 'Value for variable assignment must be a Hash (for SET n = {props})' unless value.is_a?(Hash)
 
-              [[:variable_properties, key.to_sym, Expression.coerce(value)]]
+              [[:variable_properties, key.to_sym, Expression.coerce(value), :assign]]
+            when Cyrel::Plus
+              # SET n += properties
+              raise ArgumentError, 'Value for variable assignment must be a Hash (for SET n += {props})' unless value.is_a?(Hash)
+
+              [[:variable_properties, key.variable.to_sym, Expression.coerce(value), :merge]]
             else
               raise ArgumentError, "Invalid key type in SET assignments hash: #{key.class}"
             end
@@ -78,15 +85,18 @@ module Cyrel
       end
 
       def render_assignment(assignment, query)
-        type, target, value = assignment
+        type, target, value, op = assignment
         case type
         when :property
           # target is PropertyAccess, value is Expression
           "#{target.render(query)} = #{value.render(query)}"
         when :variable_properties
           # target is variable symbol, value is Expression (Literal Hash)
-          # Using '=' operator here. Could add support for '+=' later.
-          "#{target} = #{value.render(query)}"
+          if op == :merge
+            "#{target} += #{value.render(query)}"
+          else
+            "#{target} = #{value.render(query)}"
+          end
         when :label
           # target is variable symbol, value is label string
           "#{target}:#{value}" # Labels are not parameterized

data/lib/cyrel/expression/property_access.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'cyrel/expression/base'
+
 module Cyrel
   module Expression
     # Represents accessing a property on a variable (node or relationship alias).

data/lib/cyrel/functions.rb

@@ -22,7 +22,9 @@ module Cyrel
       Expression::FunctionCall.new(:elementId, Clause::Return::RawIdentifier.new(node_variable.to_s))
     end
 
-    alias id element_id
+    def id(node_variable)
+      Expression::FunctionCall.new(:id, Clause::Return::RawIdentifier.new(node_variable.to_s))
+    end
 
     # Because apparently, COUNT(*) isn’t obvious enough.
     # Handles the 'give me everything and make it snappy' use case.

data/lib/cyrel/logging.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'active_support/tagged_logging'
+
+module Cyrel
+  # Basic logging support for Cyrel.
+  # Debug logging is disabled by default.
+  module Logging
+    LOG_TAG = 'Cyrel'
+
+    class << self
+      # @return [Logger] the configured logger
+      attr_accessor :backend
+
+      def resolve_log_level(log_level_str)
+        Logger.const_get(log_level_str.upcase)
+      rescue StandardError
+        Logger::UNKNOWN
+      end
+
+      def logger
+        self.backend ||= begin
+          log_level = ENV.fetch('CYREL_LOG_LEVEL', 'unknown')
+          logger_base = Logger.new($stdout)
+          logger_base.level = resolve_log_level(log_level)
+
+          # Return a TaggedLogging instance without calling 'tagged!'
+          ActiveSupport::TaggedLogging.new(logger_base)
+        end
+      end
+    end
+
+    def logger
+      Logging.logger.tagged(LOG_TAG)
+    end
+
+    def log_debug(msg) = logger.debug { msg }
+    def log_info(msg)  = logger.info  { msg }
+    def log_warn(msg)  = logger.warn  { msg }
+    def log_error(msg) = logger.error { msg }
+  end
+end

data/lib/cyrel/plus.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Cyrel
+  class Plus
+    attr_reader :variable
+
+    def initialize(variable)
+      @variable = variable
+    end
+  end
+end

data/lib/cyrel/query.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-# Require necessary clause and pattern types
+# Base DSL components
+require 'cyrel/parameterizable'
+require 'cyrel/logging'
 
 # Require all clause types for DSL methods
 
@@ -18,6 +20,7 @@ module Cyrel
   #   # Manages clauses, parameters, and final query generation, because string interpolation is for amateurs.
   class Query
     include Parameterizable
+    include Logging
     attr_reader :parameters, :clauses # Expose clauses for merge logic
 
     def initialize
@@ -58,6 +61,9 @@ module Cyrel
                         .reject(&:blank?)
                         .join("\n")
 
+        log_debug("QUERY: #{cypher_string}")
+        log_debug("PARAMS: #{@parameters.inspect}") unless @parameters.empty?
+
         [cypher_string, @parameters]
       end
     end

data/lib/cyrel.rb

@@ -1,72 +1,131 @@
 # frozen_string_literal: true
 
-require 'irb' # Required for binding.irb
-
 module Cyrel
   module_function
 
-  # Define all top-level helpers as instance methods first
+  # Cyrel DSL helper: creates a CALL clause for a procedure.
+  # Example: Cyrel.call('db.labels')
   def call(procedure)
     CallProcedure.new(procedure)
   end
 
+  # Cyrel DSL helper: creates a RETURN clause.
+  # Example: Cyrel.return(name: :n)
   def return(**return_values)
     ReturnOnly.new(return_values)
   end
-  # Now make all defined instance methods module functions
 
-  # --- Pattern Helpers ---
+  # Cyrel DSL helper: creates a node pattern.
+  # Example: Cyrel.node(:n, labels: ['Person'], properties: {name: 'Alice'})
   def node(alias_name, labels: [], properties: {})
     Pattern::Node.new(alias_name, labels: labels, properties: properties)
   end
-  # Add helpers for Relationship, Path if needed
 
-  # --- Query Building Starters ---
+  # Cyrel DSL helper: starts a CREATE query.
+  # Example: Cyrel.create(pattern)
   def create(pattern)
-    Query.new.create(pattern) # Start a new query and call create
+    Query.new.create(pattern)
   end
 
+  # Cyrel DSL helper: starts a MATCH query.
+  # Example: Cyrel.match(pattern)
   def match(pattern, path_variable: nil)
-    Query.new.match(pattern, path_variable: path_variable) # Start a new query and call match
+    Query.new.match(pattern, path_variable: path_variable)
   end
-  # Add helpers for merge etc. if desired as query starters
 
-  # --- Function Helpers (Delegated) ---
-  # Keep id for now for compatibility? Or remove entirely? Let's keep it but delegate element_id too.
-  # Delegate to the correct module function
+  # Cyrel DSL helper: returns the element id of a node/relationship.
+  # Example: Cyrel.id(:n)
   def id(...) = Functions.element_id(...)
+
+  # Cyrel DSL helper: returns the element id of a node/relationship (alias).
   def element_id(...) = Functions.element_id(...)
+
+  # Cyrel DSL helper: Cypher count() aggregation.
+  # Example: Cyrel.count(:n)
   def count(...) = Functions.count(...)
+
+  # Cyrel DSL helper: Cypher labels() function.
+  # Example: Cyrel.labels(:n)
   def labels(...) = Functions.labels(...)
+
+  # Cyrel DSL helper: Cypher type() function.
+  # Example: Cyrel.type(:r)
   def type(...) = Functions.type(...)
+
+  # Cyrel DSL helper: Cypher properties() function.
+  # Example: Cyrel.properties(:n)
   def properties(...) = Functions.properties(...)
+
+  # Cyrel DSL helper: Cypher coalesce() function.
+  # Example: Cyrel.coalesce(:a, :b)
   def coalesce(...) = Functions.coalesce(...)
+
+  # Cyrel DSL helper: Cypher timestamp() function.
+  # Example: Cyrel.timestamp
   def timestamp(...) = Functions.timestamp(...)
+
+  # Cyrel DSL helper: Cypher toString() function.
+  # Example: Cyrel.to_string(:n)
   def to_string(...) = Functions.to_string(...)
+
+  # Cyrel DSL helper: Cypher toInteger() function.
+  # Example: Cyrel.to_integer(:n)
   def to_integer(...) = Functions.to_integer(...)
+
+  # Cyrel DSL helper: Cypher toFloat() function.
+  # Example: Cyrel.to_float(:n)
   def to_float(...) = Functions.to_float(...)
+
+  # Cyrel DSL helper: Cypher toBoolean() function.
+  # Example: Cyrel.to_boolean(:n)
   def to_boolean(...) = Functions.to_boolean(...)
+
+  # Cyrel DSL helper: Cypher sum() aggregation.
+  # Example: Cyrel.sum(:n)
   def sum(...) = Functions.sum(...)
+
+  # Cyrel DSL helper: Cypher avg() aggregation.
+  # Example: Cyrel.avg(:n)
   def avg(...) = Functions.avg(...)
+
+  # Cyrel DSL helper: Cypher min() aggregation.
+  # Example: Cyrel.min(:n)
   def min(...) = Functions.min(...)
+
+  # Cyrel DSL helper: Cypher max() aggregation.
+  # Example: Cyrel.max(:n)
   def max(...) = Functions.max(...)
+
+  # Cyrel DSL helper: Cypher collect() aggregation.
+  # Example: Cyrel.collect(:n)
   def collect(...) = Functions.collect(...)
-  def size(...) = Functions.size(...)
 
-  # --- Expression Helpers (Delegated) ---
+  # Cyrel DSL helper: Cypher size() function.
+  # Example: Cyrel.size(:n)
+  def size(...) = Functions.size(...)
 
-  # Helper for creating PropertyAccess expressions.
+  # Cyrel DSL helper: creates a PropertyAccess expression.
+  # Example: Cyrel.prop(:n, :name)
   def prop(variable, property_name)
     Expression.prop(variable, property_name)
   end
 
-  # Helper for creating Exists expressions.
+  # Cyrel DSL helper: creates an Exists expression.
+  # Example: Cyrel.exists(pattern)
   def exists(pattern)
     Expression.exists(pattern)
   end
 
-  # Helper for creating Logical NOT expressions.
+  # Cyrel DSL helper: creates a Logical NOT expression.
+  # Example: Cyrel.not(expression)
   def not(expression)
     Expression.not(expression)
   end
+
+  # Cyrel DSL helper: property merging (SET n += {props}).
+  # Use for updating only specified properties on a node or relationship.
+  # Example: Cyrel.plus(:n) => { name: "Alice" } generates SET n += $p1
+  def plus(variable)
+    Plus.new(variable)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -119,11 +119,18 @@ files:
 - lib/active_cypher/connection_adapters/abstract_bolt_adapter.rb
 - lib/active_cypher/connection_adapters/memgraph_adapter.rb
 - lib/active_cypher/connection_adapters/neo4j_adapter.rb
-- lib/active_cypher/connection_factory.rb
+- lib/active_cypher/connection_adapters/registry.rb
 - lib/active_cypher/connection_handler.rb
 - lib/active_cypher/connection_pool.rb
 - lib/active_cypher/connection_url_resolver.rb
 - lib/active_cypher/cypher_config.rb
+- lib/active_cypher/fixtures.rb
+- lib/active_cypher/fixtures/dsl_context.rb
+- lib/active_cypher/fixtures/evaluator.rb
+- lib/active_cypher/fixtures/node_builder.rb
+- lib/active_cypher/fixtures/parser.rb
+- lib/active_cypher/fixtures/registry.rb
+- lib/active_cypher/fixtures/rel_builder.rb
 - lib/active_cypher/generators/install_generator.rb
 - lib/active_cypher/generators/node_generator.rb
 - lib/active_cypher/generators/relationship_generator.rb
@@ -132,6 +139,7 @@ files:
 - lib/active_cypher/generators/templates/cypher_databases.yml
 - lib/active_cypher/generators/templates/node.rb.erb
 - lib/active_cypher/generators/templates/relationship.rb.erb
+- lib/active_cypher/instrumentation.rb
 - lib/active_cypher/logging.rb
 - lib/active_cypher/model/abstract.rb
 - lib/active_cypher/model/attributes.rb
@@ -142,6 +150,7 @@ files:
 - lib/active_cypher/model/countable.rb
 - lib/active_cypher/model/destruction.rb
 - lib/active_cypher/model/inspectable.rb
+- lib/active_cypher/model/labelling.rb
 - lib/active_cypher/model/persistence.rb
 - lib/active_cypher/model/querying.rb
 - lib/active_cypher/railtie.rb
@@ -183,12 +192,14 @@ files:
 - lib/cyrel/expression/pattern_comprehension.rb
 - lib/cyrel/expression/property_access.rb
 - lib/cyrel/functions.rb
+- lib/cyrel/logging.rb
 - lib/cyrel/node.rb
 - lib/cyrel/parameterizable.rb
 - lib/cyrel/pattern.rb
 - lib/cyrel/pattern/node.rb
 - lib/cyrel/pattern/path.rb
 - lib/cyrel/pattern/relationship.rb
+- lib/cyrel/plus.rb
 - lib/cyrel/query.rb
 - lib/cyrel/return_only.rb
 - lib/cyrel/types/hash_type.rb

data/lib/active_cypher/connection_factory.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveCypher
-  # ConnectionFactory provides a simple API for creating connections to Cypher databases
-  # using the ConnectionUrlResolver to parse database URLs.
-  #
-  # This factory simplifies the process of creating database connections by:
-  # 1. Parsing connection URLs with ConnectionUrlResolver
-  # 2. Creating the appropriate adapter based on the URL
-  # 3. Establishing and configuring the connection with the right security settings
-  #
-  # Example:
-  #   factory = ConnectionFactory.new("neo4j://user:pass@localhost:7687")
-  #   driver = factory.create_driver
-  #
-  #   driver.with_session do |session|
-  #     result = session.run("RETURN 'Connected!' AS message")
-  #     puts result.first[:message]
-  #   end
-  class ConnectionFactory
-    # Initialize with a database URL
-    # @param url [String] A database connection URL
-    # @param options [Hash] Additional options for the connection
-    def initialize(url, options = {})
-      @url = url
-      @options = options
-      @config = resolve_url(url)
-    end
-
-    # Create a Bolt driver based on the parsed URL
-    # @param pool_size [Integer] Size of the connection pool
-    # @return [ActiveCypher::Bolt::Driver, nil] The configured driver or nil if URL is invalid
-    def create_driver(pool_size: 5)
-      return nil unless @config
-
-      # Create the adapter based on the resolved configuration
-      adapter = create_adapter
-      return nil unless adapter
-
-      # Create and configure the Bolt driver
-      uri = build_uri
-      auth_token = build_auth_token
-
-      ActiveCypher::Bolt::Driver.new(
-        uri: uri,
-        adapter: adapter,
-        auth_token: auth_token,
-        pool_size: pool_size
-      )
-    end
-
-    # Get the parsed configuration
-    # @return [Hash, nil] The parsed configuration or nil if URL is invalid
-    attr_reader :config
-
-    # Verify if the URL is valid and supported
-    # @return [Boolean] True if the URL is valid and supported
-    def valid?
-      !@config.nil?
-    end
-
-    private
-
-    # Resolve the URL into a configuration hash
-    def resolve_url(url)
-      resolver = ConnectionUrlResolver.new(url)
-      resolver.to_hash
-    end
-
-    # Create the appropriate adapter based on the parsed URL
-    def create_adapter
-      case @config[:adapter]
-      when 'neo4j'
-        create_neo4j_adapter
-      when 'memgraph'
-        create_memgraph_adapter
-      else
-        nil
-      end
-    end
-
-    # Create a Neo4j adapter
-    def create_neo4j_adapter
-      ConnectionAdapters::Neo4jAdapter.new({
-                                             uri: build_uri,
-                                             username: @config[:username],
-                                             password: @config[:password],
-                                             database: @config[:database]
-                                           })
-    end
-
-    # Create a Memgraph adapter
-    def create_memgraph_adapter
-      ConnectionAdapters::MemgraphAdapter.new({
-                                                uri: build_uri,
-                                                username: @config[:username],
-                                                password: @config[:password],
-                                                database: @config[:database]
-                                              })
-    rescue NameError
-      # Fall back to Neo4j adapter if Memgraph adapter is not available
-      ConnectionAdapters::Neo4jAdapter.new({
-                                             uri: build_uri,
-                                             username: @config[:username],
-                                             password: @config[:password],
-                                             database: @config[:database]
-                                           })
-    end
-
-    # Build the URI string with the appropriate scheme based on SSL settings
-    def build_uri
-      scheme = if @config[:ssl]
-                 @config[:ssc] ? 'bolt+ssc' : 'bolt+s'
-               else
-                 'bolt'
-               end
-
-      "#{scheme}://#{@config[:host]}:#{@config[:port]}"
-    end
-
-    # Build the authentication token for the Bolt driver
-    def build_auth_token
-      {
-        scheme: 'basic',
-        principal: @config[:username],
-        credentials: @config[:password]
-      }
-    end
-  end
-end