zed-rails-jumper 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e3cfa97946fff56ec96843f304309a74a2f28d16fb59e052d046fd92ec1975d7
+  data.tar.gz: 94ee5fa6638496adc92bf478d412c0a3b4660212af07403c929d6b8549ef19dd
+SHA512:
+  metadata.gz: 5bde8595dcb51ff98f0fb788f25c4da89f4cb4021f77fbc9c86c6b579905c2863796cba66b73fa9a72ed0f9f47f5e1b6732142fb7b4f8b8c8ac2da418ff4d609
+  data.tar.gz: 89b0a52d6154b78c8d77210f3d44e6cfc1833533f0baa9b8eb94d59c13aa8d8b2efbaae8e7f57a8fbae371a4e2d00ee24043e4b381643c8b2336c0a1ac6f15eb

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Tonksthebear
+
+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,140 @@
+# Zed Rails Jumper
+
+A CLI gem for the Zed editor that helps developers quickly jump between Rails controllers and their associated views. Inspired by [zed-test-toggle](https://github.com/MoskitoHero/zed-test-toggle).
+
+## Installation
+
+Ensure the [Zed CLI is installed](https://zed.dev/docs/getting-started?highlight=cli#cli)
+
+Install the gem:
+
+```bash
+gem install zed-rails-jumper
+```
+
+## Usage
+
+This tool is designed to be called from Zed tasks. It can jump in both directions:
+- From controller methods to associated view files
+- From view files to their corresponding controller and action
+
+**Note**: The tool automatically opens the target file in Zed using `system("zed", file_path)`.
+
+### Zed Task Configuration
+
+Add these tasks to your Zed tasks configuration:
+
+```json
+[
+  {
+    "label": "Jump to Rails View",
+    "command": "bundle exec zed-rails-jumper",
+    "args": [
+      "lookup",
+      "-p",
+      "\"$ZED_RELATIVE_FILE\"",
+      "-r",
+      "./",
+      "-l",
+      "\"$ZED_ROW\""
+    ],
+    "hide": "always",
+    "use_new_terminal": false,
+    "reveal": "never"
+  },
+  {
+    "label": "Jump to Rails Controller",
+    "command": "bundle exec zed-rails-jumper",
+    "args": ["controller", "-p", "\"$ZED_RELATIVE_FILE\"", "-r", "./"],
+    "hide": "always",
+    "use_new_terminal": false,
+    "reveal": "never"
+  }
+]
+```
+
+### Keybinding Configuration
+
+Add these keybindings to your Zed keybindings:
+
+```json
+[
+  {
+    "bindings": {
+      "cmd-shift-v": [
+        "task::Spawn",
+        {
+          "task_name": "Jump to Rails View",
+          "reevaluate_context": true
+        }
+      ],
+      "cmd-shift-c": [
+        "task::Spawn",
+        {
+          "task_name": "Jump to Rails Controller",
+          "reevaluate_context": true
+        }
+      ]
+    }
+  }
+]
+```
+
+## How it Works
+
+### Controller to View Jumping
+1. **Controller Detection**: The tool detects if you're in a Rails controller file
+2. **Method Detection**: Based on cursor position, it finds the current controller method
+3. **View Discovery**: It searches for view files in the corresponding `app/views` directory
+4. **File Opening**: Opens the first matching view file in Zed using `system("zed", file_path)`
+5. **Multiple Formats**: Supports various view formats:
+   - `.html.erb`
+   - `.erb`
+   - `.js.erb`
+   - `.json.erb`
+   - `.json.jbuilder`
+   - `.xml.builder`
+
+### View to Controller Jumping
+1. **View Detection**: The tool detects if you're in a Rails view file
+2. **Controller Mapping**: It maps the view path to the corresponding controller
+3. **Action Detection**: It extracts the action name from the view filename
+4. **Method Verification**: It checks if the action method exists in the controller
+5. **File Opening**: Opens the controller file in Zed using `system("zed", file_path)`
+
+## Examples
+
+### Controller to View
+If you're in `app/controllers/users_controller.rb` at line 5 (inside the `index` method), the tool will:
+1. Find `app/views/users/index.html.erb`
+2. Automatically open it in Zed
+
+### View to Controller
+If you're in `app/views/users/show.html.erb`, the tool will:
+1. Find `app/controllers/users_controller.rb`
+2. Automatically open it in Zed
+
+## CLI Commands
+
+### `lookup` - Find and open views for current controller method
+```bash
+zed-rails-jumper lookup -p "app/controllers/users_controller.rb" -r "/path/to/rails/app" -l 5
+```
+
+### `controller` - Find and open controller for current view
+```bash
+zed-rails-jumper controller -p "app/views/users/show.html.erb" -r "/path/to/rails/app"
+```
+
+## Development
+
+To set up the development environment:
+
+```bash
+bundle install
+bin/test
+```
+
+## License
+
+MIT License - see the [LICENSE](MIT-LICENSE) file for details.

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/exe/zed-rails-jumper

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "zed/rails/jumper/cli"
+
+Zed::Rails::Jumper::CLI.start(ARGV) 

data/lib/tasks/zed/rails/jumper_tasks.rake

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

data/lib/zed/rails/jumper/cli.rb

@@ -0,0 +1,265 @@
+require "thor"
+require "pathname"
+require "fileutils"
+
+module Zed
+  module Rails
+    module Jumper
+      class CLI < Thor
+        def self.start(*)
+          super
+        rescue Thor::InvocationError, ArgumentError, Errno::ENOENT, IOError => exc
+          warn String(exc)
+          exit(1)
+        end
+
+        def self.exit_on_failure?
+          true
+        end
+
+        desc "lookup", "Find associated Rails views for the current controller method"
+        option :path, aliases: "-p", required: true, desc: "Path to the current file"
+        option :root, aliases: "-r", required: true, desc: "Rails application root directory"
+        option :line, aliases: "-l", type: :numeric, desc: "Current line number (for cursor position)"
+        def lookup
+          current_file = options[:path]
+          rails_root = options[:root]
+          current_line = options[:line]
+          
+          view_finder = ViewFinder.new(current_file, rails_root, current_line)
+          associated_views = view_finder.find_associated_views
+          
+          if associated_views.any?
+            # Open the first view file found in Zed
+            system("zed", associated_views.first)
+          else
+            warn "No associated views found"
+            exit 1
+          end
+        end
+
+        desc "controller", "Find the controller and action for a given Rails view file"
+        option :path, aliases: "-p", required: true, desc: "Path to the current view file"
+        option :root, aliases: "-r", required: true, desc: "Rails application root directory"
+        def controller
+          view_file = options[:path]
+          rails_root = options[:root]
+
+          controller_finder = ControllerFinder.new(view_file, rails_root)
+          result = controller_finder.find_controller_and_action
+
+          if result
+            # Open the controller file in Zed
+            system("zed", result[:controller_file])
+          else
+            warn "No corresponding controller/action found"
+            exit 1
+          end
+        end
+        
+        private
+        
+        class ViewFinder
+          def initialize(current_file, rails_root, current_line = nil)
+            @current_file = Pathname.new(current_file)
+            @rails_root = Pathname.new(rails_root)
+            @current_line = current_line
+          end
+          
+          def find_associated_views
+            return [] unless controller_file?
+            
+            controller_name = extract_controller_name
+            action_name = extract_action_name
+            
+            return [] unless controller_name && action_name
+            
+            find_views_for_action(controller_name, action_name)
+          end
+          
+          private
+          
+          def controller_file?
+            @current_file.to_s.include?("controllers") && @current_file.extname == ".rb"
+          end
+          
+          def extract_controller_name
+            # Extract controller name from file path
+            # e.g., app/controllers/users_controller.rb -> users
+            # e.g., app/controllers/users/archives_controller.rb -> users/archives
+            relative_path = @current_file.relative_path_from(@rails_root.join("app", "controllers"))
+            return nil unless relative_path.to_s.end_with?("_controller.rb")
+            
+            relative_path.to_s.sub("_controller.rb", "")
+          end
+          
+          def extract_action_name
+            return "index" unless @current_line && @current_file.exist?
+            
+            # Read the file and find the method at the current line
+            lines = @current_file.readlines
+            current_line_content = lines[@current_line - 1] if @current_line <= lines.length
+            
+            # Look for method definitions around the current line
+            method_name = find_method_at_line(lines, @current_line)
+            
+            method_name || "index"
+          end
+          
+          def find_method_at_line(lines, target_line)
+            # Find the method definition that contains the target line
+            current_method = nil
+            
+            lines.each_with_index do |line, line_num|
+              line_index = line_num + 1
+              
+              # Check if this line is a method definition
+              match = line.strip.match(/^\s*def\s+(\w+)/)
+              if match
+                current_method = match[1]
+              end
+              
+              # If we've reached the target line, return the current method
+              if line_index == target_line
+                return current_method
+              end
+            end
+            
+            nil
+          end
+          
+          def find_views_for_action(controller_name, action_name)
+            view_files = []
+            
+            # First, try the current controller's view directory
+            views_dir = @rails_root.join("app", "views", controller_name)
+            view_files.concat(find_view_files_in_directory(views_dir, action_name)) if views_dir.exist?
+            
+            # If no views found, check inherited controllers
+            if view_files.empty?
+              inherited_controllers = find_inherited_controllers(controller_name)
+              inherited_controllers.each do |inherited_controller|
+                inherited_views_dir = @rails_root.join("app", "views", inherited_controller)
+                view_files.concat(find_view_files_in_directory(inherited_views_dir, action_name)) if inherited_views_dir.exist?
+              end
+            end
+            
+            view_files
+          end
+          
+          def find_view_files_in_directory(views_dir, action_name)
+            view_files = []
+            
+            # Check for .erb files
+            erb_file = views_dir.join("#{action_name}.erb")
+            view_files << erb_file.to_s if erb_file.exist?
+            
+            # Check for .html.erb files
+            html_erb_file = views_dir.join("#{action_name}.html.erb")
+            view_files << html_erb_file.to_s if html_erb_file.exist?
+            
+            # Check for .js.erb files
+            js_erb_file = views_dir.join("#{action_name}.js.erb")
+            view_files << js_erb_file.to_s if js_erb_file.exist?
+            
+            # Check for .json.jbuilder files
+            jbuilder_file = views_dir.join("#{action_name}.json.jbuilder")
+            view_files << jbuilder_file.to_s if jbuilder_file.exist?
+            
+            # Check for .json.erb files
+            json_erb_file = views_dir.join("#{action_name}.json.erb")
+            view_files << json_erb_file.to_s if json_erb_file.exist?
+            
+            # Check for .xml.builder files
+            xml_builder_file = views_dir.join("#{action_name}.xml.builder")
+            view_files << xml_builder_file.to_s if xml_builder_file.exist?
+            
+            view_files
+          end
+          
+          def find_inherited_controllers(controller_name)
+            inherited_controllers = []
+            
+            # Read the controller file to find inheritance
+            controller_file = @rails_root.join("app", "controllers", "#{controller_name}_controller.rb")
+            return inherited_controllers unless controller_file.exist?
+            
+            lines = controller_file.readlines
+            lines.each do |line|
+              # Look for class definition with inheritance
+              # e.g., class Users::ArchivesController < UsersController
+              # e.g., class Admin::UsersController < ApplicationController
+              if line.strip.match(/class\s+([A-Z][A-Za-z0-9:]*Controller)\s*<\s*([A-Z][A-Za-z0-9:]*Controller)/)
+                parent_controller = $2
+                # Convert class name to path (e.g., UsersController -> users)
+                parent_path = convert_class_name_to_path(parent_controller)
+                inherited_controllers << parent_path if parent_path
+              end
+            end
+            
+            inherited_controllers
+          end
+          
+          def convert_class_name_to_path(class_name)
+            return nil if class_name == "ApplicationController"
+            # Remove "Controller" suffix
+            path = class_name.sub(/Controller$/, "")
+            # Replace :: with /
+            path = path.gsub(/::/, "/")
+            # Convert CamelCase to snake_case for each segment
+            path = path.split("/").map { |seg| seg.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase }.join("/")
+            path
+          end
+        end
+
+        class ControllerFinder
+          def initialize(view_file, rails_root)
+            @view_file = Pathname.new(view_file)
+            @rails_root = Pathname.new(rails_root)
+          end
+
+          def find_controller_and_action
+            # Extract the path relative to app/views
+            # e.g., app/views/users/archives/show.html.erb -> users/archives/show
+            relative_path = @view_file.relative_path_from(@rails_root.join("app", "views"))
+            return nil unless relative_path.to_s.match?(/\.(erb|jbuilder|builder)$/)
+            
+            # Remove all possible Rails view extensions
+            path_without_ext = relative_path.to_s.sub(/\.(html|json|js|xml)?\.(erb|jbuilder|builder)$/, '').sub(/\.(erb|jbuilder|builder)$/, '')
+            path_parts = path_without_ext.split('/')
+            
+            return nil if path_parts.empty?
+            
+            # The last part is the action name
+            action_name = path_parts.pop
+            # The remaining parts form the controller path
+            controller_parts = path_parts
+            
+            return nil if controller_parts.empty?
+            
+            # Build the controller file path
+            # e.g., users/archives -> app/controllers/users/archives_controller.rb
+            controller_path = controller_parts.join('/')
+            controller_file = @rails_root.join("app", "controllers", "#{controller_path}_controller.rb")
+            
+            return nil unless controller_file.exist?
+
+            # Optionally, check if the method exists in the controller
+            if method_defined_in_controller?(controller_file, action_name)
+              { controller_file: controller_file.to_s, action_name: action_name }
+            else
+              { controller_file: controller_file.to_s, action_name: action_name, warning: "Method not found in controller" }
+            end
+          end
+
+          private
+
+          def method_defined_in_controller?(controller_file, action_name)
+            lines = controller_file.readlines
+            lines.any? { |line| line.strip.match(/^def\s+#{action_name}\b/) }
+          end
+        end
+      end
+    end
+  end
+end 

data/lib/zed/rails/jumper/railtie.rb

@@ -0,0 +1,8 @@
+module Zed
+  module Rails
+    module Jumper
+      class Railtie < ::Rails::Railtie
+      end
+    end
+  end
+end

data/lib/zed/rails/jumper/version.rb

@@ -0,0 +1,7 @@
+module Zed
+  module Rails
+    module Jumper
+      VERSION = "0.1.3"
+    end
+  end
+end

data/lib/zed/rails/jumper.rb

@@ -0,0 +1,11 @@
+require "zed/rails/jumper/version"
+require "zed/rails/jumper/railtie"
+require "zed/rails/jumper/cli"
+
+module Zed
+  module Rails
+    module Jumper
+      # Your code goes here...
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: zed-rails-jumper
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Tonksthebear
+bindir: exe
+cert_chain: []
+date: 2025-06-30 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.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A CLI gem for the Zed editor that helps developers quickly jump to Rails
+  views associated with the current controller method.
+executables:
+- zed-rails-jumper
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- exe/zed-rails-jumper
+- lib/tasks/zed/rails/jumper_tasks.rake
+- lib/zed/rails/jumper.rb
+- lib/zed/rails/jumper/cli.rb
+- lib/zed/rails/jumper/railtie.rb
+- lib/zed/rails/jumper/version.rb
+homepage: https://github.com/tonksthebear/zed-rails-jumper
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/tonksthebear/zed-rails-jumper
+  source_code_uri: https://github.com/tonksthebear/zed-rails-jumper
+  changelog_uri: https://github.com/tonksthebear/zed-rails-jumper/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A CLI gem for the Zed editor that helps developers quickly jump to Rails
+  views associated with the current controller method.
+test_files: []