activecypher 0.9.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b70a7612e29fd973054f654ad63f28b6fe965d993073ffd39aefcdf10798326
-  data.tar.gz: c23ad33676db0a63bb389bb8edc597eaa4eb6f8cdcfbf44eb32e0eb4c640c1fd
+  metadata.gz: 1f1c222ac52b28439402e7b5bdbd0b3245c2530ce75227a9b35ef47917225327
+  data.tar.gz: d0cb17f1db87febfdb693f0fc85970b1d4b8e6c7555ae5424be1b04cbcf1eee9
 SHA512:
-  metadata.gz: 3688ca19c11ee45562da2a6ccd6d65be740d4ba838802ec8dc52e8453ee80e42fbd771585e31b21ab857b6acb7abc449423debbae9cd2d86a5f9207009cc847d
-  data.tar.gz: f86b0d54cea7d36aa2d9093d37d0a816ab4fed6485b3697bc31c9a76abda329cae4adb5c33845baccaa5e86153c36aa4996146150b224b2eb7dec927fa43a8f2
+  metadata.gz: 3a8f60aacaea3ed7b3a4fb53e92b042237392d809304f1d17c59ebdb3c6b8e4ea221c44beaa6868a7e2e80859bbdb6f438c1cff65b2eff186b4dcd2f18c9c43a
+  data.tar.gz: ea5cdba9b038ca87809698de82982613f3a1c6efc33365bf9b01f07216edbb5bfcf5007f07cd5b9f0d360a830ec86c95e9e00b695bdafc42ac1cc242ed7c663e

data/lib/active_cypher/model/querying.rb

@@ -73,6 +73,7 @@ module ActiveCypher
         # Because apparently typing .where(attrs).limit(1).first was giving people RSI
         def find_by(attributes = {})
           return nil if attributes.blank?
+
           where(attributes).limit(1).first
         end
 
@@ -83,12 +84,12 @@ module ActiveCypher
         # For when nil isn't dramatic enough and you need your code to scream at you
         def find_by!(attributes = {})
           # Format attributes nicely for the error message
-          formatted_attrs = attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
-          
+          formatted_attrs = attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+
           find_by(attributes) || raise(ActiveCypher::RecordNotFound,
                                        "Couldn't find #{name} with #{formatted_attrs}. " \
                                        "Perhaps it's hiding in another graph, or maybe it never existed. " \
-                                       "Who can say in this vast, uncaring universe of nodes and relationships?")
+                                       'Who can say in this vast, uncaring universe of nodes and relationships?')
         end
 
         # Instantiates and immediately saves a new record. YOLO mode.

data/lib/active_cypher/relationship.rb

@@ -155,8 +155,23 @@ module ActiveCypher
 
       # -- factories -----------------------------------------------
       # Mirrors ActiveRecord.create
-      def create(attrs = {}, from_node:, to_node:)
-        new(attrs, from_node: from_node, to_node: to_node).tap(&:save)
+      def create(attrs = {}, from_node:, to_node:, **attribute_kwargs)
+        new(attrs, from_node: from_node, to_node: to_node, **attribute_kwargs).tap(&:save)
+      end
+
+      # Bang version of create - raises exception if save fails
+      # For when you want your relationship failures to be as dramatic as your breakups
+      def create!(attrs = {}, from_node:, to_node:, **attribute_kwargs)
+        relationship = create(attrs, from_node: from_node, to_node: to_node, **attribute_kwargs)
+        if relationship.persisted?
+          relationship
+        else
+          error_msgs = relationship.errors.full_messages.join(', ')
+          error_msgs = 'Validation failed' if error_msgs.empty?
+          raise ActiveCypher::RecordNotSaved,
+                "#{name} could not be saved: #{error_msgs}. " \
+                "Perhaps the nodes aren't ready for this kind of commitment?"
+        end
       end
 
       # Instantiate from DB row, marking the instance as persisted.
@@ -168,6 +183,82 @@ module ActiveCypher
                       to_node: to_node)
         instance
       end
