rails_age 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa956147280cd1ef2125eb39f3dd7867eadafde15806d95b90dab30d1290b135
-  data.tar.gz: a5b3a61d2fcf3026f9503b1bb4a9c6e60c6317f92266501f2890c2a02af1a01d
+  metadata.gz: dc953f22e786b1ce4280d8ced0bcb6ca768f89773c49a4ad0d7ddd3e3505e91e
+  data.tar.gz: fff1d2809ce6f439196bfbc8a50b7990453d17def541829ef332ee2711a7fd3a
 SHA512:
-  metadata.gz: a2dbb2a72e8f64056bf6531fab29da715bdc89d1748dce2fe92a44de11b5a8c74dbc354c18a903472c996c90e01f7947c921819d3cded09b4ffbfe1cbd0da33c
-  data.tar.gz: d5265daf4c4a1928bdd8f7f08a1efd884f8c4ce5da38d56321f58f6f507905a24d7587d2f92bacfe5a4141e500f7f81060726a2723368b443d8892bf2e66a9b3
+  metadata.gz: e03cb391c29274953ab63badc3da19a9a965d53b23844086775d5668e61f32feba68605078b506c2a1ef8bde9d6627c67c087b7b1752acd2ccff681a55d4eec2
+  data.tar.gz: 6373605ea72f6d85babde6ba167135f3098bb6b04c60a56015a04670e48f40e452a2473ce974de2e5577d2930d267aff72e253fc0a1fe10f740def2b28c0cf1b

data/CHANGELOG.md

@@ -2,8 +2,6 @@
 
 ## VERSION 0.4.0 - 2024-xx-xx
 
-- **Edges**
-  * `find_edge` is deprecated - use `find_by` with :start_node, :end_node to find an edge with specific nodes
 - **cypher**
   * query support
   * paths support
@@ -11,16 +9,38 @@
 - **Paths**
   * ?
 
-## VERSION 0.3.1 - 2024-xx-xx
+## VERSION 0.3.4 - 2024-xx-xx
+
+- **Type Generators**
+  * add `rails generate apache_age:type`
+  * add `rails generate apache_age:node_type`
+  * add `rails generate apache_age:edge_type`
+
+## VERSION 0.3.3 - 2024-xx-xx
+
+- **Edge Generator**
+  * add `rails generate apache_age:edge` to create an edge model
+
+
+## VERSION 0.3.2 - 2024-06-08
+
+- **Node Generator**
+  * add `rails generate apache_age:node Pets/Cat name age:integer` creates a node with a namespace and attributes at: `app/nodes/pets/cat.rb`
+  * add `rails generate apache_age:node Cat name age:integer` creates a node with attributes at:  `app/nodes/cat.rb`
+  * add `rails destroy apache_age:node Cat` deletes an existing node at: `app/nodes/cat.rb`
+
+## VERSION 0.3.1 - 2024-06-02
 
-- **Genetator**
-  * add `rails generate apache_age:node` to create a node model (with its type in initializer)
-  * add `rails generate apache_age:edge` to create an edge model (with its type in initializer)
 - **Installer**
-  * refactored into multiple independent tasks?
+  * refactor into multiple independent tasks with tests
+- **Documentation**
+  * updated README with additional information
+  * added `db/structure.sql` config to README
 
 ## VERSION 0.3.0 - 2024-05-28
 
+- **Edges**
+  * `find_by(start_node:, :end_node:, properties:)` to find an edge with specific nodes & properties (deprecated `find_edge`)
 - **Installer** (`rails generate apache_age:install`)
   * copy Age PG Extenstion migration to `db/migrate`
   * run the AGE PG Migration

data/README.md

@@ -14,14 +14,22 @@ gem "rails_age"
 
 ### Quick Install
 
+using the installer, creates the migration to install age, runs the migration, and adjusts the schema file, and updates the `config/database.yml` file.
+
 ```bash
 $ bundle
 $ bin/rails apache_age:install
 $ git add .
 $ git commit -m "Add Apache Age to Rails"
+$ rails generate apache_age:node Company company_name
+$ rails generate apache_age:node Person first_name last_name age:integer
 ```
 
