sidenotes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3d148544eafc19e2884ef9cd774c8d65c09ba29c6bce5a2cfaf1c139dc6eee4b
+  data.tar.gz: 583fd447f4e4469d32ab5179190a4be72d6f57a990379ef504b81462907b9061
+SHA512:
+  metadata.gz: fb0d4ad4bbc6faf74a9cc2097d777f2b0e41ba03b2843eb266bc709c1c14f9dba62d5d9017147aa6b9b1c96fcb5be17f98b810f3522bda98abd05dd0d95c92c4
+  data.tar.gz: ef5bebedb9a3536e92729859d7fb65778540c27813fc8b071f0a20ba6f030e3d25c835556a54c82b48696521c3090416a704e15a914e43e6e9132c4f4b1c9bb2

data/.rubocop.yml

@@ -0,0 +1,22 @@
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
+  Exclude:
+    - "spec/**/*"
+    - "vendor/**/*"
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/ClassLength:
+  Max: 150
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-04-08
+
+### Added
+
+- Initial release
+- YAML and JSON annotation output formats
+- Column inspection: name, type, default, nullable, limit, precision, scale, comment
+- Index inspection: name, columns, unique, where, using
+- Association inspection: type, name, class_name, foreign_key, polymorphic, through
+- Foreign key and check constraint inspection
+- Model metadata: table name, primary key, STI column, enums, encrypted attributes
+- Support for STI, polymorphic, HABTM, namespaced, and self-referential models
+- Configurable sections, output directory, and exclusion patterns
+- Rake tasks: `sidenotes:generate`, `sidenotes:clean`, `sidenotes:model`
+- Rails generator: `rails generate sidenotes:install`
+- Ruby 3.0+ and Rails 6.1+ support

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Wes Mason
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,206 @@
+# Sidenotes
+
+[![CI](https://github.com/1stvamp/sidenotes-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/1stvamp/sidenotes-ruby/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/sidenotes.svg)](https://badge.fury.io/rb/sidenotes)
+
+Structured YAML/JSON schema annotations for Rails models, as sidecar files, not inline comments.
+
+Sidenotes generates metadata files alongside your Rails models, giving you rich schema information without cluttering your source files. IDEs, editors, and tooling can consume these files to surface column types, indexes, associations, and more.
+
+## Why Sidenotes over annotate?
+
+| | annotate | sidenotes |
+|---|---|---|
+| Output | Inline comments in model files | Separate sidecar files |
+| Git noise | Every schema change touches model files | Annotation files **can be gitignored** |
+| Format | Plain text | Structured YAML/JSON |
+| Machine-readable | No | Yes; IDEs and tools can parse it |
+| Merge conflicts | Frequent on model files | None, annotations are local |
+| Customizable sections | Limited | Columns, indexes, associations, FKs, constraints, metadata |
+
+## Installation
+
+Add to your Gemfile's development group:
+
+```ruby
+group :development do
+  gem "sidenotes"
+end
+```
+
+Then run `bundle install` and generate annotations:
+
+```bash
+bundle install
+rake sidenotes:generate
+```
+
+That's it. Sidenotes works with sensible defaults and no configuration.
+
+### Optional setup
+
+If you want to customise the configuration, run the install generator:
+
+```bash
+rails generate sidenotes:install
+```
+
+This creates `config/initializers/sidenotes.rb` (guarded with `return unless defined?(Sidenotes)` so it's safe in production) and adds `.annotations/` to your `.gitignore`.
+
+If you'd prefer to commit your annotations, skip the gitignore step:
+
+```bash
+rails generate sidenotes:install --no-gitignore
+```
+
+## Usage
+
+### Generate annotations for all models
+
+```bash
+rake sidenotes:generate
+```
+
+### Generate for a single model
+
+```bash
+rake sidenotes:model MODEL=User
+```
+
+### Remove all annotation files
+
+```bash
+rake sidenotes:clean
+```
+
+### Example output
+
+Running `rake sidenotes:generate` creates `.annotations/user.yml`:
+
+```yaml
+# Generated by Sidenotes v0.1.0 on 2026-04-08 12:00:00 UTC
+# Do not edit manually - regenerate with `rake sidenotes:generate`
+---
+User:
+  metadata:
+    table_name: users
+    primary_key: id
+    enums:
+      role:
+      - member
+      - admin
+      - moderator
+  columns:
+  - name: id
+    type: integer
+    nullable: false
+  - name: name
+    type: string
+    nullable: false
+  - name: email
+    type: string
+    nullable: false
+    limit: 255
+  - name: role
+    type: string
+    default: member
+    nullable: true
+  indexes:
+  - name: index_users_on_email
+    columns:
+    - email
+    unique: true
+  associations:
+  - type: has_many
+    name: posts
+    foreign_key: user_id
+  - type: has_one
+    name: profile
+    foreign_key: user_id
+  foreign_keys: []
+```
+
+## Configuration
+
+```ruby
+# config/initializers/sidenotes.rb
+return unless defined?(Sidenotes)
+
+Sidenotes.configure do |config|
+  # Directory for annotation files (relative to Rails root)
+  config.output_directory = ".annotations"
+
+  # Output format: :yaml (default) or :json
+  config.format = :yaml
+
+  # Sections to include
+  # Available: :columns, :indexes, :associations, :foreign_keys,
+  #            :check_constraints, :metadata
+  config.sections = %i[columns indexes associations foreign_keys metadata]
+
+  # Where to look for model files
+  config.model_paths = ["app/models"]
+
+  # Exclude models by name or pattern
+  config.exclude_patterns = [
+    "ApplicationRecord",
+    /^HABTM_/,
+    /^ActiveStorage::/
+  ]
+end
+```
+
+### Configuration reference
+
+| Option | Default | Description |
+|---|---|---|
+| `output_directory` | `".annotations"` | Where annotation files are written |
+| `format` | `:yaml` | Output format (`:yaml` or `:json`) |
+| `sections` | `[:columns, :indexes, :associations, :foreign_keys, :metadata]` | Which sections to include |
+| `model_paths` | `["app/models"]` | Directories to scan for models |
+| `exclude_patterns` | `[]` | Strings or regexps to exclude models |
+
+## Namespaced models
+
+Namespaced models are written to subdirectories matching their namespace:
+
+- `Admin::User` → `.annotations/admin/user.yml`
+- `Api::V2::Widget` → `.annotations/api/v2/widget.yml`
+
+## IDE integration
+
+### VS Code
+
+The companion [sidenotes-vscode](https://github.com/1stvamp/sidenotes-vscode) extension reads `.annotations/` files and displays schema information inline as you edit models. Hover over a model name to see its columns, or use the sidebar panel for a full schema overview.
+
+Search for "Rails Sidenotes" in the VS Code marketplace.
+
+### JetBrains (RubyMine, IntelliJ)
+
+The [sidenotes-jetbrains](https://github.com/1stvamp/sidenotes-jetbrains) plugin provides the same inline schema display for JetBrains IDEs. Install it from the JetBrains Marketplace.
+
+### Other editors
+
+The structured YAML/JSON format makes it straightforward to build integrations for any editor. The schema is stable and documented; see the example output above for the full structure.
+
+## Requirements
+
+- Ruby >= 3.1
+- Rails >= 6.1
+
+## Development
+
+```bash
+git clone https://github.com/1stvamp/sidenotes-ruby.git
+cd sidenotes
+bundle install
+bundle exec rspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/1stvamp/sidenotes-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/generators/sidenotes/install_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module Sidenotes
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      class_option :gitignore, type: :boolean, default: true,
+                               desc: 'Add .annotations/ to .gitignore'
+
+      desc 'Creates an optional Sidenotes initializer for customising configuration'
+
+      def copy_initializer
+        template 'initializer.rb', 'config/initializers/sidenotes.rb'
+      end
+
+      def add_to_gitignore
+        return unless options[:gitignore]
+
+        gitignore = File.join(destination_root, '.gitignore')
+        return unless File.exist?(gitignore)
+
+        content = File.read(gitignore)
+        return if content.include?('.annotations/')
+
+        append_to_file '.gitignore', "\n# Sidenotes schema annotations\n.annotations/\n"
+      end
+    end
+  end
+end

data/lib/generators/sidenotes/templates/initializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+return unless defined?(Sidenotes)
+
+Sidenotes.configure do |config|
+  # Directory where annotation files are generated (relative to Rails root)
+  # config.output_directory = ".annotations"
+
+  # Output format: :yaml (default) or :json
+  # config.format = :yaml
+
+  # Sections to include in annotations
+  # Available: :columns, :indexes, :associations, :foreign_keys, :check_constraints, :metadata
+  # config.sections = %i[columns indexes associations foreign_keys metadata]
+
+  # Paths to search for model files (relative to Rails root)
+  # config.model_paths = ["app/models"]
+
+  # Patterns to exclude models (strings or regexps)
+  # config.exclude_patterns = ["ApplicationRecord", /^HABTM_/]
+end

data/lib/sidenotes/configuration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Sidenotes
+  class Configuration
+    VALID_FORMATS = %i[yaml json].freeze
+    VALID_SECTIONS = %i[columns indexes associations foreign_keys check_constraints metadata].freeze
+    DEFAULT_SECTIONS = %i[columns indexes associations foreign_keys metadata].freeze
+
+    attr_reader :output_directory, :format, :sections
+    attr_accessor :model_paths, :exclude_patterns
+
+    def initialize
+      @output_directory = '.annotations'
+      @format = :yaml
+      @sections = DEFAULT_SECTIONS.dup
+      @model_paths = ['app/models']
+      @exclude_patterns = []
+    end
+
+    def format=(value)
+      value = value.to_sym
+      unless VALID_FORMATS.include?(value)
+        raise ArgumentError, "Invalid format: #{value}. Valid formats: #{VALID_FORMATS.join(', ')}"
+      end
+
+      @format = value
+    end
+
+    def sections=(value)
+      value = Array(value).map(&:to_sym)
+      invalid = value - VALID_SECTIONS
+      unless invalid.empty?
+        raise ArgumentError, "Invalid sections: #{invalid.join(', ')}. Valid sections: #{VALID_SECTIONS.join(', ')}"
+      end
+
+      @sections = value
+    end
+
+    def output_directory=(value)
+      value = value.to_s
+      if value.empty? || value == '.' || value.start_with?('/')
+        raise ArgumentError, "output_directory must be a relative path within the project (got: #{value.inspect})"
+      end
+
+      @output_directory = value
+    end
+
+    def file_extension
+      case @format
+      when :yaml then 'yml'
+      when :json then 'json'
+      else raise ArgumentError, "Unknown format: #{@format}"
+      end
+    end
+  end
+end

data/lib/sidenotes/formatter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+
+module Sidenotes
+  class Formatter
+    HEADER_COMMENT = "# Generated by Sidenotes v%<version>s on %<timestamp>s\n" \
+                     "# Do not edit manually — regenerate with `rake sidenotes:generate`\n"
+
+    def initialize(model_name, data)
+      @model_name = model_name
+      @data = data
+    end
+
+    def render
+      case Sidenotes.configuration.format
+      when :yaml then render_yaml
+      when :json then render_json
+      end
+    end
+
+    private
+
+    def render_yaml
+      header = format(
+        HEADER_COMMENT,
+        version: Sidenotes::VERSION,
+        timestamp: Time.now.utc.strftime('%Y-%m-%d %H:%M:%S UTC')
+      )
+
+      content = { @model_name => @data }
+      yaml_output = YAML.dump(content)
+      # Remove the leading "---\n" for cleaner output, we'll add the header instead
+      yaml_output = yaml_output.sub(/\A---\n/, '')
+
+      "#{header}---\n#{yaml_output}"
+    end
+
+    def render_json
+      content = {
+        '_generated_by' => "Sidenotes v#{Sidenotes::VERSION}",
+        '_generated_at' => Time.now.utc.strftime('%Y-%m-%d %H:%M:%S UTC'),
+        @model_name => @data
+      }
+
+      JSON.pretty_generate(content)
+    end
+  end
+end

data/lib/sidenotes/generator.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Sidenotes
+  class Generator
+    attr_reader :models_generated, :models_skipped
+
+    def initialize
+      @models_generated = []
+      @models_skipped = []
+    end
+
+    def generate_all
+      discover_models.each { |model| generate_for(model) }
+      self
+    end
+
+    def generate_for(model)
+      model = resolve_model(model)
+      inspector = ModelInspector.new(model)
+
+      unless inspector.inspectable?
+        @models_skipped << model.name
+        return nil
+      end
+
+      data = inspector.inspect_model
+      return nil unless data
+
+      output = Formatter.new(model.name, data).render
+      path = write_file(model, output)
+      @models_generated << model.name
+      path
+    end
+
+    def clean
+      dir = Sidenotes.configuration.output_directory
+      return unless File.directory?(dir)
+
+      remove_annotation_files(dir)
+      remove_empty_dirs(dir)
+    end
+
+    def discover_models
+      load_model_files
+      collect_models
+    end
+
+    private
+
+    def remove_annotation_files(dir)
+      ext = Sidenotes.configuration.file_extension
+      Dir.glob(File.join(dir, '**', "*.#{ext}")).each do |f|
+        File.delete(f) if File.read(f, 64)&.include?('Sidenotes')
+      end
+    end
+
+    def remove_empty_dirs(dir)
+      Dir.glob(File.join(dir, '**', '*')).reverse_each do |d|
+        Dir.rmdir(d) if File.directory?(d) && Dir.empty?(d)
+      end
+      Dir.rmdir(dir) if File.directory?(dir) && Dir.empty?(dir)
+    end
+
+    def resolve_model(model)
+      return model if model.is_a?(Class)
+
+      model.to_s.constantize
+    end
+
+    def load_model_files
+      return if defined?(Rails) && Rails.application&.config&.eager_load
+
+      model_file_paths.each do |file|
+        require file
+      rescue LoadError, NameError => e
+        warn "Sidenotes: could not load #{file}: #{e.message}"
+      end
+    end
+
+    def model_file_paths
+      Sidenotes.configuration.model_paths.flat_map do |path|
+        full_path = defined?(Rails) ? Rails.root.join(path) : Pathname.new(path)
+        Dir.glob(full_path.join('**', '*.rb'))
+      end
+    end
+
+    def collect_models
+      models = ActiveRecord::Base.descendants.select do |model|
+        next false if model.abstract_class?
+        next false if excluded?(model)
+
+        true
+      end
+
+      models.sort_by(&:name)
+    end
+
+    def excluded?(model)
+      config = Sidenotes.configuration
+      config.exclude_patterns.any? do |pattern|
+        case pattern
+        when Regexp then model.name.match?(pattern)
+        when String then model.name == pattern
+        else false
+        end
+      end
+    end
+
+    def write_file(model, content)
+      config = Sidenotes.configuration
+      relative_path = model_to_path(model)
+      file_path = File.join(config.output_directory, "#{relative_path}.#{config.file_extension}")
+
+      FileUtils.mkdir_p(File.dirname(file_path))
+      File.write(file_path, content)
+      file_path
+    end
+
+    def model_to_path(model)
+      # Admin::User => admin/user
+      model.name.underscore
+    end
+  end
+end

data/lib/sidenotes/model_inspector.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Sidenotes
+  class ModelInspector
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+    end
+
+    SECTION_METHODS = {
+      metadata: :metadata,
+      columns: :columns,
+      indexes: :indexes,
+      associations: :associations,
+      foreign_keys: :foreign_keys
+    }.freeze
+
+    def inspect_model
+      return nil unless inspectable?
+
+      data = {}
+      sections = Sidenotes.configuration.sections
+
+      SECTION_METHODS.each do |section, method|
+        data[section.to_s] = send(method) if sections.include?(section)
+      end
+
+      if sections.include?(:check_constraints) && supports_check_constraints?
+        data['check_constraints'] = check_constraints
+      end
+
+      data
+    end
+
+    def inspectable?
+      return false if model.abstract_class?
+      return false unless model.respond_to?(:table_name)
+
+      model.table_exists?
+    rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+      false
+    end
+
+    private
+
+    def metadata
+      meta = {
+        'table_name' => model.table_name,
+        'primary_key' => model.primary_key
+      }
+
+      add_sti_metadata(meta)
+      add_enum_metadata(meta)
+      add_encrypted_metadata(meta)
+
+      meta
+    end
+
+    def add_sti_metadata(meta)
+      return unless model.respond_to?(:inheritance_column)
+      return unless model.columns_hash.key?(model.inheritance_column)
+      return if model.descends_from_active_record?
+
+      meta['sti_column'] = model.inheritance_column
+    end
+
+    def add_enum_metadata(meta)
+      return unless model.respond_to?(:defined_enums) && model.defined_enums.any?
+
+      meta['enums'] = model.defined_enums.transform_values { |v| v.is_a?(Hash) ? v.keys : v }
+    end
+
+    def add_encrypted_metadata(meta)
+      encrypted = model.try(:encrypted_attributes)
+      meta['encrypted_attributes'] = encrypted.map(&:to_s) if encrypted&.any?
+    end
+
+    def columns
+      model.columns.map { |col| build_column_data(col) }
+    end
+
+    def build_column_data(col)
+      data = { 'name' => col.name, 'type' => col.type.to_s }
+      data['default'] = col.default unless col.default.nil?
+      data['nullable'] = col.null
+      data['limit'] = col.limit if col.limit
+      data['precision'] = col.precision if col.precision
+      data['scale'] = col.scale if col.scale
+      data['comment'] = col.comment if col.respond_to?(:comment) && col.comment
+      data
+    end
+
+    def indexes
+      connection = model.connection
+      connection.indexes(model.table_name).map do |idx|
+        index_data = {
+          'name' => idx.name,
+          'columns' => Array(idx.columns)
+        }
+
+        index_data['unique'] = idx.unique if idx.unique
+        index_data['where'] = idx.where if idx.respond_to?(:where) && idx.where
+        index_data['using'] = idx.using.to_s if idx.respond_to?(:using) && idx.using
+
+        index_data
+      end
+    end
+
+    def associations
+      model.reflect_on_all_associations.map { |assoc| build_association_data(assoc) }
+    end
+
+    def build_association_data(assoc)
+      data = { 'type' => assoc.macro.to_s, 'name' => assoc.name.to_s }
+      data['class_name'] = assoc.class_name if assoc.class_name != assoc.name.to_s.classify
+      data['foreign_key'] = assoc.foreign_key.to_s if assoc.respond_to?(:foreign_key)
+      opts = assoc.respond_to?(:options) ? assoc.options : {}
+      data['polymorphic'] = true if opts[:polymorphic]
+      data['through'] = opts[:through].to_s if opts[:through]
+      data
+    end
+
+    def foreign_keys
+      connection = model.connection
+      return [] unless connection.respond_to?(:foreign_keys)
+
+      connection.foreign_keys(model.table_name).map do |fk|
+        fk_data = {
+          'from_column' => fk.column,
+          'to_table' => fk.to_table,
+          'to_column' => fk.primary_key
+        }
+
+        fk_data['name'] = fk.name if fk.name
+        fk_data['on_delete'] = fk.on_delete.to_s if fk.on_delete
+        fk_data['on_update'] = fk.on_update.to_s if fk.on_update
+
+        fk_data
+      end
+    end
+
+    def check_constraints
+      connection = model.connection
+      return [] unless connection.respond_to?(:check_constraints)
+
+      connection.check_constraints(model.table_name).map do |cc|
+        {
+          'name' => cc.name,
+          'expression' => cc.expression
+        }
+      end
+    rescue NotImplementedError
+      []
+    end
+
+    def supports_check_constraints?
+      model.connection.respond_to?(:check_constraints)
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/sidenotes/railtie.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sidenotes
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      namespace :sidenotes do
+        desc 'Generate annotation files for all models'
+        task generate: :environment do
+          Sidenotes::Railtie.run_generate
+        end
+
+        desc 'Remove all annotation files'
+        task clean: :environment do
+          Sidenotes::Generator.new.clean
+          puts "Sidenotes: Cleaned annotation files from #{Sidenotes.configuration.output_directory}"
+        end
+
+        desc 'Generate annotation for a single model (MODEL=User)'
+        task model: :environment do
+          Sidenotes::Railtie.run_model
+        end
+      end
+    end
+
+    def self.run_generate
+      generator = Sidenotes::Generator.new
+      generator.generate_all
+
+      puts "Sidenotes: Generated #{generator.models_generated.size} annotation(s)"
+      generator.models_generated.each { |m| puts "  #{m}" }
+
+      return unless generator.models_skipped.any?
+
+      puts "Skipped #{generator.models_skipped.size} model(s):"
+      generator.models_skipped.each { |m| puts "  #{m} (skipped)" }
+    end
+
+    def self.run_model
+      model_name = ENV.fetch('MODEL', nil)
+      abort 'Usage: rake sidenotes:model MODEL=User' unless model_name
+
+      generator = Sidenotes::Generator.new
+      path = generator.generate_for(model_name)
+
+      if path
+        puts "Sidenotes: Generated #{path}"
+      else
+        puts "Sidenotes: Could not generate annotation for #{model_name}"
+      end
+    end
+  end
+end

data/lib/sidenotes/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sidenotes
+  VERSION = '0.1.0'
+end

data/lib/sidenotes.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'sidenotes/version'
+require_relative 'sidenotes/configuration'
+require_relative 'sidenotes/model_inspector'
+require_relative 'sidenotes/formatter'
+require_relative 'sidenotes/generator'
+
+module Sidenotes
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end
+
+require_relative 'sidenotes/railtie' if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: sidenotes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wes Mason
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+description: Generates structured schema annotation files for Rails models as gitignored
+  sidecar files, replacing inline comments with separate metadata files that IDEs
+  and tools can consume.
+email:
+- wesley.mason@pinpointhq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/generators/sidenotes/install_generator.rb
+- lib/generators/sidenotes/templates/initializer.rb
+- lib/sidenotes.rb
+- lib/sidenotes/configuration.rb
+- lib/sidenotes/formatter.rb
+- lib/sidenotes/generator.rb
+- lib/sidenotes/model_inspector.rb
+- lib/sidenotes/railtie.rb
+- lib/sidenotes/version.rb
+homepage: https://github.com/1stvamp/sidenotes-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/1stvamp/sidenotes-ruby
+  source_code_uri: https://github.com/1stvamp/sidenotes-ruby
+  changelog_uri: https://github.com/1stvamp/sidenotes-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Structured YAML/JSON schema annotations for Rails models as sidecar files
+test_files: []