ts-morph 0.1.1

data/lib/ts/morph/node_service.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ts
+  module Morph
+    # Manages the Node.js service for ts-morph operations
+    class NodeService
+      NODE_DIR = File.expand_path("./node", __dir__)
+      PACKAGE_JSON = File.join(NODE_DIR, "package.json")
+      SERVICE_SCRIPT = File.join(NODE_DIR, "service.js")
+
+      class << self
+        def available?
+          File.exist?(SERVICE_SCRIPT) && dependencies_installed?
+        end
+
+        def install_dependencies
+          ensure_node_directory
+          create_package_json unless File.exist?(PACKAGE_JSON)
+          
+          Dir.chdir(NODE_DIR) do
+            system("npm install", exception: true)
+          end
+          
+          create_service_script unless File.exist?(SERVICE_SCRIPT)
+        end
+
+        def script_path
+          SERVICE_SCRIPT
+        end
+
+        private
+
+        def dependencies_installed?
+          File.exist?(File.join(NODE_DIR, "node_modules", "ts-morph"))
+        end
+
+        def ensure_node_directory
+          FileUtils.mkdir_p(NODE_DIR)
+        end
+
+        def create_package_json
+          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, JSON.pretty_generate(package_content))
+        end
+
+        def create_service_script
+          File.write(SERVICE_SCRIPT, node_service_code)
+        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
+      end
+    end
+  end
+end

data/lib/ts/morph/transformations.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Ts
+  module Morph
+    # Helper methods for building transformations
+    module Transformations
+      class << self
+        # Add default props to a component
+        # @param component [String] Component name
+        # @param props [Hash] Default props to add
+        # @return [Hash] Transformation specification
+        def add_default_props(component, props)
+          {
+            type: "addDefaultProps",
+            component: component,
+            props: props
+          }
+        end
+
+        # Wrap components with another component
+        # @param target [String] Component to wrap
+        # @param wrapper [String] Wrapper component
+        # @return [Hash] Transformation specification
+        def wrap_components(target, wrapper)
+          {
+            type: "wrapComponents",
+            target: target,
+            wrapper: wrapper
+          }
+        end
+
+        # Rename components
+        # @param old_name [String] Current component name
+        # @param new_name [String] New component name
+        # @return [Hash] Transformation specification
+        def rename_components(old_name, new_name)
+          {
+            type: "renameComponents",
+            oldName: old_name,
+            newName: new_name
+          }
+        end
+
+        # Add imports
+        # @param imports [Array<Hash>] Import specifications
+        # @return [Hash] Transformation specification
+        def add_imports(imports)
+          {
+            type: "addImports",
+            imports: imports
+          }
+        end
+
+        # Inject styles into components
+        # @param styles [Hash] Component => style rules mapping
+        # @return [Hash] Transformation specification
+        def inject_styles(styles)
+          {
+            type: "injectStyles",
+            styles: styles
+          }
+        end
+
+        # Remove a component
+        # @param component [String] Component name to remove
+        # @return [Hash] Transformation specification
+        def remove_component(component)
+          {
+            type: "removeComponent",
+            component: component
+          }
+        end
+
+        # Extract a component
+        # @param component [String] Component name to extract
+        # @return [Hash] Transformation specification
+        def extract_component(component)
+          {
+            type: "extractComponent",
+            component: component
+          }
+        end
+
+        # Build import specification
+        # @param from [String] Module to import from
+        # @param named [Array<String>] Named imports
+        # @param default [String] Default import
+        # @return [Hash] Import specification
+        def import_spec(from:, named: nil, default: nil)
+          spec = { from: from }
+          spec[:named] = named if named
+          spec[:default] = default if default
+          spec
+        end
+      end
+    end
+  end
+end

data/lib/ts/morph/transformer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Ts
+  module Morph
+    # Main transformer class that interfaces with the Node.js service
+    class Transformer
+      def initialize
+        ensure_service_available!
+      end
+
+      def transform(code, transformations)
+        transformations_file = write_temp_file(JSON.generate(transformations), ".json")
+        begin
+          execute_node_operation("transform", code) do |input_file, output_file|
+            [input_file, output_file, transformations_file.path]
+          end
+        ensure
+          transformations_file&.close
+          transformations_file&.unlink
+        end
+      end
+
+      def parse(code)
+        result = execute_node_operation("parse", code) do |input_file, output_file|
+          [input_file, output_file]
+        end
+        JSON.parse(result)
+      end
+
+      def format(code)
+        execute_node_operation("format", code) do |input_file, output_file|
+          [input_file, output_file]
+        end
+      end
+
+      private
+
+      def ensure_service_available!
+        return if NodeService.available?
+
+        raise ServiceUnavailableError, <<~MSG
+          ts-morph Node.js service is not available.
+          Please run: Ts::Morph.install_dependencies
+        MSG
+      end
+
+      def execute_node_operation(operation, code)
+        input_file = write_temp_file(code, ".tsx")
+        output_file = create_temp_file(".tsx")
+
+        begin
+          args = yield(input_file.path, output_file.path)
+          
+          cmd = ["node", NodeService.script_path, operation] + args
+          stdout, stderr, status = Open3.capture3(*cmd)
+
+          unless status.success?
+            raise TransformationError, "#{operation} failed: #{stderr}"
+          end
+
+          File.read(output_file.path)
+        ensure
+          [input_file, output_file].each do |file|
+            file&.close
+            file&.unlink
+          end
+        end
+      end
+
+      def write_temp_file(content, extension)
+        file = Tempfile.new(["ts-morph", extension])
+        file.write(content)
+        file.flush
+        file
+      end
+
+      def create_temp_file(extension)
+        Tempfile.new(["ts-morph-output", extension])
+      end
+    end
+  end
+end

data/lib/ts/morph/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ts
+  module Morph
+    VERSION = "0.1.1"
+  end
+end

data/lib/ts/morph.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "tempfile"
+require "fileutils"
+require_relative "morph/version"
+require_relative "morph/error"
+require_relative "morph/transformer"
+require_relative "morph/node_service"
+require_relative "morph/transformations"
+
+module Ts
+  module Morph
+    class << self
+      # Transform TypeScript/TSX code with specified transformations
+      # @param code [String] The TypeScript/TSX code to transform
+      # @param transformations [Array<Hash>] Array of transformation specifications
+      # @return [String] The transformed code
+      def transform(code, transformations = [])
+        Transformer.new.transform(code, transformations)
+      end
+
+      # Parse TypeScript/TSX code into an AST
+      # @param code [String] The TypeScript/TSX code to parse
+      # @return [Hash] The AST representation
+      def parse(code)
+        Transformer.new.parse(code)
+      end
+
+      # Format TypeScript/TSX code
+      # @param code [String] The TypeScript/TSX code to format
+      # @return [String] The formatted code
+      def format(code)
+        Transformer.new.format(code)
+      end
+
+      # Check if the Node.js service is available
+      # @return [Boolean]
+      def service_available?
+        NodeService.available?
+      end
+
+      # Install the required Node.js dependencies
+      def install_dependencies
+        NodeService.install_dependencies
+      end
+    end
+  end
+end

data/sig/ts/morph.rbs

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