+
+      # -- Querying methods ----------------------------------------
+      # Find the first relationship matching the given attributes
+      # Like finding a needle in a haystack, if the haystack was made of graph edges
+      def find_by(attributes = {})
+        return nil if attributes.blank?
+
+        rel_type = relationship_type
+
+        # Build WHERE conditions for the attributes
+        conditions = []
+        params = {}
+
+        attributes.each_with_index do |(key, value), index|
+          param_name = :"p#{index + 1}"
+          conditions << "r.#{key} = $#{param_name}"
+          params[param_name] = value
+        end
+
+        where_clause = conditions.join(' AND ')
+
+        # Determine ID function based on adapter type
+        adapter_class = connection.class
+        id_func = adapter_class.const_defined?(:ID_FUNCTION) ? adapter_class::ID_FUNCTION : 'id'
+
+        cypher = <<~CYPHER
+          MATCH ()-[r:#{rel_type}]-()
+          WHERE #{where_clause}
+          RETURN r, #{id_func}(r) as rid, startNode(r) as from_node, endNode(r) as to_node
+          LIMIT 1
+        CYPHER
+
+        result = connection.execute_cypher(cypher, params, 'Find Relationship By')
+        row = result.first
+
+        return nil unless row
+
+        # Extract relationship data and instantiate
+        rel_data = row[:r] || row['r']
+        rid = row[:rid] || row['rid']
+
+        # Extract properties from the relationship data
+        # Memgraph returns relationships wrapped as [type_code, [actual_data]]
+        attrs = {}
+
+        if rel_data.is_a?(Array) && rel_data.length == 2
+          # Extract the actual relationship data from the second element
+          actual_data = rel_data[1]
+
+          if actual_data.is_a?(Array) && actual_data.length >= 5
+            # Format: [rel_id, start_id, end_id, type, properties, ...]
+            props = actual_data[4]
+            attrs = props.is_a?(Hash) ? props : {}
+          end
+        elsif rel_data.is_a?(Hash)
+          attrs = rel_data
+        end
+
+        # Convert string keys to symbols for attributes
+        attrs = attrs.transform_keys(&:to_sym)
+        attrs[:internal_id] = rid if rid
+
+        instantiate(attrs)
+      end
+
+      # Find the first relationship or raise an exception
+      # For when nil just isn't dramatic enough for your data access needs
+      def find_by!(attributes = {})
+        # Format attributes nicely for the error message
+        formatted_attrs = attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+
+        find_by(attributes) || raise(ActiveCypher::RecordNotFound,
+                                     "Couldn't find #{name} with #{formatted_attrs}. " \
+                                     'Maybe these nodes were never meant to be connected? ' \
+                                     'Or perhaps their relationship status is... complicated?')
+      end
     end
 
     # --------------------------------------------------------------
@@ -176,10 +267,15 @@ module ActiveCypher
     attr_accessor :from_node, :to_node
     attr_reader   :new_record
 
-    def initialize(attrs = {}, from_node: nil, to_node: nil)
+    def initialize(attrs = {}, from_node: nil, to_node: nil, **attribute_kwargs)
       _run(:initialize) do
         super()
-        assign_attributes(attrs) if attrs
+
+        # Merge explicit attrs hash with keyword arguments for attributes.
+        # Note: `attribute_kwargs` takes precedence over `attrs` for keys that exist in both.
+        combined_attrs = attrs.merge(attribute_kwargs)
+        assign_attributes(combined_attrs) if combined_attrs.any?
+
         @from_node  = from_node
         @to_node    = to_node
         @new_record = true
@@ -232,6 +328,21 @@ module ActiveCypher
     # --------------------------------------------------------------
     private
 
+    # Initialize from database attributes, marking as persisted
+    def init_with_attributes(attributes, from_node: nil, to_node: nil)
+      # Initialize the model first to set up attributes
+      initialize({}, from_node: from_node, to_node: to_node)
+
+      # Now we're not a new record
+      @new_record = false
+
+      # Assign the attributes from the database
+      assign_attributes(attributes) if attributes
+
+      # Clear any change tracking
+      clear_changes_information
+    end
+
     def create_relationship
       raise 'Source node must be persisted' unless from_node&.persisted?
       raise 'Target node must be persisted' unless to_node&.persisted?

data/lib/active_cypher/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.9.0'
+  VERSION = '0.10.1'
 
   def self.gem_version
     Gem::Version.new VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Abdelkader Boudih