rails_age 0.5.3 → 0.6.1

data/lib/apache_age/entities/path.rb

@@ -0,0 +1,27 @@
+module ApacheAge
+  module Entities
+    module Path
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Model
+        include ActiveModel::Dirty
+        include ActiveModel::Attributes
+
+        attribute :id, :integer
+        # attribute :label, :string
+        attribute :end_id, :integer
+        attribute :start_id, :integer
+        # override with a specific node type in the defining class
+        attribute :end_node
+        attribute :start_node
+
+        validates :end_node, :start_node, presence: true
+        validate :validate_nodes
+
+        extend ApacheAge::Entities::ClassMethods
+        include ApacheAge::Entities::CommonMethods
+      end
+    end
+  end
+end

data/lib/apache_age/entities/query_builder.rb

@@ -0,0 +1,159 @@
+# query =
+#   Person.
+#     cypher('age_schema')
+#     .match("(a:Person), (b:Person)")
+#     .where("a.name = 'Node A'", "b.name = 'Node B'")
+#     .return("a.name", "b.name")
+#     .as("name_a agtype, name_b agtype")
+#     .execute
+# def cypher(graph_name = 'age_schema')
+#   ApacheAge::Cypher.new(graph_name)
+#   self
+# end
+
+module ApacheAge
+  module Entities
+    class QueryBuilder
+      attr_accessor :where_clauses, :order_clause, :limit_clause, :model_class, :match_clause,
+                    :graph_name, :return_clause, :return_names, :return_variables
+
+      def initialize(model_class, graph_name: nil)
+        @model_class = model_class
+        @where_clauses = []
+        @return_names = ['find']
+        @return_clause = 'find'
+        @return_variables = []
+        @order_clause = nil
+        @limit_clause = nil
+        @match_clause = model_class.match_clause
+        @graph_name = graph_name || model_class.age_graph
+      end
+
+      # def cypher(graph_name = 'age_schema')
+      #   return self if graph_name.blank?
+
+      #   @graph_name = graph_name
+      #   self
+      # end
+
+      def match(match_string)
+        @match_clause = match_string
+        self
+      end
+
+      # need to handle string inputs too: ie: "id(find) = #{id}"
+      def where(attributes)
+        return self if attributes.blank?
+
+        @where_clauses <<
+          if attributes.is_a?(String)
+            if attributes.include?('id(') || attributes.include?('find.')
+              attributes
+            else
+              "find.#{attributes}"
+            end
+          else
+            edge_keys = [:start_id, :start_node, :end_id, :end_node]
+            if edge_keys.any? { |key| attributes.include?(key) }
+              model_class.send(:where_edge_clause, attributes)
+            else
+              model_class.send(:where_node_clause, attributes)
+            end
+          end
+
+        self
+      end
+
+      # New return method
+      def return(*variables)
+        return self if variables.blank?
+
+        @return_variables = variables
+        # @return_names = variables.empty? ? ['find'] : variables
+        # @return_clause = variables.empty? ? 'find' : "find.#{variables.join(', find.')}"
+        self
+      end
+
+      def order(ordering)
+        @order_clause = nil
+        return self if ordering.blank?
+
+        order_by_values = Array.wrap(ordering).map { |order| parse_ordering(order) }.join(', ')
+        @order_clause = "ORDER BY #{order_by_values}"
+        self
+      end
+
+      def limit(limit_value)
+        @limit_clause = "LIMIT #{limit_value}"
+        self
+      end
+
+      def all
+        cypher_sql = build_query
+        results = model_class.send(:execute_where, cypher_sql)
+        return results if return_variables.empty?
+
+        results.map(&:to_h).map { _1.slice(*return_variables) }
+      end
+
+      def execute
+        cypher_sql = build_query
+        model_class.send(:execute_sql, cypher_sql)
+      end
+
+      def first
+        cypher_sql = build_query(limit_clause || "LIMIT 1")
+        model_class.send(:execute_find, cypher_sql)
+      end
+
+      def to_sql
+        build_query.strip
+      end
+
+      private
+
+      def parse_ordering(ordering)
+        if ordering.is_a?(Hash)
+          # Convert hash into "find.key direction" format and join with commas
+          ordering = ordering.map { |k, v| "find.#{k} #{v}" }.join(', ')
+        elsif ordering.is_a?(Symbol)
+          # If it's a symbol, simply prepend "find."
+          ordering = "find.#{ordering}"
+        elsif ordering.is_a?(String)
+          # If it's a string, assume it's already in the correct format
+          ordering = ordering
+        elsif ordering.is_a?(Array)
+          # If it's an array, process each element recursively
+          ordering = ordering.map do |order|
+            if order.is_a?(Hash)
+              order.map { |k, v| "find.#{k} #{v}" }.join(', ')
+            elsif order.is_a?(Symbol)
+              "find.#{order}"
+            elsif order.is_a?(String)
+              order
+            else
+              raise ArgumentError, 'Array elements must be a string, symbol, or hash'
+            end
+          end.join(', ')
+        else
+          raise ArgumentError, 'Ordering must be a string, symbol, hash, or array'
+        end
+      end
+
+      def build_query(_extra_clause = nil)
+        where_sql = where_clauses.any? ? "WHERE #{where_clauses.join(' AND ')}" : ''
+        order_by = order_clause.present? ? order_clause : ''
+        <<-SQL.squish
+          SELECT *
+          FROM cypher('#{graph_name}', $$
+              MATCH #{match_clause}
+              #{where_sql}
+              RETURN #{return_clause}
+              #{order_clause}
+              #{limit_clause}
+          $$) AS (#{return_names.join(' agtype, ')} agtype);
+        SQL
+      end
+    end
+  end
+end

data/lib/apache_age/entities/vertex.rb

@@ -1,53 +1,53 @@
-module ApacheAge
-  module Entities
-    module Node
-      extend ActiveSupport::Concern
+# module ApacheAge
+#   module Entities
+#     module Vertex
+#       extend ActiveSupport::Concern
 
-      included do
-        include ActiveModel::Model
-        include ActiveModel::Dirty
-        include ActiveModel::Attributes
+#       included do
+#         include ActiveModel::Model
+#         include ActiveModel::Dirty
+#         include ActiveModel::Attributes
 
-        attribute :id, :integer
+#         attribute :id, :integer
 
-        extend ApacheAge::Entities::ClassMethods
-        include ApacheAge::Entities::CommonMethods
-      end
+#         extend ApacheAge::Entities::ClassMethods
+#         include ApacheAge::Entities::CommonMethods
+#       end
 
-      def age_type = 'vertex'
+#       def age_type = 'vertex'
 
-      # AgeSchema::Nodes::Company.create(company_name: 'Bedrock Quarry')
-      # SELECT *
-      # FROM cypher('age_schema', $$
-      #     CREATE (company:Company {company_name: 'Bedrock Quarry'})
-      # RETURN company
-      # $$) as (Company agtype);
-      def create_sql
-        alias_name = age_alias || age_label.downcase
-        <<-SQL
-          SELECT *
-          FROM cypher('#{age_graph}', $$
-              CREATE (#{alias_name}#{self})
-          RETURN #{alias_name}
-          $$) as (#{age_label} agtype);
-        SQL
-      end
+#       # AgeSchema::Nodes::Company.create(company_name: 'Bedrock Quarry')
+#       # SELECT *
+#       # FROM cypher('age_schema', $$
+#       #     CREATE (company:Company {company_name: 'Bedrock Quarry'})
+#       # RETURN company
+#       # $$) as (Company agtype);
+#       def create_sql
+#         alias_name = age_alias || age_label.downcase
+#         <<-SQL
+#           SELECT *
+#           FROM cypher('#{age_graph}', $$
+#               CREATE (#{alias_name}#{self})
+#           RETURN #{alias_name}
+#           $$) as (#{age_label} agtype);
+#         SQL
+#       end
 
-      # So far just properties of string type with '' around them
-      def update_sql
-        alias_name = age_alias || age_label.downcase
-        set_caluse =
-          age_properties.map { |k, v| v ? "#{alias_name}.#{k} = '#{v}'" : "#{alias_name}.#{k} = NULL" }.join(', ')
-        <<-SQL
-          SELECT *
-          FROM cypher('#{age_graph}', $$
-              MATCH (#{alias_name}:#{age_label})
-              WHERE id(#{alias_name}) = #{id}
-              SET #{set_caluse}
-              RETURN #{alias_name}
-          $$) as (#{age_label} agtype);
-        SQL
-      end
-    end
-  end
-end
+#       # So far just properties of string type with '' around them
+#       def update_sql
+#         alias_name = age_alias || age_label.downcase
+#         set_caluse =
+#           age_properties.map { |k, v| v ? "#{alias_name}.#{k} = '#{v}'" : "#{alias_name}.#{k} = NULL" }.join(', ')
+#         <<-SQL
+#           SELECT *
+#           FROM cypher('#{age_graph}', $$
+#               MATCH (#{alias_name}:#{age_label})
+#               WHERE id(#{alias_name}) = #{id}
+#               SET #{set_caluse}
+#               RETURN #{alias_name}
+#           $$) as (#{age_label} agtype);
+#         SQL
+#       end
+#     end
+#   end
+# end

data/lib/apache_age/path.rb

@@ -0,0 +1,4 @@
+module ApacheAge
+  class Path
+  end
+end

data/lib/apache_age/types/{age_type_factory.rb → factory.rb}

@@ -1,4 +1,4 @@
-# lib/apache_age/types/age_type_factory.rb
+# lib/apache_age/types/factory.rb
 # Automatically generates ActiveModel::Type classes
 # Dynamically builds this (as a concrete example):
 # module ApacheAge
@@ -22,8 +22,8 @@
 # end
 module ApacheAge
   module Types
-    class AgeTypeFactory
-      def self.create_type_for(klass)
+    class Factory
+      def self.type_for(klass)
         Class.new(ActiveModel::Type::Value) do
           define_method(:cast) do |value|
             case value

data/lib/apache_age/validators/{vertex_type_validator copy.rb → node_type_validator.rb}

@@ -1,5 +1,5 @@
 module ApacheAge
-  module VertexTypeValidator
+  module NodeTypeValidator
     def
       # Register the AGE typesvertex_attribute(attribute_name, type_symbol, klass)
       attribute attribute_name, type_symbol

data/lib/apache_age/validators/unique_vertex.rb

@@ -1,32 +1,32 @@
-# lib/apache_age/validators/unique_vertex.rb
+# # lib/apache_age/validators/unique_vertex.rb
 
-# Usage (within an Age Model)
-# validates_with(
-#   ApacheAge::Validators::UniqueVertex,
-#   attributes: [:first_name, :last_name, :gender]
-# )
+# # Usage (within an Age Model)
+# # validates_with(
+# #   ApacheAge::Validators::UniqueVertex,
+# #   attributes: [:first_name, :last_name, :gender]
+# # )
 
-module ApacheAge
-  module Validators
-    class UniqueVertex < ActiveModel::Validator
-      def validate(record)
-        allowed_keys = record.age_properties.keys
-        attributes = options[:attributes]
-        return if attributes.blank?
+# module ApacheAge
+#   module Validators
+#     class UniqueVertex < ActiveModel::Validator
+#       def validate(record)
+#         allowed_keys = record.age_properties.keys
+#         attributes = options[:attributes]
+#         return if attributes.blank?
 
-        record_attribs =
-          attributes
-          .map { |attr| [attr, record.send(attr)] }
-          .to_h.symbolize_keys
-          .slice(*allowed_keys)
-        query = record.class.find_by(record_attribs)
+#         record_attribs =
+#           attributes
+#           .map { |attr| [attr, record.send(attr)] }
+#           .to_h.symbolize_keys
+#           .slice(*allowed_keys)
+#         query = record.class.find_by(record_attribs)
 
-        # if no match is found or if it finds itself, it's valid
-        return if query.blank?  || (query.id == record.id)
+#         # if no match is found or if it finds itself, it's valid
+#         return if query.blank?  || (query.id == record.id)
 
-        record.errors.add(:base, 'record not unique')
-        attributes.each { record.errors.add(_1, 'property combination not unique') }
-      end
-    end
-  end
-end
+#         record.errors.add(:base, 'record not unique')
+#         attributes.each { record.errors.add(_1, 'property combination not unique') }
+#       end
+#     end
+#   end
+# end

data/lib/apache_age/validators/vertex_type_validator.rb

@@ -0,0 +1,15 @@
+# module ApacheAge
+#   module VertexTypeValidator
+#     def
+#       # Register the AGE typesvertex_attribute(attribute_name, type_symbol, klass)
+#       attribute attribute_name, type_symbol
+
+#       validate do
+#         value = send(attribute_name)
+#         unless value.is_a?(klass)
+#           errors.add(attribute_name, "must be a #{klass.name}")
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/generators/apache_age/edge/USAGE

@@ -23,9 +23,9 @@ Example:
           validates :employee_role, presence: true
           validates :begin_date, presence: true
 
-          # unique node validator (remove any attributes that are not important to uniqueness)
+          # unique edge validator (remove any attributes that are not important to uniqueness)
           validates_with(
-            ApacheAge::Validators::UniqueVertex,
+            ApacheAge::Validators::UniqueEdge,
             attributes: [:employee_role, :begin_date :start_node, :end_node]
           )
         end
@@ -35,12 +35,12 @@ Example:
         `bin/rails g apache_age:edge Animals/Cat name age:integer`
 
     This creates:
-        `app/nodes/animals/cat.rb`
+        `app/edges/animals/has_cat.rb`
 
     with the contents
         ```
-        class Animals::Cat
-          include ApacheAge::Entities::Vertex
+        class Animals::HatCat
+          include ApacheAge::Entities::Edge
 
           attribute :name, :string
           attribute :age, :integer
@@ -48,9 +48,9 @@ Example:
           validates :name, presence: true
           validates :age, presence: true
 
-          # unique node validator (remove any attributes that are not important to uniqueness)
+          # unique edge validator (remove any attributes that are not important to uniqueness)
           validates_with(
-            ApacheAge::Validators::UniqueVertex,
+            ApacheAge::Validators::UniqueEdge,
             attributes: [:name, :age, :start_node, :end_node]
           )
         end

data/lib/generators/apache_age/edge/edge_generator.rb

@@ -14,6 +14,7 @@ module ApacheAge
 
     source_root File.expand_path('templates', __dir__)
     argument :attributes, type: :array, default: [], banner: "field:type field:type"
+    class_option :skip_namespace, type: :boolean, default: true, desc: "Skip namespace 'rails_age' in generated files"
 
     def perform_task
       age_type = 'edge'

data/lib/generators/apache_age/generator_entity_helpers.rb

@@ -40,14 +40,6 @@ module ApacheAge
       end.join("\n") + "\n"
     end
 
-    # def indented_end_namespace
-    #   return '' if parent_module.empty?
-
-    #   parent_module.split('::').map.with_index do |_, index|
-    #     "#{'  ' * (parent_module.split('::').length - 1 - index)}end"
-    #   end.join("\n") + "\n"
-    # end
-
     def add_type_config
       return unless File.exist?(types_config_file)
 
@@ -79,7 +71,7 @@ module ApacheAge
 <<-RUBY
   require_dependency '#{file_path}'
   ActiveModel::Type.register(
-    :#{type_name}, ApacheAge::Types::AgeTypeGenerator.create_type_for(#{entity_namespaced_class})
+    :#{type_name}, ApacheAge::Types::Factory.type_for(#{entity_namespaced_class})
   )
 RUBY
     end

data/lib/generators/apache_age/node/USAGE

@@ -12,7 +12,7 @@ Example:
     with the contents:
         ```
         class Cat
-          include ApacheAge::Entities::Vertex
+          include ApacheAge::Entities::Node
 
           attribute :full_name, :string
           attribute :birthdate, :date
@@ -22,7 +22,7 @@ Example:
 
           # unique node validator (remove any attributes that are not important to uniqueness)
           validates_with(
-            ApacheAge::Validators::UniqueVertex,
+            ApacheAge::Validators::UniqueNode,
             attributes: [:full_name, :birthdate]
           )
         end
@@ -37,7 +37,7 @@ Example:
     with the contents
         ```
         class Animals::Cat
-          include ApacheAge::Entities::Vertex
+          include ApacheAge::Entities::Node
 
           attribute :name, :string
           attribute :age, :integer
@@ -47,7 +47,7 @@ Example:
 
           # unique node validator (remove any attributes that are not important to uniqueness)
           validates_with(
-            ApacheAge::Validators::UniqueVertex,
+            ApacheAge::Validators::UniqueNode,
             attributes: [:name, :age]
           )
         end

data/lib/generators/apache_age/node/node_generator.rb

@@ -9,9 +9,9 @@ module ApacheAge
     include ApacheAge::GeneratorEntityHelpers
 
     desc "Generates node (model) with attributes."
-
     source_root File.expand_path('templates', __dir__)
     argument :attributes, type: :array, default: [], banner: "field:type field:type"
+    class_option :skip_namespace, type: :boolean, default: true, desc: "Skip namespace 'rails_age' in generated files"
 
     def perform_task
       age_type = 'node'

data/lib/generators/apache_age/node/templates/node.rb.tt

@@ -1,5 +1,5 @@
 class <%= class_name %>
-  include ApacheAge::Entities::Vertex
+  include ApacheAge::Entities::Node
 
 <%- attributes_list.each do |attribute| -%>
   attribute :<%= attribute[:name] %>, :<%= attribute[:type] %>
@@ -11,7 +11,7 @@ class <%= class_name %>
 
   # custom unique node validator (remove any attributes that are NOT important to uniqueness)
   validates_with(
-    ApacheAge::Validators::UniqueVertex,
+    ApacheAge::Validators::UniqueNode,
     attributes: <%= unique_attributes.inspect %>
   )
 end

data/lib/generators/apache_age/scaffold_edge/scaffold_edge_generator.rb

@@ -9,10 +9,9 @@ module ApacheAge
     include Rails::Generators::ResourceHelpers
 
     desc "Generates an edge, and its controller and views with the given attributes."
-
     source_root File.expand_path("templates", __dir__)
-
     argument :attributes, type: :array, default: [], banner: "field:type field:type"
+    class_option :skip_namespace, type: :boolean, default: true, desc: "Skip namespace 'rails_age' in generated files"
 
     def create_model_file
       invoke 'apache_age:edge', [name] + attributes.collect { |attr| "#{attr.name}:#{attr.type}" }

data/lib/generators/apache_age/scaffold_node/scaffold_node_generator.rb

@@ -9,10 +9,9 @@ module ApacheAge
     include Rails::Generators::ResourceHelpers
 
     desc "Generates a node, and its controller and views with the given attributes."
-
     source_root File.expand_path("templates", __dir__)
-
     argument :attributes, type: :array, default: [], banner: "field:type field:type"
+    class_option :skip_namespace, type: :boolean, default: true, desc: "Skip namespace 'rails_age' in generated files"
 
     def create_model_file
       invoke 'apache_age:node', [name] + attributes.collect { |attr| "#{attr.name}:#{attr.type}" }

data/lib/rails_age/version.rb

@@ -1,3 +1,3 @@
 module RailsAge
-  VERSION = '0.5.3'
+  VERSION = '0.6.1'
 end

data/lib/rails_age.rb

@@ -6,18 +6,19 @@ module RailsAge
 end
 
 module ApacheAge
+  require 'apache_age/cypher.rb'
+  require 'apache_age/entities/query_builder'
   require 'apache_age/entities/class_methods'
   require 'apache_age/entities/common_methods'
   require 'apache_age/entities/entity'
-  require 'apache_age/entities/vertex'
   require 'apache_age/entities/node'
   require 'apache_age/entities/edge'
+  # require 'apache_age/entities/path'
   require 'apache_age/node'
   require 'apache_age/edge'
+  # require 'apache_age/path'
   require 'apache_age/validators/expected_node_type'
   require 'apache_age/validators/unique_node'
   require 'apache_age/validators/unique_edge'
-  require 'apache_age/validators/unique_vertex'
-  require 'apache_age/types/age_type_factory'
-  require 'apache_age/types/age_type_generator'
+  require 'apache_age/types/factory'
 end

data/lib/tasks/config_types.rake

@@ -5,28 +5,28 @@ namespace :apache_age do
   desc "Install AGE types from rails_age into the rails initializers"
   task :config_types => :environment do
     types_file_path = File.expand_path("#{Rails.root}/config/initializers/types.rb", __FILE__)
-    required_file_path = "require 'apache_age/types/age_type_generator'"
+    required_file_path = "require 'apache_age/types/factory'"
     required_file_content =
       <<~RUBY
-      require 'apache_age/types/age_type_generator'
+      require 'apache_age/types/factory'
       # AGE Type Definition Usage (edges/nodes):
-      # require_dependency 'nodes/company'
+      # require_dependency 'company'
       # ActiveModel::Type.register(
-      #   :company, ApacheAge::Types::AgeTypeGenerator.create_type_for(Nodes::Company)
+      #   :company, ApacheAge::Types::Factory.type_for(Company)
       # )
       RUBY
     node_type_content =
 <<-RUBY
   require_dependency 'apache_age/node'
   ActiveModel::Type.register(
-    :node, ApacheAge::Types::AgeTypeGenerator.create_type_for(ApacheAge::Node)
+    :node, ApacheAge::Types::Factory.type_for(ApacheAge::Node)
   )
 RUBY
     edge_type_content =
 <<-RUBY
   require_dependency 'apache_age/edge'
   ActiveModel::Type.register(
-    :edge, ApacheAge::Types::AgeTypeGenerator.create_type_for(ApacheAge::Edge)
+    :edge, ApacheAge::Types::Factory.type_for(ApacheAge::Edge)
   )
 RUBY