-NOTE: it is important to add the db/schema.rb to your git repository because `rails db:migrate` will inappropriately modify the schema file.  However, you can run `bin/rails apache_age:install` at any time to repair the schema file if needed.
+NOTE: it is important to commit the `db/schema.rb` to git because `rails db:migrate` inappropriately modifies the schema file (I haven't yet tested `db/structure.sql`).
+
+**You can run `bin/rails apache_age:install` at any time to repair the schema file as needed.**
+
+For now, if you are using `db/structure.sql` you will need to manually configure Apache Age (RailsAge) as described below.
 
 ### Manual Install
 
@@ -76,6 +84,7 @@ $ bin/rails db:migrate
 
 Rails migrate will mangle the schema `db/schema.rb` file.  You need to remove the lines that look like:
 ```ruby
+ActiveRecord::Schema[7.1].define(version: 2024_05_21_062349) do
   create_schema "ag_catalog"
   create_schema "age_schema"
 
@@ -99,12 +108,14 @@ Rails migrate will mangle the schema `db/schema.rb` file.  You need to remove th
 
   # other migrations
   # ...
+end
 ```
 
 and replace them with the following lines:
 ```ruby
+ActiveRecord::Schema[7.1].define(version: 2024_05_21_062349) do
   # These are extensions that must be enabled in order to support this database
-  enable_extension "plpgsql"
+  enable_extension 'plpgsql'
 
   # Allow age extension
   execute('CREATE EXTENSION IF NOT EXISTS age;')
@@ -120,14 +131,38 @@ and replace them with the following lines:
 
   # other migrations
   # ...
+end
 ```
 
-NOTE: I like to add the schema.rb to git so that it is easy to revert the unwanted changes and keep the desired changes.
-ALSO note that running: `bin/rails apache_age:install` will check and non-destructively repair any config files at any time (however a git commit before hand as a backup is a good idea incase something goes wrong!)
+NOTE: if using `db/structure.sql` use:
+```sql
+-- These are extensions that must be enabled in order to support this database
+CREATE EXTENSION IF NOT EXISTS plpgsql WITH SCHEMA public;
+
+-- Allow age extension (if not already enabled), this builds the age_catalog schema
+CREATE EXTENSION IF NOT EXISTS age;
+
+-- Load the age module
+LOAD 'age';
+
+-- Load the ag_catalog into the search path
+SET search_path = ag_catalog, "$user", public;
+
+-- Create age_schema graph if it doesn't exist
+SELECT create_graph('age_schema');
+
+# other migrations
+# ...
+
+INSERT INTO "schema_migrations" (version) VALUES
+('20110315075839'),
+--- ...
+('20240521062349');
+```
 
 ## Contributing
 
-Create an MR and tests and I will review it.
+Create an merge request (with tests) and I will review it/merge it when ready.
 
 ## License
 
@@ -135,9 +170,12 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Usage
 
+I suggest you creat a folder create a folder called `app/nodes` and `app/edges` to keep the code organized.
+I frequently use the `app/graphs` folder to keep all the graph related code together in a Module (as is done in the [rails age demo app](https://github.com/marpori/rails_age_demo_app))
+
 I suggest you creat a folder within app called `graphs` and under that create a folder called `nodes` and `edges`. This will help you keep your code organized.
 
-A full sample app can be found [here](https://github.com/marpori/rails_age_demo_app) the summary usage is described below.
+A trival, but fully functional [rails age demo app](https://github.com/marpori/rails_age_demo_app), based on the Flintstones Commic, is available for reference.
 
 ### Nodes
 
@@ -168,9 +206,8 @@ module Nodes
     attribute :last_name, :string, default: nil
     attribute :given_name, :string, default: nil
     attribute :nick_name, :string, default: nil
-    attribute :gender, :string, default: nil
 
-    validates :gender, :first_name, :last_name, :given_name, :nick_name,
+    validates :first_name, :last_name, :given_name, :nick_name,
               presence: true
 
     def initialize(**attributes)

data/db/schema.rb

@@ -1,6 +1,6 @@
 ActiveRecord::Schema[7.1].define(version: 2024_05_21_062349) do
   # These are extensions that must be enabled in order to support this database
-  enable_extension "plpgsql"
+  enable_extension 'plpgsql'
 
   # Allow age extension
   execute('CREATE EXTENSION IF NOT EXISTS age;')

data/lib/generators/apache_age/edge/USAGE

@@ -0,0 +1,54 @@
+Description:
+    This creates Apache AGE nodes that work seamlessly with Rails.
+    A node can be created with or without a namespace.
+    See the below examples.
+
+Example:
+    `bin/rails g apache_age:node Cat name age:integer`
+
+    This creates:
+        `app/nodes/cat.rb`
+
+    with the contents:
+        ```
+        class Cat
+          include ApacheAge::Entities::Vertex
+
+          attribute :name, :string
+          attribute :age, :integer
+
+          validates :name, presence: true
+          validates :age, presence: true
+
+          # unique node validator (remove any attributes that are not important to uniqueness)
+          validates_with(
+            ApacheAge::Validators::UniqueVertexValidator,
+            attributes: [:name, :age]
+          )
+        end
+        ```
+
+    A namespace can also be used:
+        `bin/rails g apache_age:node Animals/Cat name age:integer`
+
+    This creates:
+        `app/nodes/animals/cat.rb`
+
+    with the contents
+        ```
+        class Animals::Cat
+          include ApacheAge::Entities::Vertex
+
+          attribute :name, :string
+          attribute :age, :integer
+
+          validates :name, presence: true
+          validates :age, presence: true
+
+          # unique node validator (remove any attributes that are not important to uniqueness)
+          validates_with(
+            ApacheAge::Validators::UniqueVertexValidator,
+            attributes: [:name, :age]
+          )
+        end
+        ```

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

@@ -0,0 +1,56 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module ApacheAge
+  class EdgeGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path('templates', __dir__)
+    argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+    def perform_task
+      behavior == :invoke ? create_edge_file : destroy_edge_file
+    end
+
+    private
+
+    def create_edge_file
+      template "edge.rb.tt", File.join("app/edge", class_path, "#{file_name}.rb")
+    end
+
+    def destroy_edge_file
+      file_path = File.join("app/edge", class_path, "#{file_name}.rb")
+      File.delete(file_path) if File.exist?(file_path)
+    end
+
+    def attributes_list
+      attributes.map { |attr| { name: attr.name, type: attr.type } }
+    end
+
+    def unique_attributes
+      attributes_list.map { |attr| attr[:name].to_sym }
+    end
+
+    def parent_module
+      class_path.map(&:camelize).join('::')
+    end
+
+    def full_class_name
+      parent_module.empty? ? class_name : "#{parent_module}::#{class_name}"
+    end
+
+    def indented_namespace
+      return '' if parent_module.empty?
+
+      parent_module.split('::').map.with_index do |namespace, index|
+        "#{'  ' * index}module #{namespace}"
+      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
+  end
+end

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

@@ -0,0 +1,20 @@
+<%= indented_namespace %>
+<%= '  ' * class_path.length %>class <%= class_name %>
+<%= '  ' * class_path.length %>  include ApacheAge::Entities::Edge
+
+<%- attributes_list.each do |attribute| -%>
+<%= '  ' * class_path.length %>  attribute :<%= attribute[:name] %>, :<%= attribute[:reference] || attribute[:type] %>
+<%- end -%>
+
+<%= '  ' * class_path.length %>  validates :<%= unique_attributes.first %>, presence: true
+<%= '  ' * class_path.length %>  validate :validate_unique
+
+<%= '  ' * class_path.length %>  private
+
+<%= '  ' * class_path.length %>  def validate_unique
+<%= '  ' * class_path.length %>    ApacheAge::Validators::UniqueEdgeValidator
+<%= '  ' * class_path.length %>      .new(attributes: <%= unique_attributes.inspect %>)
+<%= '  ' * class_path.length %>      .validate(self)
+<%= '  ' * class_path.length %>  end
+<%= '  ' * class_path.length %>end
+<%= indented_end_namespace %>

data/lib/generators/apache_age/node/USAGE

@@ -0,0 +1,54 @@
+Description:
+    This creates Apache AGE nodes that work seamlessly with Rails.
+    A node can be created with or without a namespace.
+    See the below examples.
+
+Example:
+    `bin/rails g apache_age:node Cat name age:integer`
+
+    This creates:
+        `app/nodes/cat.rb`
+
+    with the contents:
+        ```
+        class Cat
+          include ApacheAge::Entities::Vertex
+
+          attribute :name, :string
+          attribute :age, :integer
+
+          validates :name, presence: true
+          validates :age, presence: true
+
+          # unique node validator (remove any attributes that are not important to uniqueness)
+          validates_with(
+            ApacheAge::Validators::UniqueVertexValidator,
+            attributes: [:name, :age]
+          )
+        end
+        ```
+
+    A namespace can also be used:
+        `bin/rails g apache_age:node Animals/Cat name age:integer`
+
+    This creates:
+        `app/nodes/animals/cat.rb`
+
+    with the contents
+        ```
+        class Animals::Cat
+          include ApacheAge::Entities::Vertex
+
+          attribute :name, :string
+          attribute :age, :integer
+
+          validates :name, presence: true
+          validates :age, presence: true
+
+          # unique node validator (remove any attributes that are not important to uniqueness)
+          validates_with(
+            ApacheAge::Validators::UniqueVertexValidator,
+            attributes: [:name, :age]
+          )
+        end
+        ```

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

@@ -0,0 +1,56 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module ApacheAge
+  class NodeGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path('templates', __dir__)
+    argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+    def perform_task
+      behavior == :invoke ? create_node_file : destroy_node_file
+    end
+
+    private
+
+    def create_node_file
+      template "node.rb.tt", File.join(destination_root, "app/nodes", class_path, "#{file_name}.rb")
+    end
+
+    def destroy_node_file
+      file_path = File.join(destination_root, "app/nodes", class_path, "#{file_name}.rb")
+      File.delete(file_path) if File.exist?(file_path)
+    end
+
+    def attributes_list
+      attributes.map { |attr| { name: attr.name, type: attr.type } }
+    end
+
+    def unique_attributes
+      attributes_list.map { |attr| attr[:name].to_sym }
+    end
+
+    def parent_module
+      class_path.map(&:camelize).join('::')
+    end
+
+    def full_class_name
+      parent_module.empty? ? class_name : "#{parent_module}::#{class_name}"
+    end
+
+    def indented_namespace
+      return '' if parent_module.empty?
+
+      parent_module.split('::').map.with_index do |namespace, index|
+        "#{'  ' * index}module #{namespace}"
+      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
+  end
+end

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

@@ -0,0 +1,17 @@
+class <%= class_name %>
+  include ApacheAge::Entities::Vertex
+
+<%- attributes_list.each do |attribute| -%>
+  attribute :<%= attribute[:name] %>, :<%= attribute[:type] %>
+<%- end -%>
+
+<%- attributes_list.each do |attribute| -%>
+  validates :<%= attribute[:name] %>, presence: true
+<%- end -%>
+
+  # unique node validator (remove any attributes that are not important to uniqueness)
+  validates_with(
+    ApacheAge::Validators::UniqueVertexValidator,
+    attributes: <%= unique_attributes.inspect %>
+  )
+end

data/lib/rails_age/version.rb

@@ -1,3 +1,3 @@
 module RailsAge
-  VERSION = '0.3.0'
+  VERSION = '0.3.2'
 end

data/lib/tasks/copy_migrations.rake

@@ -0,0 +1,33 @@
+# lib/tasks/install.rake
+# Usage:
+# * `bin/rails apache_age:copy_migrations`
+# * `bundle exec rails apache_age:copy_migrations[destination_path.to_s]`
+# * `bundle exec rails apache_age:copy_migrations.invoke(destination_path.to_s)`
+namespace :apache_age do
+  desc "Copy migrations from rails_age to application and update schema"
+  task :copy_migrations, [:destination_path] => :environment do |t, args|
+    source = File.expand_path('../../../db/migrate', __FILE__)
+    destination_path =
+      File.expand_path(args[:destination_path].presence || "#{Rails.root}/db/migrate", __FILE__)
+
+    FileUtils.mkdir_p(destination_path) unless File.exist?(destination_path)
+    existing_migrations =
+      Dir.glob("#{destination_path}/*.rb").map { |file| File.basename(file).sub(/^\d+/, '') }
+
+    Dir.glob("#{source}/*.rb").each do |file|
+      filename = File.basename(file)
+      test_name = filename.sub(/^\d+/, '')
+
+      if existing_migrations.include?(test_name)
+        puts "Skipping migration: '#{filename}', it already exists"
+      else
+        migration_version = Time.now.utc.strftime("%Y_%m_%d_%H%M%S")
+        file_version = migration_version.delete('_')
+        new_filename = filename.sub(/^\d+/, file_version)
+        destination_file = File.join(destination_path, new_filename)
+        FileUtils.cp(file, destination_file)
+        puts "Created migration: '#{new_filename}'"
+      end
+    end
+  end
+end

data/lib/tasks/database_config.rake

@@ -0,0 +1,99 @@
+# lib/tasks/install.rake
+# Usage: `rake apache_age:copy_migrations`
+#
+namespace :apache_age do
+  desc "Ensure the database.yml file is properly configured for Apache Age"
+  task :database_config => :environment do
+
+    db_config_file = File.expand_path("#{Rails.root}/config/database.yml", __FILE__)
+
+    # Read the file
+    lines = File.readlines(db_config_file)
+
+    # any uncommented "schema_search_path:" lines?
+    path_index = lines.find_index { |line| !line.include?('#') && line.include?('schema_search_path:') }
+    default_start_index = lines.index { |line| line.strip.start_with?('default:') }
+
+    # when it finds an existing schema_search_path, it updates it
+    if path_index && lines[path_index].include?('ag_catalog,age_schema')
+      puts "the schema_search_path in config/database.yml is already properly set, nothing to do."
+    else
+      if path_index
+        key, val = lines[path_index].split(': ')
+        # remove any unwanted characters
+        val = val.gsub(/[ "\s\"\"'\n]/, '')
+        lines[path_index] = "#{key}: ag_catalog,age_schema,#{val}\n"
+        puts "added ag_catalog,age_schema to schema_search_path in config/database.yml"
+      elsif default_start_index
+        puts "the schema_search_path in config/database.yml is now properly set."
+        sections_index = lines.map.with_index { |line, index| index if !line.start_with?(' ') }.compact.sort
+
+        # find the start of the default section
+        next_section_in_list = sections_index.index(default_start_index) + 1
+
+        # find the end of the default section (before the next section starts)
+        path_insert_index = sections_index[next_section_in_list]
+
+        lines.insert(path_insert_index, "  schema_search_path: ag_catalog,age_schema,public\n")
+      else
+        puts "didn't find a default section in database.yml, please add the following line:"
+        puts "  schema_search_path: ag_catalog,age_schema,public"
+        puts "to the apprpriate section of your database.yml"
+      end
+
+      # Write the modified lines back to the file
+      File.open(db_config_file, 'w') { |file| file.write(lines.join) }
+    end
+  end
+end
+
+# # lib/tasks/install.rake
+# # Usage: `rake apache_age:copy_migrations`
+# #
+# namespace :apache_age do
+#   desc "Ensure the database.yml file is properly configured for Apache Age"
+#   task :database_config, [:destination_path] => :environment do |t, args|
+#     destination_path =
+#       File.expand_path(args[:destination_path].presence || "#{Rails.root}/config", __FILE__)
+
+#     db_config_file = File.expand_path("#{destination_path.to_s}/database.yml", __FILE__)
+
+#     # Read the file
+#     lines = File.readlines(db_config_file)
+
+#     # any uncommented "schema_search_path:" lines?
+#     path_index = lines.find_index { |line| !line.include?('#') && line.include?('schema_search_path:') }
+#     default_start_index = lines.index { |line| line.strip.start_with?('default:') }
+
+#     # when it finds an existing schema_search_path, it updates it
+#     if path_index && lines[path_index].include?('ag_catalog,age_schema')
+#       puts "the schema_search_path in config/database.yml is already properly set, nothing to do."
+#     else
+#       if path_index
+#         key, val = lines[path_index].split(': ')
+#         # remove any unwanted characters
+#         val = val.gsub(/[ "\s\"\"'\n]/, '')
+#         lines[path_index] = "#{key}: ag_catalog,age_schema,#{val}\n"
+#         puts "added ag_catalog,age_schema to schema_search_path in config/database.yml"
+#       elsif default_start_index
+#         puts "the schema_search_path in config/database.yml is now properly set."
+#         sections_index = lines.map.with_index { |line, index| index if !line.start_with?(' ') }.compact.sort
+
+#         # find the start of the default section
+#         next_section_in_list = sections_index.index(default_start_index) + 1
+
+#         # find the end of the default section (before the next section starts)
+#         path_insert_index = sections_index[next_section_in_list]
+
+#         lines.insert(path_insert_index, "  schema_search_path: ag_catalog,age_schema,public\n")
+#       else
+#         puts "didn't find a default section in database.yml, please add the following line:"
+#         puts "  schema_search_path: ag_catalog,age_schema,public"
+#         puts "to the apprpriate section of your database.yml"
+#       end
+
+#       # Write the modified lines back to the file
+#       File.open(db_config_file, 'w') { |file| file.write(lines.join) }
+#     end
+#   end
+# end

data/lib/tasks/install.original.rake

@@ -0,0 +1,257 @@
+# lib/tasks/install.rake
+# Usage: `rake apache_age:install`
+#
+namespace :apache_age do
+  desc "Install & configure Apache Age within Rails (updates migrations, schema & database.yml)"
+  task :install_old => :environment do
+    source_schema = File.expand_path('../../../db/schema.rb', __FILE__)
+    destination_schema = File.expand_path("#{Rails.root}/db/schema.rb", __FILE__)
+    source_migrations = File.expand_path('../../../db/migrate', __FILE__)
+    destination_migrations = File.expand_path("#{Rails.root}/db/migrate", __FILE__)
+    # create the migrations folder if needed
+    FileUtils.mkdir_p(destination_migrations) unless File.exist?(destination_migrations)
+    original_migrations =
+      Dir.glob("#{destination_migrations}/*.rb").map { |file| File.basename(file).sub(/^\d+/, '') }
+
+    # # check if the schema is non-existent or blank (NEW) we need to know how to handle schema
+    # is_schema_blank = !File.exist?(destination_schema) || blank_schema?(destination_schema)
+    # puts "Schema is blank: #{is_schema_blank}"
+
+    # ensure we have a schema file
+    unless File.exist?(destination_schema)
+      run_db_create
+      run_db_migrate
+    end
+
+    # copy our migrations to the application (last_migration_version is nil if no migration necessary)
+    # last_migration_version = copy_migrations
+    Rake::Task["apache_age:copy_migrations"].invoke
+
+    updated_migrations =
+      Dir.glob("#{destination_migrations}/*.rb").map { |file| File.basename(file).sub(/^\d+/, '') }
+
+    # # run our new migrations (unless we have not added any new migrations)
+    # if original_migrations == updated_migrations
+    #   puts "no new migrations were copied, skipping migrations"
+    # else
+    #   puts "added Apache Age migrations, running migrations"
+    #   run_db_migrate
+    # end
+    run_db_migrate
+
+    # adjust the schema file (unfortunately rails mangles the schema file)
+    # if is_schema_blank
+    #   puts "creating new schema..."
+    #   create_new_schema(last_migration_version, destination_schema, source_schema)
+    # else
+    #   puts "updating existing schema..."
+    #   update_existing_schema(last_migration_version, destination_schema, source_schema)
+    # end
+    Rake::Task["apache_age:schema_config"].invoke
+
+    # ensure the config/database.yml file has the proper configurations
+    # update_database_yml
+    Rake::Task["apache_age:database_config"].invoke
+  end
+
+  def run_db_create
+    puts "Running db:create..."
+    Rake::Task["db:create"].invoke
+  end
+
+  def run_db_migrate
+    puts "Running db:migrate..."
+    Rake::Task["db:migrate"].invoke
+  end
+
+  def copy_migrations
+    migration_version = nil
+
+    source = File.expand_path('../../../db/migrate', __FILE__)
+    destination = File.expand_path("#{Rails.root}/db/migrate", __FILE__)
+
+    FileUtils.mkdir_p(destination) unless File.exist?(destination)
+    existing_migrations =
+      Dir.glob("#{destination}/*.rb").map { |file| File.basename(file).sub(/^\d+/, '') }
+
+    Dir.glob("#{source}/*.rb").each do |file|
+      filename = File.basename(file)
+      test_name = filename.sub(/^\d+/, '')
+
+      if existing_migrations.include?(test_name)
+        puts "Skipping #{filename}, it already exists"
+      else
+        migration_version = Time.now.utc.strftime("%Y_%m_%d_%H%M%S")
+        file_version = migration_version.delete('_')
+        new_filename = filename.sub(/^\d+/, file_version)
+        destination_file = File.join(destination, new_filename)
+        FileUtils.cp(file, destination_file)
+        puts "Copied #{filename} to #{destination} as #{new_filename}"
+      end
+    end
+    migration_version
+  end
+
+  def blank_schema?(destination_schema)
+    return false unless File.exist?(destination_schema)
+
+    content = File.read(destination_schema)
+    content.include?('define(version: 0)') &&
+      (content.include?("enable_extension 'plpgsql'") || content.include?('enable_extension "plpgsql"')) &&
+      content.scan(/enable_extension/).size == 1
+  end
+
+  def schema_rails_version(destination_schema)
+    if File.exist?(destination_schema)
+      content = File.read(destination_schema)
+      version_match = content.match(/ActiveRecord::Schema\[(.*?)\]/)
+      return version_match[1] if version_match
+    else
+      full_version = Rails.version
+      primary_secondary_version = full_version.split('.')[0..1].join('.')
+      primary_secondary_version
+    end
+  end
+
+  def create_new_schema(last_migration_version, destination_schema, source_schema)
+    if File.exist?(source_schema) && File.exist?(destination_schema)
+      rails_version = schema_rails_version(destination_schema)
+      source_content = File.read(source_schema)
+
+      # ensure we use the Rails version from the destination schema
+      source_content.gsub!(
+        /ActiveRecord::Schema\[\d+\.\d+\]/,
+        "ActiveRecord::Schema[#{rails_version}]"
+      )
+      # ensure we use the last migration version (not the source schema version)
+      source_content.gsub!(
+        /define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do/,
+        "define(version: #{last_migration_version}) do"
+      )
+
+      File.write(destination_schema, source_content)
+      puts "Created new schema in #{destination_schema} with necessary extensions and configurations."
+    else
+      puts "local db/schema.rb file not found."
+    end
+  end
+
+  def update_existing_schema(last_migration_version, destination_schema, source_schema)
+    if File.exist?(source_schema) && File.exist?(destination_schema)
+      rails_version = schema_rails_version(destination_schema)
+      source_content = File.read(source_schema)
+      new_content =
+        source_content.gsub(
+          /.*ActiveRecord::Schema\[\d+\.\d+\]\.define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do\n|\nend$/,
+          ''
+        )
+
+      destination_content = File.read(destination_schema)
+
+      # Remove unwanted schema statements
+      destination_content.gsub!(%r{^.*?create_schema "ag_catalog".*?\n}, '')
+      destination_content.gsub!(%r{^.*?create_schema "age_schema".*?\n}, '')
+      destination_content.gsub!(%r{^.*?enable_extension "age".*?\n}, '')
+      destination_content.gsub!(%r{^.*?enable_extension "plpgsql".*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_graph" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'regnamespace' for column 'namespace'.*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_label" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'regclass' for column 'relation'.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'graphid' for column 'id'.*?\n}, '')
+      destination_content.gsub!(
+        %r{^.*?# Could not dump table "_ag_label_edge" because of following StandardError.*?\n}, ''
+      )
+      destination_content.gsub!(
+        %r{^.*?# Could not dump table "_ag_label_vertex" because of following StandardError.*?\n}, ''
+      )
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_graph" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_label" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?add_foreign_key "ag_label", "ag_graph".*?\n}, '')
+
+      # add new wanted schema statements (at the top of the schema)
+      unless destination_content.include?(%{execute("LOAD 'age';")}) &&
+             destination_content.include?(%{enable_extension 'plpgsql'}) &&
+             destination_content.include?(%{execute("SELECT create_graph('age_schema');")}) &&
+             destination_content.include?(%{execute('CREATE EXTENSION IF NOT EXISTS age;')}) &&
+             destination_content.include?(%{execute('SET search_path = ag_catalog, "$user", public;')})
+        # if not all are found then remove any found
+        destination_content.gsub!(%r{^.*?execute("LOAD 'age';")*?\n}, '')
+        destination_content.gsub!(%r{^.*?enable_extension 'plpgsql'*?\n}, '')
+        destination_content.gsub!(%r{^.*?execute("SELECT create_graph('age_schema');")*?\n}, '')
+        destination_content.gsub!(%r{^.*?execute('CREATE EXTENSION IF NOT EXISTS age;')*?\n}, '')
+        destination_content.gsub!(%r{^.*?execute('SET search_path = ag_catalog, "$user", public;')*?\n}, '')
+        destination_content.gsub!(%r{^.*?# Allow age extension*?\n}, '')
+        destination_content.gsub!(%r{^.*?# Load the ag_catalog into the search path*?\n}, '')
+        destination_content.gsub!(%r{^.*?# Create age_schema graph if it doesn't exist*?\n}, '')
+        destination_content.gsub!(%r{^.*?# These are extensions that must be enabled in order to support this database*?\n}, '')
+
+        # add all of the correct settings back in
+        destination_content.sub!(
+          %r{(ActiveRecord::Schema\[\d+\.\d+\]\.define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do\n)},
+          "\\1#{new_content}\n"
+        )
+          puts 'db/schema.rb has been updated with the necessary configuration.'
+      else
+        puts 'db/schema.rb has the necessary configuration, no adjustments necessary'
+      end
+
+      existing_version = destination_content.match(/define\(version: (\d{4}(?:_\d{2}){2}(?:_\d{6})?)\)/)[1].gsub('_', '')
+      current_version = last_migration_version ? last_migration_version.gsub('_', '') : existing_version
+
+      # ensure we use the last migration version (not the source schema version)
+      if current_version.to_i > existing_version.to_i
+        destination_content.gsub!(
+          /define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do/,
+          "define(version: #{last_migration_version}) do"
+        )
+        puts "Updated schema version to the migration version #{last_migration_version}"
+      end
+
+      File.write(destination_schema, destination_content)
+      puts "Updated #{destination_schema} with necessary extensions and configurations."
+    else
+      puts "local db/schema.rb file not found."
+    end
+  end
+
+  def update_database_yml
+    db_config_file = File.expand_path("#{Rails.root}/config/database.yml", __FILE__)
+
+    # Read the file
+    lines = File.readlines(db_config_file)
+
+    # any uncommented "schema_search_path:" lines?
+    path_index = lines.find_index { |line| !line.include?('#') && line.include?('schema_search_path:') }
+    default_start_index = lines.index { |line| line.strip.start_with?('default:') }
+
+    # when it finds an existing schema_search_path, it updates it
+    if path_index && lines[path_index].include?('ag_catalog,age_schema')
+      puts "schema_search_path already set to ag_catalog,age_schema nothing to do."
+      return
+    elsif path_index
+      key, val = lines[path_index].split(': ')
+      # remove any unwanted characters
+      val = val.gsub(/[ "\s\"\"'\n]/, '')
+      lines[path_index] = "#{key}: ag_catalog,age_schema,#{val}\n"
+      puts "add ag_catalog,age_schema to schema_search_path"
+    elsif default_start_index
+      puts "add ag_catalog,age_schema,public to schema_search_path in the default section of database.yml"
+      sections_index = lines.map.with_index { |line, index| index if !line.start_with?(' ') }.compact.sort
+
+      # find the start of the default section
+      next_section_in_list = sections_index.index(default_start_index) + 1
+
+      # find the end of the default section (before the next section starts)
+      path_insert_index = sections_index[next_section_in_list]
+
+      lines.insert(path_insert_index, "  schema_search_path: ag_catalog,age_schema,public\n")
+    else
+      puts "didn't find a default section in database.yml, please add the following line:"
+      puts "  schema_search_path: ag_catalog,age_schema,public"
+      puts "to the apprpriate section of your database.yml"
+    end
+
+    # Write the modified lines back to the file
+    File.open(db_config_file, 'w') { |file| file.write(lines.join) }
+  end
+end

data/lib/tasks/install.rake

@@ -2,209 +2,18 @@
 # Usage: `rake apache_age:install`
 #
 namespace :apache_age do
-  desc "Copy migrations from rails_age to application and update schema"
+  desc "Install & configure Apache Age within Rails (updates migrations, schema & database.yml)"
   task :install => :environment do
-    source_schema = File.expand_path('../../../db/schema.rb', __FILE__)
-    destination_schema = File.expand_path("#{Rails.root}/db/schema.rb", __FILE__)
+    # copy our migrations to the application (if needed)
+    Rake::Task["apache_age:copy_migrations"].invoke
 
-    # ensure we have a schema file
-    run_migrations
-
-    # copy our migrations to the application
-    last_migration_version = copy_migrations
-
-    # check if the schema is blank (NEW) before running migrations!
-    is_schema_blank = blank_schema?(destination_schema)
-    puts "Schema is blank: #{is_schema_blank}"
-
-    # run our new migrations
-    run_migrations
-
-    # adjust the schema file (unfortunately rails mangles the schema file)
-    if is_schema_blank
-      puts "creating new schema..."
-      create_new_schema(last_migration_version, destination_schema, source_schema)
-    else
-      puts "updating existing schema..."
-      update_existing_schema(last_migration_version, destination_schema, source_schema)
-    end
-
-    update_database_yml
-  end
-
-  def copy_migrations
-    migration_version = nil
-
-    source = File.expand_path('../../../db/migrate', __FILE__)
-    destination = File.expand_path("#{Rails.root}/db/migrate", __FILE__)
-
-    FileUtils.mkdir_p(destination) unless File.exist?(destination)
-    existing_migrations =
-      Dir.glob("#{destination}/*.rb").map { |file| File.basename(file).sub(/^\d+/, '') }
-
-    Dir.glob("#{source}/*.rb").each do |file|
-      filename = File.basename(file)
-      test_name = filename.sub(/^\d+/, '')
-
-      if existing_migrations.include?(test_name)
-        puts "Skipping #{filename}, it already exists"
-      else
-        migration_version = Time.now.utc.strftime("%Y_%m_%d_%H%M%S")
-        file_version = migration_version.delete('_')
-        new_filename = filename.sub(/^\d+/, file_version)
-        destination_file = File.join(destination, new_filename)
-        FileUtils.cp(file, destination_file)
-        puts "Copied #{filename} to #{destination} as #{new_filename}"
-      end
-    end
-    migration_version
-  end
-
-  def blank_schema?(destination_schema)
-    return false unless File.exist?(destination_schema)
-
-    content = File.read(destination_schema)
-    content.include?('define(version: 0)') &&
-      content.include?('enable_extension "plpgsql"') &&
-      content.scan(/enable_extension/).size == 1
-  end
-
-  def run_migrations
-    puts "Running migrations..."
+    # run any new migrations
     Rake::Task["db:migrate"].invoke
-  end
-
-  def extract_rails_version(destination_schema)
-    if File.exist?(destination_schema)
-      content = File.read(destination_schema)
-      version_match = content.match(/ActiveRecord::Schema\[(.*?)\]/)
-      return version_match[1] if version_match
-    else
-      full_version = Rails.version
-      primary_secondary_version = full_version.split('.')[0..1].join('.')
-      primary_secondary_version
-    end
-  end
 
-  def create_new_schema(last_migration_version, destination_schema, source_schema)
-    if File.exist?(source_schema) && File.exist?(destination_schema)
-      rails_version = extract_rails_version(destination_schema)
-      source_content = File.read(source_schema)
-
-      # ensure we use the Rails version from the destination schema
-      source_content.gsub!(
-        /ActiveRecord::Schema\[\d+\.\d+\]/,
-        "ActiveRecord::Schema[#{rails_version}]"
-      )
-      # ensure we use the last migration version (not the source schema version)
-      source_content.gsub!(
-        /define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do/,
-        "define(version: #{last_migration_version}) do"
-      )
-
-      File.write(destination_schema, source_content)
-      puts "Created new schema in #{destination_schema} with necessary extensions and configurations."
-    else
-      puts "local db/schema.rb file not found."
-    end
-  end
-
-  def update_existing_schema(last_migration_version, destination_schema, source_schema)
-    if File.exist?(source_schema) && File.exist?(destination_schema)
-      rails_version = extract_rails_version(destination_schema)
-      source_content = File.read(source_schema)
-      new_content =
-        source_content.gsub(
-          /.*ActiveRecord::Schema\[\d+\.\d+\]\.define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do\n|\nend$/,
-          ''
-        )
-
-      destination_content = File.read(destination_schema)
-
-      # Remove unwanted schema statements
-      destination_content.gsub!(%r{^.*?# These are extensions that must be enabled in order to support this database.*?\n}, '')
-
-      destination_content.gsub!(%r{^.*?create_schema "ag_catalog".*?\n}, '')
-      destination_content.gsub!(%r{^.*?create_schema "age_schema".*?\n}, '')
-      destination_content.gsub!(%r{^.*?enable_extension "age".*?\n}, '')
-      destination_content.gsub!(%r{^.*?enable_extension "plpgsql".*?\n}, '')
-      destination_content.gsub!(%r{^.*?# Could not dump table "ag_graph" because of following StandardError.*?\n}, '')
-      destination_content.gsub!(%r{^.*?#   Unknown type 'regnamespace' for column 'namespace'.*?\n}, '')
-      destination_content.gsub!(%r{^.*?# Could not dump table "ag_label" because of following StandardError.*?\n}, '')
-      destination_content.gsub!(%r{^.*?#   Unknown type 'regclass' for column 'relation'.*?\n}, '')
-      destination_content.gsub!(%r{^.*?#   Unknown type 'graphid' for column 'id'.*?\n}, '')
-      destination_content.gsub!(
-        %r{^.*?# Could not dump table "_ag_label_edge" because of following StandardError.*?\n}, ''
-      )
-      destination_content.gsub!(
-        %r{^.*?# Could not dump table "_ag_label_vertex" because of following StandardError.*?\n}, ''
-      )
-      destination_content.gsub!(%r{^.*?# Could not dump table "ag_graph" because of following StandardError.*?\n}, '')
-      destination_content.gsub!(%r{^.*?# Could not dump table "ag_label" because of following StandardError.*?\n}, '')
-      destination_content.gsub!(%r{^.*?add_foreign_key "ag_label", "ag_graph".*?\n}, '')
-
-      # add new wanted schema statements (at the top of the schema)
-      destination_content.sub!(
-        %r{(ActiveRecord::Schema\[\d+\.\d+\]\.define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do\n)},
-        "\\1#{new_content}\n"
-      )
-
-      existing_version = destination_content.match(/define\(version: (\d{4}(?:_\d{2}){2}(?:_\d{6})?)\)/)[1].gsub('_', '')
-      current_version = last_migration_version ? last_migration_version.gsub('_', '') : existing_version
-
-      # ensure we use the last migration version (not the source schema version)
-      if current_version.to_i > existing_version.to_i
-        destination_content.gsub!(
-          /define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do/,
-          "define(version: #{last_migration_version}) do"
-        )
-      end
-
-      File.write(destination_schema, destination_content)
-      puts "Updated #{destination_schema} with necessary extensions and configurations."
-    else
-      puts "local db/schema.rb file not found."
-    end
-  end
-
-  def update_database_yml
-    db_config_file = File.expand_path("#{Rails.root}/config/database.yml", __FILE__)
-
-    # Read the file
-    lines = File.readlines(db_config_file)
-
-    # any uncommented "schema_search_path:" lines?
-    path_index = lines.find_index { |line| !line.include?('#') && line.include?('schema_search_path:') }
-    default_start_index = lines.index { |line| line.strip.start_with?('default:') }
-
-    # when it finds an existing schema_search_path, it updates it
-    if path_index && lines[path_index].include?('ag_catalog,age_schema')
-      puts "schema_search_path already set to ag_catalog,age_schema nothing to do."
-      return
-    elsif path_index
-      key, val = lines[path_index].split(': ')
-      # remove any unwanted characters
-      val = val.gsub(/[ "\s\"\"'\n]/, '')
-      lines[path_index] = "#{key}: ag_catalog,age_schema,#{val}\n"
-      puts "add ag_catalog,age_schema to schema_search_path"
-    elsif default_start_index
-      puts "add ag_catalog,age_schema,public to schema_search_path in the default section of database.yml"
-      sections_index = lines.map.with_index { |line, index| index if !line.start_with?(' ') }.compact.sort
-
-      # find the start of the default section
-      next_section_in_list = sections_index.index(default_start_index) + 1
-
-      # find the end of the default section (before the next section starts)
-      path_insert_index = sections_index[next_section_in_list]
-
-      lines.insert(path_insert_index, "  schema_search_path: ag_catalog,age_schema,public\n")
-    else
-      puts "didn't find a default section in database.yml, please add the following line:"
-      puts "  schema_search_path: ag_catalog,age_schema,public"
-      puts "to the apprpriate section of your database.yml"
-    end
+    # adjust the schema file (unfortunately rails mangles the schema file)
+    Rake::Task["apache_age:schema_config"].invoke
 
-    # Write the modified lines back to the file
-    File.open(db_config_file, 'w') { |file| file.write(lines.join) }
+    # ensure the config/database.yml file has the proper configurations
+    Rake::Task["apache_age:database_config"].invoke
   end
 end

data/lib/tasks/schema_config.rake

@@ -0,0 +1,95 @@
+# lib/tasks/install.rake
+# Usage: `rake apache_age:schema_config`
+#
+namespace :apache_age do
+  desc "Copy migrations from rails_age to application and update schema"
+  task :schema_config => :environment do
+    # source_schema = File.expand_path('../../../db/schema.rb', __FILE__)
+    destination_schema = File.expand_path("#{Rails.root}/db/schema.rb", __FILE__)
+
+    unless File.exist?(destination_schema)
+      puts "local db/schema.rb file not found. please run db:create and db:migrate first"
+    else
+      destination_content = File.read(destination_schema)
+
+      # Remove unwanted schema statements
+      destination_content.gsub!(%r{^.*?create_schema "ag_catalog".*?\n}, '')
+      destination_content.gsub!(%r{^.*?create_schema "age_schema".*?\n}, '')
+      destination_content.gsub!(%r{^.*?enable_extension "age".*?\n}, '')
+      destination_content.gsub!(%r{^.*?enable_extension "plpgsql".*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_graph" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'regnamespace' for column 'namespace'.*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_label" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'regclass' for column 'relation'.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'graphid' for column 'id'.*?\n}, '')
+      destination_content.gsub!(
+        %r{^.*?# Could not dump table "_ag_label_edge" because of following StandardError.*?\n}, ''
+      )
+      destination_content.gsub!(
+        %r{^.*?# Could not dump table "_ag_label_vertex" because of following StandardError.*?\n}, ''
+      )
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_graph" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_label" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?add_foreign_key "ag_label", "ag_graph".*?\n}, '')
+
+      # add necessary contents (as needed)
+      if destination_content.include?(%{execute("LOAD 'age';")}) &&
+              destination_content.include?(%{enable_extension 'plpgsql'}) &&
+              destination_content.include?(%{execute("SELECT create_graph('age_schema');")}) &&
+              destination_content.include?(%{execute('CREATE EXTENSION IF NOT EXISTS age;')}) &&
+              destination_content.include?(%{execute('SET search_path = ag_catalog, "$user", public;')})
+        puts "schema.rb is properly configured, nothing to do"
+      else
+        # if not all are found then remove any found
+        destination_content.gsub!(%r{^.*?execute("LOAD 'age';")*?\n}, '')
+        destination_content.gsub!(%r{^.*?enable_extension 'plpgsql'*?\n}, '')
+        destination_content.gsub!(%r{^.*?execute("SELECT create_graph('age_schema');")*?\n}, '')
+        destination_content.gsub!(%r{^.*?execute('CREATE EXTENSION IF NOT EXISTS age;')*?\n}, '')
+        destination_content.gsub!(%r{^.*?execute('SET search_path = ag_catalog, "$user", public;')*?\n}, '')
+        destination_content.gsub!(%r{^.*?# Allow age extension*?\n}, '')
+        destination_content.gsub!(%r{^.*?# Load the ag_catalog into the search path*?\n}, '')
+        destination_content.gsub!(%r{^.*?# Create age_schema graph if it doesn't exist*?\n}, '')
+        destination_content.gsub!(%r{^.*?# These are extensions that must be enabled in order to support this database*?\n}, '')
+
+        # add all of the correct settings back in
+        # source_content = File.read(source_schema)
+        source_content =
+          <<~RUBY
+          ActiveRecord::Schema[7.1].define(version: 2024_05_21_062349) do
+            # These are extensions that must be enabled in order to support this database
+            enable_extension 'plpgsql'
+
+            # Allow age extension
+            execute('CREATE EXTENSION IF NOT EXISTS age;')
+
+            # Load the age code
+            execute("LOAD 'age';")
+
+            # Load the ag_catalog into the search path
+            execute('SET search_path = ag_catalog, "$user", public;')
+
+            # Create age_schema graph if it doesn't exist
+            execute("SELECT create_graph('age_schema');")
+          end
+          RUBY
+
+        age_config_contents =
+          source_content.gsub(
+            /.*ActiveRecord::Schema\[\d+\.\d+\]\.define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do\n|\nend$/,
+            ''
+          )
+
+        destination_content.sub!(
+          %r{(ActiveRecord::Schema\[\d+\.\d+\]\.define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do\n)},
+          "\\1#{age_config_contents}\n"
+        )
+      end
+
+      # Remove multiple consecutive empty lines
+      destination_content.gsub!(/\n{2,}/, "\n\n")
+
+      File.write(destination_schema, destination_content)
+      puts "The schema '#{destination_schema}' is ready to work with Apache Age."
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_age
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Bill Tihen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-28 00:00:00.000000000 Z
+date: 2024-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -76,11 +76,20 @@ files:
 - lib/apache_age/validators/unique_edge_validator.rb
 - lib/apache_age/validators/unique_vertex_validator.rb
 - lib/apache_age/validators/vertex_type_validator.rb
+- lib/generators/apache_age/edge/USAGE
+- lib/generators/apache_age/edge/edge_generator.rb
+- lib/generators/apache_age/edge/templates/edge.rb.tt
+- lib/generators/apache_age/node/USAGE
+- lib/generators/apache_age/node/node_generator.rb
+- lib/generators/apache_age/node/templates/node.rb.tt
 - lib/rails_age.rb
 - lib/rails_age/engine.rb
 - lib/rails_age/version.rb
+- lib/tasks/copy_migrations.rake
+- lib/tasks/database_config.rake
+- lib/tasks/install.original.rake
 - lib/tasks/install.rake
-- lib/tasks/rails_age_tasks.rake
+- lib/tasks/schema_config.rake
 homepage: https://github.com/marpori/rails_age
 licenses:
 - MIT

data/lib/tasks/rails_age_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :rails_age do
-#   # Task goes here
-# end