activecypher 0.0.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0e2c604c5ec3fe484276994955b2d0be34105662c5cfbce0e52c9113a50eea9
-  data.tar.gz: 5431aa5e0d2b069e262bdc797200ad9366358b041e98cec136568e90e40b9726
+  metadata.gz: b78e44e773d760db977af2feadbb8da2feae14d361e530a9ce0c300b3488316e
+  data.tar.gz: 867b1beeed8d8f2a42d49b61c33be85fbc97e431b1a5d212ffdd676b9fc5cde3
 SHA512:
-  metadata.gz: 9fbb120bc4ab351bc91df701bea81d6fd50d23ef5e6e3f55f76618648b5c1cb481124a16bf1a8c8a1c7be24bf778250698394df6c159d5a8234a62629220f823
-  data.tar.gz: 8e9dfe628538982b7971a9f6fb70e2ee6da0a167ccc582b1081e5e013cd3d1b7bd29b7b782d9b72c8d41edf80da25c34f305585e1243d12ef6f7422b709bd948
+  metadata.gz: 6ab032c06695810f847c679dcadddec8af51c4c4a6c53425f04561cf92f2d558876b775cd40d535e40c66c654e33474752d7438eeb91fa5d2f3450b1fe46fd53
+  data.tar.gz: 14120d94c9f0fb83765631ab06efe2da72cf2939ea6d24a2fade76911384b4df0cc992f828aa55e10326730e3388b2703746647dcfc577d49c9245be70dfeedd

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