auto_glossary 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fddd93fba68c2b99a3ea1e2017393b053f0341ec1ee68815bd90afaf23166ea0
+  data.tar.gz: 4bb4aeb3e1752b1cc3965229586785ca91b49ccbe994b3db665fd42fd40c074d
+SHA512:
+  metadata.gz: ece9e23d884a593aa881e15be743d2eb9293dac1b1ab3576410036c10b3704c903d42fb9cde3d751ddd198162aeb7e93a0b2f4bac8d6794d1a73616b809de31f
+  data.tar.gz: c9bcd7372a7216cb60309e2a6e658619bf6472d2f49e8450a2283214963a5c2a82d5bc64a69df736eb034c69fd8c47e632c8190189ab22ba012726dddcd02a69

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Will Johnston
+
+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,35 @@
+# AutoGlossary
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/auto_glossary`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/auto_glossary.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/app/assets/stylesheets/glossary.css

@@ -0,0 +1,180 @@
+/* Glossary term styling */
+.glossary-term {
+  text-decoration: underline dotted;
+  text-decoration-color: rgba(0, 100, 200, 0.8);
+  text-decoration-thickness: 2px;
+  text-underline-offset: 3px;
+  cursor: help;
+  transition: text-decoration-color 0.2s ease;
+}
+
+.glossary-term:hover {
+  text-decoration-color: rgba(0, 100, 200, 1);
+  text-decoration-thickness: 2.5px;
+}
+
+.glossary-term:focus {
+  outline: 2px solid rgba(0, 100, 200, 0.5);
+  outline-offset: 2px;
+  border-radius: 2px;
+}
+
+/* Tooltip styling */
+.glossary-tooltip {
+  position: absolute;
+  z-index: 10000;
+  background: #2c3e50;
+  color: #fff;
+  padding: 8px 12px;
+  border-radius: 4px;
+  font-size: 0.9rem;
+  line-height: 1.4;
+  max-width: 300px;
+  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.2);
+  pointer-events: none;
+}
+
+.glossary-tooltip::before {
+  content: '';
+  position: absolute;
+  bottom: 100%;
+  left: 20px;
+  border: 6px solid transparent;
+  border-bottom-color: #2c3e50;
+}
+
+.glossary-tooltip em {
+  color: #95a5a6;
+  font-style: italic;
+}
+
+/* Modal styling */
+.glossary-modal {
+  display: none;
+  position: fixed;
+  z-index: 9999;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.glossary-modal.active {
+  display: block;
+}
+
+.glossary-modal-backdrop {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(2px);
+}
+
+.glossary-modal-dialog {
+  position: relative;
+  margin: 50px auto;
+  max-width: 600px;
+  background: #fff;
+  border-radius: 8px;
+  box-shadow: 0 10px 25px rgba(0, 0, 0, 0.3);
+  animation: slideDown 0.3s ease;
+}
+
+@keyframes slideDown {
+  from {
+    opacity: 0;
+    transform: translateY(-50px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.glossary-modal-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 20px;
+  border-bottom: 1px solid #e0e0e0;
+}
+
+.glossary-modal-title {
+  margin: 0;
+  font-size: 1.5rem;
+  font-weight: 600;
+  color: #2c3e50;
+  text-transform: capitalize;
+}
+
+.glossary-modal-close {
+  background: none;
+  border: none;
+  font-size: 2rem;
+  line-height: 1;
+  color: #95a5a6;
+  cursor: pointer;
+  padding: 0;
+  width: 30px;
+  height: 30px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 4px;
+  transition: all 0.2s ease;
+}
+
+.glossary-modal-close:hover {
+  background: #ecf0f1;
+  color: #2c3e50;
+}
+
+.glossary-modal-body {
+  padding: 20px;
+}
+
+.glossary-modal-content {
+  font-size: 1rem;
+  line-height: 1.6;
+  color: #34495e;
+}
+
+.glossary-modal-content p {
+  margin: 0 0 15px 0;
+}
+
+.glossary-modal-content p:last-child {
+  margin-bottom: 0;
+}
+
+.glossary-attribution {
+  margin-top: 20px;
+  padding-top: 15px;
+  border-top: 1px solid #e0e0e0;
+  color: #7f8c8d;
+}
+
+.glossary-attribution a {
+  color: #3498db;
+  text-decoration: none;
+}
+
+.glossary-attribution a:hover {
+  text-decoration: underline;
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+  .glossary-modal-dialog {
+    margin: 20px;
+    max-width: calc(100% - 40px);
+  }
+
+  .glossary-tooltip {
+    max-width: 250px;
+    font-size: 0.85rem;
+  }
+}

data/app/controllers/auto_glossary/glossary_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AutoGlossary
+  class GlossaryController < ApplicationController
+    skip_before_action :verify_authenticity_token, only: [:definition]
+
+    # GET /glossary/definition?term=basidiospore
+    def definition
+      term = params[:term]
+
+      if term.blank?
+        render json: { error: "Term parameter is required" }, status: :bad_request
+        return
+      end
+
+      definition = AutoGlossary::WikipediaGlossaryService.get_definition(term)
+
+      if definition
+        render json: { term: term, definition: definition }
+      else
+        render json: { error: "Definition not found", term: term }, status: :not_found
+      end
+    rescue StandardError => e
+      Rails.logger.error "Error fetching glossary definition: #{e.message}"
+      render json: { error: "Internal server error" }, status: :internal_server_error
+    end
+
+    # GET /glossary - Optional: browse all terms
+    def index
+      @terms = AutoGlossary::WikipediaGlossaryService.fetch_glossary_terms
+      @terms = @terms.sort_by { |k, _v| k.downcase }
+    end
+  end
+end

data/app/helpers/auto_glossary/glossary_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module AutoGlossary
+  module GlossaryHelper
+    # Mark glossary terms in text with special HTML markup
+    # Options:
+    #   first_only: true - only mark first occurrence of each term (default: true)
+    def mark_glossary_terms(text, options = {})
+      return text if text.blank?
+
+      first_only = options.fetch(:first_only, true)
+      marked_terms = Set.new
+
+      terms = AutoGlossary::WikipediaGlossaryService.fetch_glossary_terms
+      return text if terms.empty?
+
+      # Sort terms by length (longest first) to avoid partial matches
+      sorted_terms = terms.keys.sort_by { |t| -t.length }
+
+      result = text.dup
+
+      sorted_terms.each do |term|
+        # Skip if we've already marked this term and first_only is true
+        next if first_only && marked_terms.include?(term.downcase)
+
+        # Create regex pattern for word boundaries
+        # Match the term with optional 's' for plural
+        pattern = /\b(#{Regexp.escape(term)}s?)\b/i
+
+        # Replace first or all occurrences
+        if first_only
+          result = result.sub(pattern) do |match|
+            marked_terms.add(term.downcase)
+            glossary_term_tag(match)
+          end
+        else
+          result = result.gsub(pattern) do |match|
+            glossary_term_tag(match)
+          end
+        end
+      end
+
+      result.html_safe
+    end
+
+    private
+
+    def glossary_term_tag(term)
+      # Normalize to singular form for lookup
+      normalized = normalize_term_for_lookup(term)
+      %(<span class="glossary-term" data-term="#{CGI.escapeHTML(normalized)}" tabindex="0">#{CGI.escapeHTML(term)}</span>)
+    end
+
+    def normalize_term_for_lookup(term)
+      normalized = term.downcase.strip
+
+      # Remove common plural endings
+      if normalized.end_with?("s") && !normalized.end_with?("ss")
+        # Try removing 's' for simple plurals
+        singular = normalized.chomp("s")
+
+        # Check if singular form exists in glossary
+        terms = AutoGlossary::WikipediaGlossaryService.fetch_glossary_terms
+        return singular if terms.keys.any? { |k| k.downcase == singular }
+      end
+
+      normalized
+    end
+  end
+end

data/app/javascript/controllers/glossary_controller.js

@@ -0,0 +1,199 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["modal", "modalContent", "tooltip"]
+  static values = {
+    url: { type: String, default: "/glossary/definition" }
+  }
+
+  connect() {
+    this.tooltipElement = null
+    this.currentTerm = null
+    this.definitionCache = new Map()
+
+    // Add event listeners to all glossary terms
+    this.attachGlossaryListeners()
+  }
+
+  disconnect() {
+    this.removeTooltip()
+  }
+
+  attachGlossaryListeners() {
+    document.querySelectorAll('.glossary-term').forEach(term => {
+      term.addEventListener('mouseenter', this.showTooltip.bind(this))
+      term.addEventListener('mouseleave', this.hideTooltip.bind(this))
+      term.addEventListener('click', this.showModal.bind(this))
+      term.addEventListener('keydown', this.handleKeydown.bind(this))
+    })
+  }
+
+  showTooltip(event) {
+    const term = event.target.dataset.term
+    if (!term) return
+
+    this.currentTerm = term
+
+    // Show loading tooltip
+    this.createTooltip(event.target, 'Loading...')
+
+    // Fetch definition
+    this.fetchDefinition(term).then(definition => {
+      if (this.currentTerm === term) {
+        this.updateTooltip(this.truncateDefinition(definition, 150))
+      }
+    })
+  }
+
+  hideTooltip(event) {
+    // Small delay to allow moving to modal
+    setTimeout(() => {
+      if (!this.modalOpen) {
+        this.removeTooltip()
+      }
+    }, 100)
+  }
+
+  createTooltip(element, content) {
+    this.removeTooltip()
+
+    this.tooltipElement = document.createElement('div')
+    this.tooltipElement.className = 'glossary-tooltip'
+    this.tooltipElement.innerHTML = content
+    document.body.appendChild(this.tooltipElement)
+
+    this.positionTooltip(element)
+  }
+
+  updateTooltip(content) {
+    if (this.tooltipElement) {
+      this.tooltipElement.innerHTML = content
+    }
+  }
+
+  removeTooltip() {
+    if (this.tooltipElement) {
+      this.tooltipElement.remove()
+      this.tooltipElement = null
+    }
+    this.currentTerm = null
+  }
+
+  positionTooltip(element) {
+    if (!this.tooltipElement) return
+
+    const rect = element.getBoundingClientRect()
+    const tooltipRect = this.tooltipElement.getBoundingClientRect()
+
+    let top = rect.bottom + window.scrollY + 5
+    let left = rect.left + window.scrollX
+
+    // Adjust if tooltip goes off screen
+    if (left + tooltipRect.width > window.innerWidth) {
+      left = window.innerWidth - tooltipRect.width - 10
+    }
+
+    if (top + tooltipRect.height > window.innerHeight + window.scrollY) {
+      top = rect.top + window.scrollY - tooltipRect.height - 5
+    }
+
+    this.tooltipElement.style.top = `${top}px`
+    this.tooltipElement.style.left = `${left}px`
+  }
+
+  showModal(event) {
+    event.preventDefault()
+    const term = event.target.dataset.term
+    if (!term) return
+
+    this.modalOpen = true
+    this.removeTooltip()
+
+    // Create modal if it doesn't exist
+    if (!this.hasModalTarget) {
+      this.createModal()
+    }
+
+    this.modalTarget.querySelector('.glossary-modal-content').innerHTML = '<p>Loading...</p>'
+    this.modalTarget.classList.add('active')
+    this.modalTarget.querySelector('.glossary-modal-title').textContent = term
+
+    this.fetchDefinition(term).then(definition => {
+      const content = this.modalTarget.querySelector('.glossary-modal-content')
+      content.innerHTML = `
+        <p>${definition}</p>
+        <p class="glossary-attribution">
+          <small>Source: <a href="https://en.wikipedia.org/wiki/Glossary_of_mycology" target="_blank" rel="noopener">Wikipedia Glossary of Mycology</a> (CC BY-SA 4.0)</small>
+        </p>
+      `
+    })
+  }
+
+  hideModal() {
+    if (this.hasModalTarget) {
+      this.modalTarget.classList.remove('active')
+    }
+    this.modalOpen = false
+  }
+
+  createModal() {
+    const modal = document.createElement('div')
+    modal.className = 'glossary-modal'
+    modal.dataset.glossaryTarget = 'modal'
+    modal.innerHTML = `
+      <div class="glossary-modal-backdrop" data-action="click->glossary#hideModal"></div>
+      <div class="glossary-modal-dialog">
+        <div class="glossary-modal-header">
+          <h3 class="glossary-modal-title"></h3>
+          <button type="button" class="glossary-modal-close" data-action="click->glossary#hideModal">&times;</button>
+        </div>
+        <div class="glossary-modal-body">
+          <div class="glossary-modal-content"></div>
+        </div>
+      </div>
+    `
+    document.body.appendChild(modal)
+  }
+
+  handleKeydown(event) {
+    if (event.key === 'Enter' || event.key === ' ') {
+      event.preventDefault()
+      this.showModal(event)
+    }
+  }
+
+  async fetchDefinition(term) {
+    // Check cache first
+    if (this.definitionCache.has(term)) {
+      return this.definitionCache.get(term)
+    }
+
+    try {
+      const response = await fetch(`${this.urlValue}?term=${encodeURIComponent(term)}`, {
+        headers: {
+          'Accept': 'application/json'
+        }
+      })
+
+      if (!response.ok) {
+        throw new Error('Failed to fetch definition')
+      }
+
+      const data = await response.json()
+      const definition = data.definition || 'Definition not found.'
+
+      // Cache the definition
+      this.definitionCache.set(term, definition)
+
+      return definition
+    } catch (error) {
+      console.error('Error fetching glossary definition:', error)
+      return 'Unable to load definition.'
+    }
+  }
+
+  truncateDefinition(text, maxLength) {
+    if (text.length <= maxLength) return text
+    return text.substring(0, maxLength) + '... <em>(click for more)</em>'
+  }
+}

data/app/services/auto_glossary/wikipedia_glossary_service.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module AutoGlossary
+  class WikipediaGlossaryService
+    GLOSSARY_PAGE = "Glossary_of_mycology"
+    API_ENDPOINT = "https://en.wikipedia.org/w/api.php"
+    CACHE_EXPIRY = 24.hours
+
+    class << self
+      # Fetch all glossary terms from Wikipedia
+      def fetch_glossary_terms
+        Rails.cache.fetch("wikipedia_glossary_terms", expires_in: CACHE_EXPIRY) do
+          parse_glossary_page
+        end
+      end
+
+      # Get definition for a specific term
+      def get_definition(term)
+        normalized_term = normalize_term(term)
+        terms = fetch_glossary_terms
+
+        # Try exact match first
+        definition = terms[normalized_term]
+        return definition if definition
+
+        # Try case-insensitive match
+        terms.each do |key, value|
+          return value if key.downcase == normalized_term.downcase
+        end
+
+        # Try removing plural 's' if no match found
+        if normalized_term.end_with?("s") && !normalized_term.end_with?("ss")
+          singular = normalized_term.chomp("s")
+          definition = terms[singular]
+          return definition if definition
+
+          # Try case-insensitive singular match
+          terms.each do |key, value|
+            return value if key.downcase == singular.downcase
+          end
+        end
+
+        # Try removing 'es' ending (e.g., "hyphes" -> "hypha")
+        if normalized_term.end_with?("es")
+          singular = normalized_term.chomp("es")
+          definition = terms[singular]
+          return definition if definition
+
+          terms.each do |key, value|
+            return value if key.downcase == singular.downcase
+          end
+        end
+
+        nil
+      end
+
+      # Check if a term exists in the glossary
+      def term_exists?(term)
+        normalized_term = normalize_term(term)
+        terms = fetch_glossary_terms
+
+        terms.key?(normalized_term) || terms.keys.any? { |k| k.downcase == normalized_term.downcase }
+      end
+
+      private
+
+      def normalize_term(term)
+        # Remove hyphens, normalize spacing
+        term.to_s.strip.gsub(/[‐‑‒–—―]/, "-")
+      end
+
+      def parse_glossary_page
+        content = fetch_page_content
+        return {} unless content
+
+        extract_terms_from_html(content)
+      end
+
+      def fetch_page_content
+        uri = URI(API_ENDPOINT)
+        params = {
+          action: "parse",
+          page: GLOSSARY_PAGE,
+          format: "json",
+          prop: "text",
+          disableeditsection: 1,
+          disabletoc: 1
+        }
+        uri.query = URI.encode_www_form(params)
+
+        request = Net::HTTP::Get.new(uri)
+        request["User-Agent"] = "AutoGlossaryGem/1.0 (Educational/Research)"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: 10) do |http|
+          http.request(request)
+        end
+
+        if response.code == "200"
+          data = JSON.parse(response.body)
+          data.dig("parse", "text", "*")
+        else
+          Rails.logger.error "Wikipedia API error: #{response.code} - #{response.body}"
+          nil
+        end
+      rescue StandardError => e
+        Rails.logger.error "Error fetching Wikipedia glossary: #{e.message}"
+        nil
+      end
+
+      def extract_terms_from_html(html)
+        terms = {}
+
+        # Wikipedia glossary format: <dt>term</dt><dd>definition</dd>
+        html.scan(/<dt[^>]*>(.*?)<\/dt>\s*<dd[^>]*>(.*?)<\/dd>/m) do |term_html, def_html|
+          term = strip_html_tags(term_html).strip
+          definition = clean_definition(def_html)
+
+          terms[term] = definition unless term.empty? || definition.empty?
+        end
+
+        terms
+      end
+
+      def strip_html_tags(text)
+        text.gsub(/<\/?[^>]*>/, "")
+            .gsub(/\s+/, " ")
+            .strip
+      end
+
+      def clean_definition(html)
+        # Remove edit links, references, etc.
+        cleaned = html.gsub(/<span class="mw-editsection".*?<\/span>/m, "")
+                     .gsub(/<sup[^>]*>.*?<\/sup>/m, "")
+                     .gsub(/\[edit\]/i, "")
+
+        strip_html_tags(cleaned).strip
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+AutoGlossary::Engine.routes.draw do
+  get "definition", to: "glossary#definition", defaults: { format: :json }
+  get "", to: "glossary#index", as: :glossary
+end

data/lib/auto_glossary/engine.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module AutoGlossary
+  class Engine < ::Rails::Engine
+    isolate_namespace AutoGlossary
+
+    # Make helpers available to the host app
+    initializer "auto_glossary.helpers" do
+      ActiveSupport.on_load(:action_controller_base) do
+        helper AutoGlossary::GlossaryHelper
+      end
+      ActiveSupport.on_load(:action_view) do
+        include AutoGlossary::GlossaryHelper
+      end
+    end
+
+    # Add assets paths
+    initializer "auto_glossary.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << root.join("app/assets/stylesheets")
+        app.config.assets.precompile += %w[glossary.css]
+      end
+    end
+
+    # Add JavaScript paths for Stimulus
+    initializer "auto_glossary.stimulus" do |app|
+      # The JavaScript controller will need to be manually imported by the host app
+      # or included via importmap/npm
+    end
+  end
+end

data/lib/auto_glossary/version.rb

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

data/lib/auto_glossary.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "auto_glossary/version"
+require_relative "auto_glossary/engine" if defined?(Rails)
+
+module AutoGlossary
+  class Error < StandardError; end
+end

data/lib/generators/auto_glossary/install/install_generator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module AutoGlossary
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Installs Auto-Glossary into your Rails application"
+
+      def add_routes
+        route <<~RUBY
+          # Auto-Glossary routes
+          mount AutoGlossary::Engine => "/glossary"
+        RUBY
+      end
+
+      def copy_javascript
+        template "glossary_controller.js", "app/javascript/controllers/glossary_controller.js"
+      end
+
+      def show_usage
+        say "\n"
+        say "================================================================", :green
+        say "Auto-Glossary has been installed!", :green
+        say "================================================================", :green
+        say "\n"
+        say "Next steps:", :yellow
+        say "\n"
+        say "1. Add the stylesheet to your layout (app/views/layouts/application.html.erb):", :yellow
+        say "   <%= stylesheet_link_tag 'glossary', 'data-turbo-track': 'reload' %>", :cyan
+        say "\n"
+        say "2. Add the Stimulus controller to your <body> tag:", :yellow
+        say "   <body data-controller=\"glossary\">", :cyan
+        say "\n"
+        say "3. Use in your views:", :yellow
+        say "   <%= mark_glossary_terms(@article.body) %>", :cyan
+        say "\n"
+        say "4. Restart your Rails server", :yellow
+        say "\n"
+        say "For more info: https://github.com/mrdbidwill/auto-glossary", :blue
+        say "\n"
+      end
+    end
+  end
+end

data/lib/generators/auto_glossary/install/templates/glossary_controller.js

@@ -0,0 +1,199 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["modal", "modalContent", "tooltip"]
+  static values = {
+    url: { type: String, default: "/glossary/definition" }
+  }
+
+  connect() {
+    this.tooltipElement = null
+    this.currentTerm = null
+    this.definitionCache = new Map()
+
+    // Add event listeners to all glossary terms
+    this.attachGlossaryListeners()
+  }
+
+  disconnect() {
+    this.removeTooltip()
+  }
+
+  attachGlossaryListeners() {
+    document.querySelectorAll('.glossary-term').forEach(term => {
+      term.addEventListener('mouseenter', this.showTooltip.bind(this))
+      term.addEventListener('mouseleave', this.hideTooltip.bind(this))
+      term.addEventListener('click', this.showModal.bind(this))
+      term.addEventListener('keydown', this.handleKeydown.bind(this))
+    })
+  }
+
+  showTooltip(event) {
+    const term = event.target.dataset.term
+    if (!term) return
+
+    this.currentTerm = term
+
+    // Show loading tooltip
+    this.createTooltip(event.target, 'Loading...')
+
+    // Fetch definition
+    this.fetchDefinition(term).then(definition => {
+      if (this.currentTerm === term) {
+        this.updateTooltip(this.truncateDefinition(definition, 150))
+      }
+    })
+  }
+
+  hideTooltip(event) {
+    // Small delay to allow moving to modal
+    setTimeout(() => {
+      if (!this.modalOpen) {
+        this.removeTooltip()
+      }
+    }, 100)
+  }
+
+  createTooltip(element, content) {
+    this.removeTooltip()
+
+    this.tooltipElement = document.createElement('div')
+    this.tooltipElement.className = 'glossary-tooltip'
+    this.tooltipElement.innerHTML = content
+    document.body.appendChild(this.tooltipElement)
+
+    this.positionTooltip(element)
+  }
+
+  updateTooltip(content) {
+    if (this.tooltipElement) {
+      this.tooltipElement.innerHTML = content
+    }
+  }
+
+  removeTooltip() {
+    if (this.tooltipElement) {
+      this.tooltipElement.remove()
+      this.tooltipElement = null
+    }
+    this.currentTerm = null
+  }
+
+  positionTooltip(element) {
+    if (!this.tooltipElement) return
+
+    const rect = element.getBoundingClientRect()
+    const tooltipRect = this.tooltipElement.getBoundingClientRect()
+
+    let top = rect.bottom + window.scrollY + 5
+    let left = rect.left + window.scrollX
+
+    // Adjust if tooltip goes off screen
+    if (left + tooltipRect.width > window.innerWidth) {
+      left = window.innerWidth - tooltipRect.width - 10
+    }
+
+    if (top + tooltipRect.height > window.innerHeight + window.scrollY) {
+      top = rect.top + window.scrollY - tooltipRect.height - 5
+    }
+
+    this.tooltipElement.style.top = `${top}px`
+    this.tooltipElement.style.left = `${left}px`
+  }
+
+  showModal(event) {
+    event.preventDefault()
+    const term = event.target.dataset.term
+    if (!term) return
+
+    this.modalOpen = true
+    this.removeTooltip()
+
+    // Create modal if it doesn't exist
+    if (!this.hasModalTarget) {
+      this.createModal()
+    }
+
+    this.modalTarget.querySelector('.glossary-modal-content').innerHTML = '<p>Loading...</p>'
+    this.modalTarget.classList.add('active')
+    this.modalTarget.querySelector('.glossary-modal-title').textContent = term
+
+    this.fetchDefinition(term).then(definition => {
+      const content = this.modalTarget.querySelector('.glossary-modal-content')
+      content.innerHTML = `
+        <p>${definition}</p>
+        <p class="glossary-attribution">
+          <small>Source: <a href="https://en.wikipedia.org/wiki/Glossary_of_mycology" target="_blank" rel="noopener">Wikipedia Glossary of Mycology</a> (CC BY-SA 4.0)</small>
+        </p>
+      `
+    })
+  }
+
+  hideModal() {
+    if (this.hasModalTarget) {
+      this.modalTarget.classList.remove('active')
+    }
+    this.modalOpen = false
+  }
+
+  createModal() {
+    const modal = document.createElement('div')
+    modal.className = 'glossary-modal'
+    modal.dataset.glossaryTarget = 'modal'
+    modal.innerHTML = `
+      <div class="glossary-modal-backdrop" data-action="click->glossary#hideModal"></div>
+      <div class="glossary-modal-dialog">
+        <div class="glossary-modal-header">
+          <h3 class="glossary-modal-title"></h3>
+          <button type="button" class="glossary-modal-close" data-action="click->glossary#hideModal">&times;</button>
+        </div>
+        <div class="glossary-modal-body">
+          <div class="glossary-modal-content"></div>
+        </div>
+      </div>
+    `
+    document.body.appendChild(modal)
+  }
+
+  handleKeydown(event) {
+    if (event.key === 'Enter' || event.key === ' ') {
+      event.preventDefault()
+      this.showModal(event)
+    }
+  }
+
+  async fetchDefinition(term) {
+    // Check cache first
+    if (this.definitionCache.has(term)) {
+      return this.definitionCache.get(term)
+    }
+
+    try {
+      const response = await fetch(`${this.urlValue}?term=${encodeURIComponent(term)}`, {
+        headers: {
+          'Accept': 'application/json'
+        }
+      })
+
+      if (!response.ok) {
+        throw new Error('Failed to fetch definition')
+      }
+
+      const data = await response.json()
+      const definition = data.definition || 'Definition not found.'
+
+      // Cache the definition
+      this.definitionCache.set(term, definition)
+
+      return definition
+    } catch (error) {
+      console.error('Error fetching glossary definition:', error)
+      return 'Unable to load definition.'
+    }
+  }
+
+  truncateDefinition(text, maxLength) {
+    if (text.length <= maxLength) return text
+    return text.substring(0, maxLength) + '... <em>(click for more)</em>'
+  }
+}

data/sig/auto_glossary.rbs

@@ -0,0 +1,4 @@
+module AutoGlossary
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: auto_glossary
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Will Johnston
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Auto-Glossary provides hover tooltips and click-through definitions for
+  technical terms by fetching content from Wikipedia glossaries. Perfect for educational,
+  scientific, and technical documentation sites.
+email:
+- mrdbidwill@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/stylesheets/glossary.css
+- app/controllers/auto_glossary/glossary_controller.rb
+- app/helpers/auto_glossary/glossary_helper.rb
+- app/javascript/controllers/glossary_controller.js
+- app/services/auto_glossary/wikipedia_glossary_service.rb
+- config/routes.rb
+- lib/auto_glossary.rb
+- lib/auto_glossary/engine.rb
+- lib/auto_glossary/version.rb
+- lib/generators/auto_glossary/install/install_generator.rb
+- lib/generators/auto_glossary/install/templates/glossary_controller.js
+- sig/auto_glossary.rbs
+homepage: https://auto-glossary.com
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://auto-glossary.com
+  source_code_uri: https://github.com/mrdbidwill/auto-glossary
+  changelog_uri: https://github.com/mrdbidwill/auto-glossary/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: Automatically highlight and define technical terms from Wikipedia glossaries
+  in Rails applications
+test_files: []