activecypher 0.0.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0e2c604c5ec3fe484276994955b2d0be34105662c5cfbce0e52c9113a50eea9
-  data.tar.gz: 5431aa5e0d2b069e262bdc797200ad9366358b041e98cec136568e90e40b9726
+  metadata.gz: 56e09b9d8193d2c4c745c1973bb420ba83854cbe0b578d5d37d4e215c96c7687
+  data.tar.gz: a53e722376ff97ae59c6fc0735c16eb15b9e2fe89fe45cda6d42c5d45237a97f
 SHA512:
-  metadata.gz: 9fbb120bc4ab351bc91df701bea81d6fd50d23ef5e6e3f55f76618648b5c1cb481124a16bf1a8c8a1c7be24bf778250698394df6c159d5a8234a62629220f823
-  data.tar.gz: 8e9dfe628538982b7971a9f6fb70e2ee6da0a167ccc582b1081e5e013cd3d1b7bd29b7b782d9b72c8d41edf80da25c34f305585e1243d12ef6f7422b709bd948
+  metadata.gz: bd26475b4774f41f37b047c558707c7fe5282718c8970f1a24148c3f6ad57186ad7b0823051e06d420d80373605f8d28721b7f934dd64e0110b05050af6af7f9
+  data.tar.gz: 20b688e0788fe8dd84a51471ee2125d8ce8082304d4e9db724d4970b0e27da638fd4e541030982b582716d5ad1c1f86d1e88c3fbb3605437bab05c96a5e2b832

data/lib/active_cypher/associations/collection_proxy.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  module Associations
+    # @!visibility public
+    # CollectionProxy wraps association collections, providing lazy loading and mutation helpers.
+    # Because what’s one more layer between you and your data?
+    class CollectionProxy < Relation
+      attr_reader :owner, :reflection
+
+      # ------------------------------------------------------------
+      # construction
+      # ------------------------------------------------------------
+
+      # Initializes the proxy, because direct access would be too easy.
+      #
+      # @param owner [Object] The owning record
+      # @param reflection [Hash] The association reflection
+      # @param base_relation [Relation] The base relation for the association
+      def initialize(owner, reflection, base_relation)
+        super(reflection[:class_name].constantize, base_relation.cyrel_query)
+
+        @owner      = owner
+        @reflection = reflection
+        @records    = nil # lazy – load on first enumeration
+      end
+
+      # ------------------------------------------------------------
+      # enumeration helpers
+      # ------------------------------------------------------------
+
+      # Iterates over the records in the association.
+      # Because Rubyists love pretending their database is just an array.
+      #
+      # @yield [record] Yields each record in the collection
+      def each(&)
+        load_target unless @records
+        @records.each(&)
+      end
+      alias to_a each
+
+      # Returns the size, because counting things is the only certainty in life.
+      #
+      # @return [Integer] The number of records in the collection
+      def size   = load_target.size
+      alias length size
+
+      # Fully refresh from the database.
+      # For when you want to relive the disappointment of your data changing.
+      #
+      # @return [self]
+      def reload
+        @records = nil
+        load_target
+        self
+      end
+
+      # ------------------------------------------------------------
+      # Mutation helpers  ( <<, build, create … )
+      # ------------------------------------------------------------
+
+      #
+      #   hobby.people << bob
+      #
+      # * persists the edge (via the relationship model if supplied)
+      # * updates the in‑memory collection, so `include?` etc. work
+      #
+      # Because shoveling objects into a collection is the pinnacle of ORM magic.
+      #
+      # @param records [Array<Object>] Records to add
+      # @return [self]
+      def <<(*records)
+        unless owner.persisted?
+          raise ActiveCypher::PersistenceError,
+                'Cannot modify associations on a new record'
+        end
+
+        records.flatten.each { |rec| add_record(rec) }
+        self
+      end
+
+      # Convenient `ids` reader ─ used by a few specs.
+      # Because sometimes you just want the IDs and none of the commitment.
+      #
+      # @return [Array<String>] The internal IDs of the associated records
+      def ids
+        map(&:internal_id)
+      end
+
+      private
+
+      # ------------------------------------------------------------------
+      #  helpers
+      # ------------------------------------------------------------------
+
+      # Loads the target records, because lazy loading is the only exercise this code gets.
+      #
+      # @return [Array<Object>] The loaded records
+      def load_target
+        @records = load_records
+      end
+
+      # Adds a record to the association, with all the ceremony of a royal wedding.
+      #
+      # @param record [Object] The record to add
+      # @raise [ArgumentError] if the record is not of the correct class
+      # @raise [RuntimeError] if the record is not persisted
+      def add_record(record)
+        klass = reflection[:class_name].constantize
+        raise ArgumentError, "Expected #{klass}, got #{record.class}" unless record.is_a?(klass)
+        raise "Associated object #{record.inspect} must be persisted" unless record.persisted?
+
+        # Persist the edge ------------------------------------------------
+        rel_klass = reflection[:relationship_class]&.constantize
+        dir       = reflection[:direction]
+
+        from_node, to_node =
+          case dir
+          when :out  then [owner, record]
+          when :in   then [record, owner]
+          when :both then [owner,  record]
+          else raise ArgumentError, "Direction '#{dir}' not supported"
+          end
+
+        if rel_klass
+          rel_klass.create({}, from_node: from_node, to_node: to_node)
+        else
+          arrow = (dir == :both ? :'--' : :out)
+          Cyrel
+            .match(Cyrel.node(from_node.class.label_name).as(:a)
+                        .where(Cyrel.id(:a).eq(from_node.internal_id)))
+            .match(Cyrel.node(to_node.class.label_name).as(:b)
+                        .where(Cyrel.id(:b).eq(to_node.internal_id)))
+            .create(Cyrel.node(:a).rel(arrow, reflection[:relationship]).to(:b))
+            .tap { |qry| owner.class.connection.execute_cypher(*qry.to_cypher, 'Create Association') }
+        end
+
+        # Keep the in‑memory collection in sync --------------------------
+        load_target unless @records # force initial load if needed
+        @records << record unless @records.include?(record)
+      end
+    end
+  end
+end