ts-morph 0.1.1

data/ext/ts_morph/extconf.rb

@@ -0,0 +1,649 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'mkmf'
+require 'json'
+
+# Define Node service code generator first
+def node_service_code
+  <<~JAVASCRIPT
+    const { Project, SyntaxKind } = require("ts-morph");
+    const fs = require("fs");
+
+    class TsMorphService {
+      constructor() {
+        this.project = new Project({
+          useInMemoryFileSystem: true,
+          compilerOptions: {
+            jsx: "react",
+            target: "ES2020",
+            module: "ESNext"
+          }
+        });
+      }
+
+      transform(code, transformations) {
+        const sourceFile = this.project.createSourceFile("temp.tsx", code, { overwrite: true });
+        
+        transformations.forEach(transform => {
+          switch (transform.type) {
+            case 'addDefaultProps':
+              this.addDefaultProps(sourceFile, transform.component, transform.props);
+              break;
+            case 'wrapComponents':
+              this.wrapComponents(sourceFile, transform.target, transform.wrapper);
+              break;
+            case 'renameComponents':
+              this.renameComponents(sourceFile, transform.oldName, transform.newName);
+              break;
+            case 'addImports':
+              this.addImports(sourceFile, transform.imports);
+              break;
+            case 'injectStyles':
+              this.injectStyles(sourceFile, transform.styles);
+              break;
+            case 'removeComponent':
+              this.removeComponent(sourceFile, transform.component);
+              break;
+            case 'extractComponent':
+              this.extractComponent(sourceFile, transform.component);
+              break;
+          }
+        });
+
+        return sourceFile.getFullText();
+      }
+
+      addDefaultProps(sourceFile, componentName, defaultProps) {
+        // Add props to JSX elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+          const openingElement = element.getOpeningElement();
+          if (openingElement.getTagNameNode().getText() === componentName) {
+            Object.entries(defaultProps).forEach(([propName, propValue]) => {
+              const existingProp = openingElement.getAttribute(propName);
+              if (!existingProp) {
+                openingElement.addAttribute({
+                  name: propName,
+                  initializer: typeof propValue === 'string' ? `"${propValue}"` : `{${JSON.stringify(propValue)}}`
+                });
+              }
+            });
+          }
+        });
+
+        // Add props to self-closing elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+          if (element.getTagNameNode().getText() === componentName) {
+            Object.entries(defaultProps).forEach(([propName, propValue]) => {
+              const existingProp = element.getAttribute(propName);
+              if (!existingProp) {
+                element.addAttribute({
+                  name: propName,
+                  initializer: typeof propValue === 'string' ? `"${propValue}"` : `{${JSON.stringify(propValue)}}`
+                });
+              }
+            });
+          }
+        });
+      }
+
+      wrapComponents(sourceFile, targetComponent, wrapperComponent) {
+        const jsxElements = sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement)
+          .filter(el => el.getOpeningElement().getTagNameNode().getText() === targetComponent);
+
+        jsxElements.forEach(element => {
+          const elementText = element.getFullText();
+          const wrappedCode = `<${wrapperComponent}>${elementText}</${wrapperComponent}>`;
+          element.replaceWithText(wrappedCode);
+        });
+      }
+
+      renameComponents(sourceFile, oldName, newName) {
+        // Rename JSX elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+          const openingElement = element.getOpeningElement();
+          const closingElement = element.getClosingElement();
+          
+          if (openingElement.getTagNameNode().getText() === oldName) {
+            openingElement.getTagNameNode().replaceWithText(newName);
+            if (closingElement) {
+              closingElement.getTagNameNode().replaceWithText(newName);
+            }
+          }
+        });
+
+        // Rename self-closing elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+          if (element.getTagNameNode().getText() === oldName) {
+            element.getTagNameNode().replaceWithText(newName);
+          }
+        });
+
+        // Rename imports
+        sourceFile.getImportDeclarations().forEach(importDecl => {
+          importDecl.getNamedImports().forEach(namedImport => {
+            if (namedImport.getName() === oldName) {
+              namedImport.renameAlias(newName);
+            }
+          });
+        });
+      }
+
+      addImports(sourceFile, imports) {
+        imports.forEach(imp => {
+          const existingImport = sourceFile.getImportDeclaration(
+            decl => decl.getModuleSpecifierValue() === imp.from
+          );
+
+          if (existingImport) {
+            imp.named?.forEach(name => {
+              existingImport.addNamedImport(name);
+            });
+          } else {
+            sourceFile.addImportDeclaration({
+              moduleSpecifier: imp.from,
+              namedImports: imp.named,
+              defaultImport: imp.default
+            });
+          }
+        });
+      }
+
+      injectStyles(sourceFile, styles) {
+        Object.entries(styles).forEach(([componentName, styleRules]) => {
+          // Handle JSX elements
+          sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+            const openingElement = element.getOpeningElement();
+            if (openingElement.getTagNameNode().getText() === componentName) {
+              const styleAttr = openingElement.getAttribute("style");
+              if (styleAttr) {
+                const existingValue = styleAttr.getInitializer()?.getText() || "{}";
+                const mergedStyles = `{...${existingValue.slice(1, -1)}, ...${JSON.stringify(styleRules)}}`;
+                styleAttr.setInitializer(mergedStyles);
+              } else {
+                openingElement.addAttribute({
+                  name: "style",
+                  initializer: `{${JSON.stringify(styleRules)}}`
+                });
+              }
+            }
+          });
+
+          // Handle self-closing elements
+          sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+            if (element.getTagNameNode().getText() === componentName) {
+              const styleAttr = element.getAttribute("style");
+              if (styleAttr) {
+                const existingValue = styleAttr.getInitializer()?.getText() || "{}";
+                const mergedStyles = `{...${existingValue.slice(1, -1)}, ...${JSON.stringify(styleRules)}}`;
+                styleAttr.setInitializer(mergedStyles);
+              } else {
+                element.addAttribute({
+                  name: "style",
+                  initializer: `{${JSON.stringify(styleRules)}}`
+                });
+              }
+            }
+          });
+        });
+      }
+
+      removeComponent(sourceFile, componentName) {
+        // Remove JSX elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+          if (element.getOpeningElement().getTagNameNode().getText() === componentName) {
+            element.remove();
+          }
+        });
+
+        // Remove self-closing elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+          if (element.getTagNameNode().getText() === componentName) {
+            element.remove();
+          }
+        });
+      }
+
+      extractComponent(sourceFile, componentName) {
+        const components = [];
+        
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+          if (element.getOpeningElement().getTagNameNode().getText() === componentName) {
+            components.push(element.getFullText());
+          }
+        });
+
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+          if (element.getTagNameNode().getText() === componentName) {
+            components.push(element.getFullText());
+          }
+        });
+
+        return components;
+      }
+
+      parse(code) {
+        const sourceFile = this.project.createSourceFile("temp.tsx", code, { overwrite: true });
+        return this.buildAst(sourceFile);
+      }
+
+      buildAst(node) {
+        const ast = {
+          kind: SyntaxKind[node.getKind()],
+          text: node.getText(),
+          children: []
+        };
+
+        node.getChildren().forEach(child => {
+          ast.children.push(this.buildAst(child));
+        });
+
+        return ast;
+      }
+
+      format(code) {
+        const sourceFile = this.project.createSourceFile("temp.tsx", code, { overwrite: true });
+        sourceFile.formatText();
+        return sourceFile.getFullText();
+      }
+    }
+
+    // Main execution
+    if (require.main === module) {
+      const args = process.argv.slice(2);
+      const operation = args[0];
+      const inputFile = args[1];
+      const outputFile = args[2];
+
+      const service = new TsMorphService();
+      const code = fs.readFileSync(inputFile, 'utf8');
+
+      try {
+        let result;
+        
+        switch (operation) {
+          case 'transform':
+            const transformationsFile = args[3];
+            const transformations = JSON.parse(fs.readFileSync(transformationsFile, 'utf8'));
+            result = service.transform(code, transformations);
+            break;
+          case 'parse':
+            result = JSON.stringify(service.parse(code), null, 2);
+            break;
+          case 'format':
+            result = service.format(code);
+            break;
+          default:
+            throw new Error(`Unknown operation: ${operation}`);
+        }
+
+        fs.writeFileSync(outputFile, result);
+        console.log("Success");
+      } catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+      }
+    }
+
+    module.exports = TsMorphService;
+  JAVASCRIPT
+end
+
+# This runs during gem installation
+
+def install_node_dependencies
+  puts "Installing Node.js dependencies for ts-morph..."
+  
+  # Get the gem root directory
+  # Install into the gem's lib/ts/morph/node directory so it's packaged with the gem
+  # Write to the same directory used by Ts::Morph::NodeService::NODE_DIR
+  node_dir = File.expand_path('../../lib/ts/morph/node', __dir__)
+  
+  # Create node directory
+  FileUtils.mkdir_p(node_dir)
+  
+  # Create package.json
+  package_json_path = File.join(node_dir, 'package.json')
+  unless File.exist?(package_json_path)
+    package_content = {
+      name: "ts-morph-ruby-service",
+      version: "1.0.0",
+      private: true,
+      dependencies: {
+        "ts-morph": "^23.0.0",
+        "@babel/parser": "^7.24.0",
+        "@babel/traverse": "^7.24.0",
+        "@babel/generator": "^7.24.0",
+        "@babel/types": "^7.24.0",
+        "typescript": "^5.0.0"
+      }
+    }
+    
+    File.write(package_json_path, JSON.pretty_generate(package_content))
+  end
+  
+  # Install npm dependencies
+  Dir.chdir(node_dir) do
+    unless system("npm install")
+      puts "WARNING: Failed to install Node.js dependencies. You may need to run 'npm install' manually in #{node_dir}"
+    end
+  end
+  
+  # Create the service.js file
+  service_script_path = File.join(node_dir, 'service.js')
+  unless File.exist?(service_script_path)
+    File.write(service_script_path, node_service_code)
+  end
+  
+  puts "Node.js dependencies installed successfully!"
+rescue => e
+  puts "WARNING: Error installing Node.js dependencies: #{e.message}"
+  puts "You may need to install them manually by running: Ts::Morph.install_dependencies"
+end
+
+# Check if Node.js and npm are available
+if system("which node > /dev/null 2>&1") && system("which npm > /dev/null 2>&1")
+  install_node_dependencies
+else
+  puts "WARNING: Node.js and npm are required but not found in PATH"
+  puts "Please install Node.js and npm, then run: Ts::Morph.install_dependencies"
+end
+
+def node_service_code
+  <<~JAVASCRIPT
+    const { Project, SyntaxKind } = require("ts-morph");
+    const fs = require("fs");
+
+    class TsMorphService {
+      constructor() {
+        this.project = new Project({
+          useInMemoryFileSystem: true,
+          compilerOptions: {
+            jsx: "react",
+            target: "ES2020",
+            module: "ESNext"
+          }
+        });
+      }
+
+      transform(code, transformations) {
+        const sourceFile = this.project.createSourceFile("temp.tsx", code, { overwrite: true });
+        
+        transformations.forEach(transform => {
+          switch (transform.type) {
+            case 'addDefaultProps':
+              this.addDefaultProps(sourceFile, transform.component, transform.props);
+              break;
+            case 'wrapComponents':
+              this.wrapComponents(sourceFile, transform.target, transform.wrapper);
+              break;
+            case 'renameComponents':
+              this.renameComponents(sourceFile, transform.oldName, transform.newName);
+              break;
+            case 'addImports':
+              this.addImports(sourceFile, transform.imports);
+              break;
+            case 'injectStyles':
+              this.injectStyles(sourceFile, transform.styles);
+              break;
+            case 'removeComponent':
+              this.removeComponent(sourceFile, transform.component);
+              break;
+            case 'extractComponent':
+              this.extractComponent(sourceFile, transform.component);
+              break;
+          }
+        });
+
+        return sourceFile.getFullText();
+      }
+
+      addDefaultProps(sourceFile, componentName, defaultProps) {
+        // Add props to JSX elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+          const openingElement = element.getOpeningElement();
+          if (openingElement.getTagNameNode().getText() === componentName) {
+            Object.entries(defaultProps).forEach(([propName, propValue]) => {
+              const existingProp = openingElement.getAttribute(propName);
+              if (!existingProp) {
+                openingElement.addAttribute({
+                  name: propName,
+                  initializer: typeof propValue === 'string' ? `"${propValue}"` : `{${JSON.stringify(propValue)}}`
+                });
+              }
+            });
+          }
+        });
+
+        // Add props to self-closing elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+          if (element.getTagNameNode().getText() === componentName) {
+            Object.entries(defaultProps).forEach(([propName, propValue]) => {
+              const existingProp = element.getAttribute(propName);
+              if (!existingProp) {
+                element.addAttribute({
+                  name: propName,
+                  initializer: typeof propValue === 'string' ? `"${propValue}"` : `{${JSON.stringify(propValue)}}`
+                });
+              }
+            });
+          }
+        });
+      }
+
+      wrapComponents(sourceFile, targetComponent, wrapperComponent) {
+        const jsxElements = sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement)
+          .filter(el => el.getOpeningElement().getTagNameNode().getText() === targetComponent);
+
+        jsxElements.forEach(element => {
+          const elementText = element.getFullText();
+          const wrappedCode = `<${wrapperComponent}>${elementText}</${wrapperComponent}>`;
+          element.replaceWithText(wrappedCode);
+        });
+      }
+
+      renameComponents(sourceFile, oldName, newName) {
+        // Rename JSX elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+          const openingElement = element.getOpeningElement();
+          const closingElement = element.getClosingElement();
+          
+          if (openingElement.getTagNameNode().getText() === oldName) {
+            openingElement.getTagNameNode().replaceWithText(newName);
+            if (closingElement) {
+              closingElement.getTagNameNode().replaceWithText(newName);
+            }
+          }
+        });
+
+        // Rename self-closing elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+          if (element.getTagNameNode().getText() === oldName) {
+            element.getTagNameNode().replaceWithText(newName);
+          }
+        });
+
+        // Rename imports
+        sourceFile.getImportDeclarations().forEach(importDecl => {
+          importDecl.getNamedImports().forEach(namedImport => {
+            if (namedImport.getName() === oldName) {
+              namedImport.renameAlias(newName);
+            }
+          });
+        });
+      }
+
+      addImports(sourceFile, imports) {
+        imports.forEach(imp => {
+          const existingImport = sourceFile.getImportDeclaration(
+            decl => decl.getModuleSpecifierValue() === imp.from
+          );
+
+          if (existingImport) {
+            imp.named?.forEach(name => {
+              existingImport.addNamedImport(name);
+            });
+          } else {
+            sourceFile.addImportDeclaration({
+              moduleSpecifier: imp.from,
+              namedImports: imp.named,
+              defaultImport: imp.default
+            });
+          }
+        });
+      }
+
+      injectStyles(sourceFile, styles) {
+        Object.entries(styles).forEach(([componentName, styleRules]) => {
+          // Handle JSX elements
+          sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+            const openingElement = element.getOpeningElement();
+            if (openingElement.getTagNameNode().getText() === componentName) {
+              const styleAttr = openingElement.getAttribute("style");
+              if (styleAttr) {
+                const existingValue = styleAttr.getInitializer()?.getText() || "{}";
+                const mergedStyles = `{...${existingValue.slice(1, -1)}, ...${JSON.stringify(styleRules)}}`;
+                styleAttr.setInitializer(mergedStyles);
+              } else {
+                openingElement.addAttribute({
+                  name: "style",
+                  initializer: `{${JSON.stringify(styleRules)}}`
+                });
+              }
+            }
+          });
+
+          // Handle self-closing elements
+          sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+            if (element.getTagNameNode().getText() === componentName) {
+              const styleAttr = element.getAttribute("style");
+              if (styleAttr) {
+                const existingValue = styleAttr.getInitializer()?.getText() || "{}";
+                const mergedStyles = `{...${existingValue.slice(1, -1)}, ...${JSON.stringify(styleRules)}}`;
+                styleAttr.setInitializer(mergedStyles);
+              } else {
+                element.addAttribute({
+                  name: "style",
+                  initializer: `{${JSON.stringify(styleRules)}}`
+                });
+              }
+            }
+          });
+        });
+      }
+
+      removeComponent(sourceFile, componentName) {
+        // Remove JSX elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+          if (element.getOpeningElement().getTagNameNode().getText() === componentName) {
+            element.remove();
+          }
+        });
+
+        // Remove self-closing elements
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+          if (element.getTagNameNode().getText() === componentName) {
+            element.remove();
+          }
+        });
+      }
+
+      extractComponent(sourceFile, componentName) {
+        const components = [];
+        
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach(element => {
+          if (element.getOpeningElement().getTagNameNode().getText() === componentName) {
+            components.push(element.getFullText());
+          }
+        });
+
+        sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach(element => {
+          if (element.getTagNameNode().getText() === componentName) {
+            components.push(element.getFullText());
+          }
+        });
+
+        return components;
+      }
+
+      parse(code) {
+        const sourceFile = this.project.createSourceFile("temp.tsx", code, { overwrite: true });
+        return this.buildAst(sourceFile);
+      }
+
+      buildAst(node) {
+        const ast = {
+          kind: SyntaxKind[node.getKind()],
+          text: node.getText(),
+          children: []
+        };
+
+        node.getChildren().forEach(child => {
+          ast.children.push(this.buildAst(child));
+        });
+
+        return ast;
+      }
+
+      format(code) {
+        const sourceFile = this.project.createSourceFile("temp.tsx", code, { overwrite: true });
+        sourceFile.formatText();
+        return sourceFile.getFullText();
+      }
+    }
+
+    // Main execution
+    if (require.main === module) {
+      const args = process.argv.slice(2);
+      const operation = args[0];
+      const inputFile = args[1];
+      const outputFile = args[2];
+
+      const service = new TsMorphService();
+      const code = fs.readFileSync(inputFile, 'utf8');
+
+      try {
+        let result;
+        
+        switch (operation) {
+          case 'transform':
+            const transformationsFile = args[3];
+            const transformations = JSON.parse(fs.readFileSync(transformationsFile, 'utf8'));
+            result = service.transform(code, transformations);
+            break;
+          case 'parse':
+            result = JSON.stringify(service.parse(code), null, 2);
+            break;
+          case 'format':
+            result = service.format(code);
+            break;
+          default:
+            throw new Error(`Unknown operation: ${operation}`);
+        }
+
+        fs.writeFileSync(outputFile, result);
+        console.log("Success");
+      } catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+      }
+    }
+
+    module.exports = TsMorphService;
+  JAVASCRIPT
+end
+
+# Create a dummy Makefile to satisfy the extension build process
+File.write("Makefile", <<~MAKEFILE)
+  # Dummy Makefile for ts-morph gem
+  .PHONY: all install clean
+  
+  all:
+  
+  install:
+  
+  clean:
+MAKEFILE
+
+exit 0

data/lib/ts/morph/error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ts
+  module Morph
+    # Base error class for ts-morph operations
+    class Error < StandardError; end
+
+    # Raised when transformation fails
+    class TransformationError < Error; end
+
+    # Raised when Node.js service is not available
+    class ServiceUnavailableError < Error; end
+
+    # Raised when parsing fails
+    class ParseError < Error; end
+  end
+end