brick-module 0.1.5 → 0.1.6

package/android/brick_modules.gradle

@@ -43,6 +43,88 @@ ext.readPackageJson = { File packageJsonFile ->
     }
 }
 
+ext.findBrickJson = { startDir ->
+    // Walk up the directory tree looking for brick.json
+    if (!startDir) {
+        return null
+    }
+    
+    try {
+        def current = new File(startDir).canonicalFile
+        def root = new File('/').canonicalFile
+        
+        while (current != root && current != null) {
+            def brickJsonFile = new File(current, 'brick.json')
+            if (brickJsonFile.exists()) {
+                return brickJsonFile
+            }
+            def parent = current.parentFile
+            if (parent == current || parent == null) break  // Reached filesystem root
+            current = parent
+        }
+    } catch (Exception e) {
+        // Failed to process directory, return null
+    }
+    
+    return null
+}
+
+ext.resolveProjectRoot = { projectRootPath, configDir ->
+    // Handle both absolute and relative paths
+    if (!projectRootPath || !configDir) {
+        return null
+    }
+    
+    try {
+        def projectRootFile = new File(projectRootPath)
+        if (projectRootFile.isAbsolute()) {
+            return projectRootFile.exists() ? projectRootFile : null
+        } else {
+            // Relative to brick.json location
+            def resolvedFile = new File(configDir, projectRootPath).canonicalFile
+            return resolvedFile.exists() ? resolvedFile : null
+        }
+    } catch (Exception e) {
+        return null
+    }
+}
+
+ext.getBrickAndroidPath = { searchRoot ->
+    // Walk up directory tree to find brick.json
+    def brickConfigFile = findBrickJson(searchRoot)
+    
+    if (brickConfigFile && brickConfigFile.exists()) {
+        try {
+            def config = new JsonSlurper().parse(brickConfigFile)
+            
+            // Get the effective project root
+            def effectiveRoot = brickConfigFile.parentFile
+            if (config.projectRoot) {
+                def resolvedRoot = resolveProjectRoot(config.projectRoot, brickConfigFile.parentFile)
+                if (resolvedRoot) {
+                    effectiveRoot = resolvedRoot
+                }
+            }
+            
+            def androidPath = config?.output?.android
+            if (androidPath && !androidPath.isEmpty()) {
+                // Handle absolute paths (though not recommended)
+                if (new File(androidPath).isAbsolute()) {
+                    println("[Brick] Warning: Using absolute path for Android output is not recommended: ${androidPath}")
+                    return androidPath
+                }
+                // Otherwise, treat as relative to effective project root
+                return new File(effectiveRoot, androidPath).canonicalPath
+            }
+        } catch (Exception e) {
+            println("[Brick] Warning: Failed to parse brick.json: ${e.message}")
+        }
+    }
+    
+    // Default: .brick directory in the Android project root
+    return new File(searchRoot, '.brick').canonicalPath
+}
+
 ext.getAllDependencies = { packageJson ->
     def deps = []
     deps.addAll(packageJson.dependencies?.keySet() ?: [])
@@ -54,6 +136,44 @@ ext.isBrickModule = { packageJson ->
     return packageJson?.brickModule != null
 }
 
+ext.findProjectRoot = { androidDir ->
+    // 1. Walk up directory tree to find brick.json
+    def brickConfigFile = findBrickJson(androidDir)
+    if (brickConfigFile) {
+        brickLog("Found brick.json at: ${brickConfigFile.canonicalPath}")
+        try {
+            def config = new JsonSlurper().parse(brickConfigFile)
+            if (config.projectRoot) {
+                def projectRoot = resolveProjectRoot(config.projectRoot, brickConfigFile.parentFile)
+                if (projectRoot) {
+                    brickLog("Using projectRoot from brick.json: ${projectRoot.canonicalPath}")
+                    return projectRoot
+                }
+            }
+            // If brick.json exists but has no projectRoot, use its directory as project root
+            return brickConfigFile.parentFile
+        } catch (Exception e) {
+            println("[Brick] Warning: Failed to parse brick.json: ${e.message}")
+        }
+    }
+    
+    // 2. Walk up to find package.json with node_modules
+    def current = androidDir
+    while (current != null && current != new File('/')) {
+        if (new File(current, 'package.json').exists() && new File(current, 'node_modules').exists()) {
+            brickLog("Found project root via package.json: ${current.canonicalPath}")
+            return current
+        }
+        def parent = current.parentFile
+        if (parent == current) break
+        current = parent
+    }
+    
+    // If no project root found, use default fallback
+    brickLog("Warning: Failed to find project root via brick.json or package.json. Using default: ${androidDir.parentFile.canonicalPath}")
+    return androidDir.parentFile
+}
+
 ext.runBrickCodegen = { workingDir ->
     def brickModuleDir = resolveModule(workingDir, "brick-module")
     if (brickModuleDir == null) {
@@ -82,7 +202,7 @@ ext.runBrickCodegen = { workingDir ->
 // =============================================================================
 
 ext.applyBrickModules = { settings ->
-    def projectRoot = settings.rootDir.parentFile
+    def projectRoot = findProjectRoot(settings.rootDir)
     def foundModules = []
     def brickModulesData = [:]
     
@@ -144,15 +264,16 @@ ext.applyBrickModules = { settings ->
         }
     }
     
-    // Check if codegen is needed
-    def brickDir = new File(settings.rootDir, ".brick")
+    // Check if codegen is needed (use configured path)
+    def androidBrickPath = getBrickAndroidPath(settings.rootDir)
+    def brickDir = new File(androidBrickPath)
     def needsCodegen = !brickDir.exists() || !new File(brickDir, "src/main/kotlin/BrickModule.kt").exists()
     
     if (needsCodegen) {
         runBrickCodegen(projectRoot)
     }
     
-    // Include generated module
+    // Include generated module (use configured path)
     if (brickDir.exists()) {
         settings.include(":brick-codegen")
         settings.project(":brick-codegen").projectDir = brickDir

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brick-module",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Better React Native native module development",
   "type": "module",
   "main": "dist/index.js",
@@ -51,7 +51,7 @@
     "brick-codegen": "./bin/brick-codegen.js"
   },
   "dependencies": {
-    "brick-codegen": "0.1.5"
+    "brick-codegen": "0.1.6"
   },
   "peerDependencies": {
     "react": ">=18.2.0",

package/podfile_helper.rb

@@ -6,8 +6,79 @@
 require 'json'
 require 'pathname'
 
+def find_brick_json(start_dir)
+  # Walk up the directory tree looking for brick.json
+  current = File.expand_path(start_dir)
+  root = File.expand_path('/')
+  
+  while current != root
+    brick_json_path = File.join(current, 'brick.json')
+    if File.exist?(brick_json_path)
+      return brick_json_path
+    end
+    parent = File.dirname(current)
+    break if parent == current  # Reached filesystem root
+    current = parent
+  end
+  
+  return nil
+end
+
+def find_project_root
+  ios_root = Pod::Config.instance.installation_root
+  
+  # 1. Walk up directory tree to find brick.json
+  brick_json_path = find_brick_json(ios_root)
+  if brick_json_path
+    Pod::UI.puts "[Brick] Found brick.json at: #{brick_json_path}"
+    begin
+      config = JSON.parse(File.read(brick_json_path))
+      if config['projectRoot']
+        project_root = resolve_project_root(config['projectRoot'], File.dirname(brick_json_path))
+        if project_root
+          Pod::UI.puts "[Brick] Using projectRoot from brick.json: #{project_root}"
+          return project_root
+        end
+      end
+      # If brick.json exists but has no projectRoot, use its directory as project root
+      return File.dirname(brick_json_path)
+    rescue => e
+      Pod::UI.warn "[Brick] Failed to parse brick.json: #{e.message}"
+    end
+  end
+  
+  # 2. Walk up to find package.json with node_modules
+  current = ios_root
+  while current != '/'
+    if File.exist?(File.join(current, 'package.json')) && File.exist?(File.join(current, 'node_modules'))
+      Pod::UI.puts "[Brick] Found project root via package.json: #{current}"
+      return current
+    end
+    parent = File.dirname(current)
+    break if parent == current
+    current = parent
+  end
+  
+  # If no project root found, use default fallback
+  default_root = File.expand_path(File.join(ios_root, '..'))
+  Pod::UI.warn "[Brick] Warning: Failed to find project root via brick.json or package.json. Using default: #{default_root}"
+  return default_root
+end
+
+def resolve_project_root(project_root_path, config_dir)
+  # Handle both absolute and relative paths
+  if Pathname.new(project_root_path).absolute?
+    return project_root_path if File.exist?(project_root_path)
+  else
+    # Relative to brick.json location
+    resolved_path = File.expand_path(File.join(config_dir, project_root_path))
+    return resolved_path if File.exist?(resolved_path)
+  end
+  return nil
+end
+
 def use_brick_modules!
-  brick_root = "#{Pod::Config.instance.installation_root}/.."
+  brick_root = find_project_root
   discovered_modules = []
   
   begin
@@ -21,9 +92,12 @@ def use_brick_modules!
       # Generate BrickModuleProvider.swift for auto-registration
       generate_brick_module_provider(brick_root, discovered_modules)
       
+      # Get iOS output path from brick.json if it exists
+      ios_brick_path = get_brick_ios_path(brick_root)
+      
       # Add generated BrickCodegen pod if it exists
-      brick_codegen_podspec_path = "#{brick_root}/ios/.brick/BrickCodegen.podspec"
-      brick_codegen_pod_path = "#{brick_root}/ios/.brick"
+      brick_codegen_podspec_path = "#{brick_root}/#{ios_brick_path}/BrickCodegen.podspec"
+      brick_codegen_pod_path = "#{brick_root}/#{ios_brick_path}"
       
       if File.exist?(brick_codegen_podspec_path)
         begin
@@ -98,11 +172,49 @@ def discover_brick_modules(project_root)
   modules
 end
 
+def get_brick_ios_path(project_root)
+  # Walk up from project_root to find brick.json
+  brick_config_path = find_brick_json(project_root)
+  
+  if brick_config_path && File.exist?(brick_config_path)
+    begin
+      config = JSON.parse(File.read(brick_config_path))
+      
+      # Get the effective project root
+      effective_root = project_root
+      if config['projectRoot']
+        resolved_root = resolve_project_root(config['projectRoot'], File.dirname(brick_config_path))
+        effective_root = resolved_root if resolved_root
+      end
+      
+      ios_path = config.dig('output', 'ios')
+      if ios_path && !ios_path.empty?
+        # Handle absolute paths (though not recommended)
+        if Pathname.new(ios_path).absolute?
+          Pod::UI.warn "[Brick] Using absolute path for iOS output is not recommended: #{ios_path}"
+          return ios_path
+        else
+          # Relative to effective project root
+          return File.join(effective_root, ios_path)
+        end
+      end
+    rescue => e
+      Pod::UI.warn "[Brick] Failed to parse brick.json: #{e.message}"
+    end
+  end
+  
+  # Return default path relative to project root
+  return File.join(project_root, 'ios/.brick')
+end
+
 def generate_brick_module_provider(project_root, modules)
   return if modules.empty?
   
-  # Create the .brick directory if it doesn't exist
-  brick_dir = File.join(project_root, 'ios', '.brick')
+  # Get iOS output path from brick.json
+  ios_brick_path = get_brick_ios_path(project_root)
+  
+  # Create the brick directory if it doesn't exist
+  brick_dir = File.join(project_root, ios_brick_path)
   FileUtils.mkdir_p(brick_dir) unless File.exist?(brick_dir)
   
   # Generate imports and module instances