pindo 5.2.4 → 5.3.7

data/lib/pindo/module/android/gradle_helper.rb

@@ -1,10 +1,38 @@
 require_relative 'base_helper'
+require 'net/http'
+require 'uri'
+require 'zip'
 
 module Pindo
   module GradleHelper
     include BaseAndroidHelper
 
+    # 常量定义
+    RECOMMENDED_GRADLE_VERSION = '7.6.4'
+    MIN_GRADLE_WRAPPER_JAR_SIZE = 50_000  # 50KB
+    DOWNLOAD_TIMEOUT = 30  # 30秒
+
     def check_gradle_files(project_path)
+      puts "\e[36m=== 检查Gradle Wrapper配置 ===\e[0m"
+      
+      # 优先使用基于gradle-wrapper.properties的自动配置
+      if File.exist?(File.join(project_path, "gradle/wrapper/gradle-wrapper.properties"))
+        puts "检测到gradle-wrapper.properties文件，使用自动配置..."
+        if setup_gradle_wrapper_from_properties(project_path)
+          puts "\e[32m✓ 基于gradle-wrapper.properties的自动配置成功\e[0m"
+          return true
+        else
+          puts "\e[33m⚠ 自动配置失败，回退到传统方式\e[0m"
+        end
+      end
+
+      # 回退到传统的文件复制方式
+      puts "使用传统方式配置Gradle Wrapper..."
+      setup_gradle_wrapper_traditional(project_path)
+    end
+
+    # 传统的gradle wrapper配置方式（作为回退方案）
+    def setup_gradle_wrapper_traditional(project_path)
       # 检查是否存在 gradlew 文件 如果没有则执行复制操作
       gradlew_path = File.join(project_path, "gradlew")
       if File.exist?(gradlew_path)
@@ -46,11 +74,726 @@ module Pindo
     end
 
     def update_gradle_version(project_path)
-      # 更新gradle wrapper版本
+      # 智能更新gradle wrapper版本
       wrapper_path = File.join(project_path, "gradle/wrapper/gradle-wrapper.properties")
+      
+      unless File.exist?(wrapper_path)
+        puts "\e[33m⚠ 未找到gradle-wrapper.properties文件，跳过版本更新\e[0m"
+        return false
+      end
+
       content = File.read(wrapper_path)
-      content.gsub!("gradle-6.1.1-bin.zip", "gradle-7.2-bin.zip")
-      File.write(wrapper_path, content)
+      original_content = content.dup
+      
+      # 解析当前版本
+      current_version = parse_gradle_version(wrapper_path)
+      if current_version.nil?
+        puts "\e[33m⚠ 无法解析当前Gradle版本\e[0m"
+        return false
+      end
+
+      puts "当前Gradle版本: #{current_version}"
+      
+      # 根据当前版本智能选择目标版本
+      target_version = determine_target_gradle_version(current_version)
+      
+      if target_version == current_version
+        puts "\e[32m✓ Gradle版本已是最新，无需更新\e[0m"
+        return true
+      end
+
+      puts "更新Gradle版本: #{current_version} -> #{target_version}"
+      
+      # 更新版本
+      content.gsub!("gradle-#{current_version}-bin.zip", "gradle-#{target_version}-bin.zip")
+      content.gsub!("gradleVersion=#{current_version}", "gradleVersion=#{target_version}")
+      
+      if content != original_content
+        File.write(wrapper_path, content)
+        puts "\e[32m✓ Gradle版本更新完成\e[0m"
+        
+        # 重新配置gradle wrapper
+        setup_gradle_wrapper_from_properties(project_path)
+        return true
+      else
+        puts "\e[33m⚠ Gradle版本更新失败，未找到匹配的版本字符串\e[0m"
+        return false
+      end
+    end
+
+    # 基于gradle-wrapper.properties自动配置gradle工具
+    def setup_gradle_wrapper_from_properties(project_path)
+      wrapper_properties_path = File.join(project_path, "gradle/wrapper/gradle-wrapper.properties")
+      
+      unless File.exist?(wrapper_properties_path)
+        puts "\e[33m⚠ 未找到gradle-wrapper.properties文件: #{wrapper_properties_path}\e[0m"
+        return false
+      end
+
+      # 解析gradle-wrapper.properties文件
+      gradle_version = parse_gradle_version(wrapper_properties_path)
+      if gradle_version.nil?
+        puts "\e[31m✗ 无法解析gradle版本\e[0m"
+        return false
+      end
+
+      puts "\e[36m=== 自动配置Gradle Wrapper ===\e[0m"
+      puts "检测到Gradle版本: #{gradle_version}"
+
+      # 确保gradle wrapper目录存在
+      wrapper_dir = File.join(project_path, "gradle/wrapper")
+      FileUtils.mkdir_p(wrapper_dir)
+
+      # 下载并配置gradle-wrapper.jar
+      unless download_gradle_wrapper_jar(wrapper_dir, gradle_version)
+        puts "\e[31m✗ 下载gradle-wrapper.jar失败\e[0m"
+        return false
+      end
+
+      # 生成gradlew脚本
+      unless generate_gradlew_script(project_path)
+        puts "\e[31m✗ 生成gradlew脚本失败\e[0m"
+        return false
+      end
+
+      puts "\e[32m✓ Gradle Wrapper配置完成\e[0m"
+      true
+    end
+
+    # 检查gradle wrapper配置是否完整
+    def verify_gradle_wrapper_setup(project_path)
+      wrapper_dir = File.join(project_path, "gradle/wrapper")
+      wrapper_jar_path = File.join(wrapper_dir, "gradle-wrapper.jar")
+      gradlew_path = File.join(project_path, "gradlew")
+      properties_path = File.join(wrapper_dir, "gradle-wrapper.properties")
+
+      all_exist = File.exist?(wrapper_jar_path) && 
+                  File.exist?(gradlew_path) && 
+                  File.exist?(properties_path)
+
+      if all_exist
+        puts "\e[32m✓ Gradle Wrapper配置完整\e[0m"
+        return true
+      else
+        puts "\e[33m⚠ Gradle Wrapper配置不完整:\e[0m"
+        puts "  gradle-wrapper.jar: #{File.exist?(wrapper_jar_path) ? '✓' : '✗'}"
+        puts "  gradlew: #{File.exist?(gradlew_path) ? '✓' : '✗'}"
+        puts "  gradle-wrapper.properties: #{File.exist?(properties_path) ? '✓' : '✗'}"
+        return false
+      end
+    end
+
+    private
+
+    # 解析gradle版本
+    def parse_gradle_version(properties_path)
+      content = File.read(properties_path)
+      
+      # 匹配distributionUrl中的gradle版本
+      if content =~ /distributionUrl=.*gradle-(\d+\.\d+(?:\.\d+)?(?:-.*)?)-bin\.zip/
+        return $1
+      end
+      
+      # 匹配gradleVersion属性
+      if content =~ /gradleVersion=(\d+\.\d+(?:\.\d+)?(?:-.*)?)/
+        return $1
+      end
+      
+      nil
+    end
+
+    # 根据当前版本确定目标版本
+    def determine_target_gradle_version(current_version)
+      
+      # 版本映射表：当前版本 -> 推荐版本
+      # 对于旧版本，统一升级到推荐的稳定版本
+      version_mapping = {
+        # Gradle 6.x 系列
+        '6.1.1' => RECOMMENDED_GRADLE_VERSION,
+        '6.1' => RECOMMENDED_GRADLE_VERSION,
+        '6.0' => RECOMMENDED_GRADLE_VERSION,
+        
+        # Gradle 5.x 系列
+        '5.6' => RECOMMENDED_GRADLE_VERSION,
+        '5.5' => RECOMMENDED_GRADLE_VERSION,
+        '5.4' => RECOMMENDED_GRADLE_VERSION,
+        '5.3' => RECOMMENDED_GRADLE_VERSION,
+        '5.2' => RECOMMENDED_GRADLE_VERSION,
+        '5.1' => RECOMMENDED_GRADLE_VERSION,
+        '5.0' => RECOMMENDED_GRADLE_VERSION,
+        
+        # Gradle 4.x 系列
+        '4.10' => RECOMMENDED_GRADLE_VERSION,
+        '4.9' => RECOMMENDED_GRADLE_VERSION,
+        '4.8' => RECOMMENDED_GRADLE_VERSION,
+        '4.7' => RECOMMENDED_GRADLE_VERSION,
+        '4.6' => RECOMMENDED_GRADLE_VERSION,
+        '4.5' => RECOMMENDED_GRADLE_VERSION,
+        '4.4' => RECOMMENDED_GRADLE_VERSION,
+        '4.3' => RECOMMENDED_GRADLE_VERSION,
+        '4.2' => RECOMMENDED_GRADLE_VERSION,
+        '4.1' => RECOMMENDED_GRADLE_VERSION,
+        '4.0' => RECOMMENDED_GRADLE_VERSION,
+        
+        # Gradle 3.x 系列
+        '3.6' => RECOMMENDED_GRADLE_VERSION,
+        '3.5' => RECOMMENDED_GRADLE_VERSION,
+        '3.4' => RECOMMENDED_GRADLE_VERSION,
+        '3.3' => RECOMMENDED_GRADLE_VERSION,
+        '3.2' => RECOMMENDED_GRADLE_VERSION,
+        '3.1' => RECOMMENDED_GRADLE_VERSION,
+        '3.0' => RECOMMENDED_GRADLE_VERSION
+      }
+
+      # 精确匹配
+      if version_mapping.key?(current_version)
+        return version_mapping[current_version]
+      end
+
+      # 主版本号匹配
+      major_version = current_version.split('.').first.to_i
+      case major_version
+      when 0..6
+        return RECOMMENDED_GRADLE_VERSION  # 旧版本升级到推荐版本
+      when 7
+        return current_version             # 已经是7.x，保持当前版本
+      when 8
+        return current_version             # 已经是8.x，保持当前版本
+      else
+        return RECOMMENDED_GRADLE_VERSION  # 默认升级到推荐版本
+      end
+    end
+
+    # 生成gradle-wrapper.jar（使用gradle wrapper命令）
+    def download_gradle_wrapper_jar(wrapper_dir, gradle_version)
+      wrapper_jar_path = File.join(wrapper_dir, "gradle-wrapper.jar")
+      
+      # 如果已存在且版本匹配，跳过生成
+      if File.exist?(wrapper_jar_path) && verify_gradle_wrapper_jar(wrapper_jar_path, gradle_version)
+        puts "\e[32m✓ gradle-wrapper.jar已存在且版本匹配\e[0m"
+        return true
+      end
+
+      puts "正在生成gradle-wrapper.jar (版本: #{gradle_version})..."
+      
+      # 获取项目根目录
+      project_path = File.dirname(File.dirname(wrapper_dir))
+      
+      # 检查是否有gradlew脚本
+      gradlew_path = File.join(project_path, "gradlew")
+      
+      if File.exist?(gradlew_path)
+        puts "发现gradlew脚本，使用gradle wrapper命令生成..."
+        return generate_wrapper_with_gradlew(project_path, gradle_version)
+      else
+        puts "未发现gradlew脚本，使用gradle命令生成..."
+        return generate_wrapper_with_gradle(project_path, gradle_version)
+      end
+    end
+
+    # 使用gradlew脚本生成wrapper
+    def generate_wrapper_with_gradlew(project_path, gradle_version)
+      puts "使用gradlew脚本生成wrapper..."
+      
+      # 切换到项目目录
+      Dir.chdir(project_path) do
+        # 使用gradlew wrapper命令生成wrapper
+        cmd = "./gradlew wrapper --gradle-version #{gradle_version}"
+        puts "执行命令: #{cmd}"
+        
+        result = system(cmd)
+        if result
+          puts "\e[32m✓ gradle wrapper生成成功\e[0m"
+          return true
+        else
+          puts "\e[31m✗ gradle wrapper生成失败\e[0m"
+          return false
+        end
+      end
+    rescue => e
+      puts "\e[31m✗ gradle wrapper生成异常: #{e.message}\e[0m"
+      false
+    end
+
+    # 使用gradle命令生成wrapper
+    def generate_wrapper_with_gradle(project_path, gradle_version)
+      puts "使用gradle命令生成wrapper..."
+      
+      # 检查系统是否有gradle命令
+      unless system("which gradle > /dev/null 2>&1")
+        puts "\e[33m⚠ 系统未安装gradle，使用简化的wrapper生成方式...\e[0m"
+        return generate_wrapper_manually(project_path, gradle_version)
+      end
+      
+      # 切换到项目目录
+      Dir.chdir(project_path) do
+        # 使用gradle wrapper命令生成wrapper
+        cmd = "gradle wrapper --gradle-version #{gradle_version}"
+        puts "执行命令: #{cmd}"
+        
+        result = system(cmd)
+        if result
+          puts "\e[32m✓ gradle wrapper生成成功\e[0m"
+          return true
+        else
+          puts "\e[31m✗ gradle wrapper生成失败\e[0m"
+          return false
+        end
+      end
+    rescue => e
+      puts "\e[31m✗ gradle wrapper生成异常: #{e.message}\e[0m"
+      false
+    end
+
+    # 手动生成wrapper（不使用临时目录）
+    def generate_wrapper_manually(project_path, gradle_version)
+      puts "手动生成gradle wrapper..."
+      
+      # 确保wrapper目录存在
+      wrapper_dir = File.join(project_path, "gradle/wrapper")
+      FileUtils.mkdir_p(wrapper_dir)
+      
+      # 生成gradlew脚本
+      gradlew_path = File.join(project_path, "gradlew")
+      unless File.exist?(gradlew_path)
+        puts "生成gradlew脚本..."
+        generate_gradlew_script(project_path)
+      end
+      
+      # 生成gradle-wrapper.jar（使用预定义的jar文件）
+      wrapper_jar_path = File.join(wrapper_dir, "gradle-wrapper.jar")
+      unless File.exist?(wrapper_jar_path)
+        puts "生成gradle-wrapper.jar..."
+        # 这里可以使用一个通用的gradle-wrapper.jar文件
+        # 或者从网络下载一个标准的jar文件
+        return download_standard_wrapper_jar(wrapper_jar_path, gradle_version)
+      end
+      
+      puts "\e[32m✓ gradle wrapper手动生成成功\e[0m"
+      true
+    rescue => e
+      puts "\e[31m✗ 手动生成wrapper异常: #{e.message}\e[0m"
+      false
+    end
+
+    # 下载标准的gradle-wrapper.jar
+    def download_standard_wrapper_jar(wrapper_jar_path, gradle_version)
+      puts "下载标准的gradle-wrapper.jar..."
+      
+      # 使用gradle官方提供的wrapper jar下载URL
+      wrapper_jar_urls = [
+        "https://github.com/gradle/gradle/raw/v#{gradle_version}/gradle/wrapper/gradle-wrapper.jar",
+        "https://raw.githubusercontent.com/gradle/gradle/v#{gradle_version}/gradle/wrapper/gradle-wrapper.jar"
+      ]
+      
+      wrapper_jar_urls.each do |url|
+        puts "尝试下载: #{url}"
+        if download_with_curl(url, wrapper_jar_path)
+          if File.exist?(wrapper_jar_path) && File.size(wrapper_jar_path) > 1000
+            puts "\e[32m✓ gradle-wrapper.jar下载成功\e[0m"
+            return true
+          end
+        end
+      end
+      
+      puts "\e[31m✗ 下载gradle-wrapper.jar失败\e[0m"
+      false
+    end
+
+    # 下载gradle分发包并生成wrapper
+    def download_and_generate_wrapper(project_path, gradle_version)
+      puts "下载gradle分发包并生成wrapper..."
+      
+      begin
+        # 创建临时目录
+        temp_dir = Dir.mktmpdir("gradle_download_")
+        gradle_dir = File.join(temp_dir, "gradle-#{gradle_version}")
+        
+        # 下载gradle分发包
+        download_urls = [
+          "https://services.gradle.org/distributions/gradle-#{gradle_version}-bin.zip",
+          "https://github.com/gradle/gradle-distributions/releases/download/v#{gradle_version}/gradle-#{gradle_version}-bin.zip"
+        ]
+        
+        download_success = false
+        download_urls.each do |url|
+          puts "尝试下载: #{url}"
+          zip_path = File.join(temp_dir, "gradle-#{gradle_version}-bin.zip")
+          
+          if download_with_curl(url, zip_path)
+            # 解压gradle分发包
+            if system("cd #{temp_dir} && unzip -q gradle-#{gradle_version}-bin.zip")
+              download_success = true
+              puts "✓ gradle分发包下载并解压成功"
+              break
+            end
+          end
+        end
+        
+        unless download_success
+          puts "\e[31m✗ 下载gradle分发包失败\e[0m"
+          return false
+        end
+        
+        # 使用下载的gradle生成wrapper
+        gradle_bin = File.join(gradle_dir, "bin", "gradle")
+        if File.exist?(gradle_bin)
+          Dir.chdir(project_path) do
+            cmd = "#{gradle_bin} wrapper --gradle-version #{gradle_version}"
+            puts "执行命令: #{cmd}"
+            
+            result = system(cmd)
+            if result
+              puts "\e[32m✓ gradle wrapper生成成功\e[0m"
+              # 重要：在清理临时目录之前，确保wrapper已经生成完成
+              # 等待一下确保文件写入完成
+              sleep(1)
+              return true
+            else
+              puts "\e[31m✗ gradle wrapper生成失败\e[0m"
+              return false
+            end
+          end
+        else
+          puts "\e[31m✗ 未找到gradle可执行文件\e[0m"
+          return false
+        end
+        
+      rescue => e
+        puts "\e[31m✗ 下载并生成wrapper异常: #{e.message}\e[0m"
+        false
+      ensure
+        # 延迟清理临时目录，确保wrapper生成完成
+        if temp_dir && File.directory?(temp_dir)
+          puts "清理临时目录: #{temp_dir}"
+          FileUtils.rm_rf(temp_dir)
+        end
+      end
+    end
+
+    # 使用curl下载文件（备用方案）
+    def download_with_curl(url, file_path)
+      puts "使用curl下载: #{url}"
+      
+      # 使用curl命令下载，支持重定向和SSL
+      curl_cmd = [
+        'curl',
+        '-L',                    # 跟随重定向
+        '-s',                    # 静默模式
+        '--connect-timeout', '30',  # 连接超时
+        '--max-time', '300',     # 最大时间5分钟
+        '--retry', '3',          # 重试3次
+        '--retry-delay', '2',    # 重试延迟2秒
+        '--user-agent', 'Pindo Gradle Wrapper Helper/1.0',
+        '-o', file_path,         # 输出文件
+        url
+      ]
+      
+      if system(*curl_cmd)
+        if File.exist?(file_path) && File.size(file_path) > 0
+          puts "\e[32m✓ curl下载成功: #{File.size(file_path)} 字节\e[0m"
+          return true
+        else
+          puts "\e[31m✗ curl下载失败: 文件为空或不存在\e[0m"
+          return false
+        end
+      else
+        puts "\e[31m✗ curl下载失败: 命令执行失败\e[0m"
+        return false
+      end
+    rescue => e
+      puts "\e[31m✗ curl下载异常: #{e.message}\e[0m"
+      false
+    end
+
+    # 验证gradle-wrapper.jar文件
+    def verify_gradle_wrapper_jar(jar_path, expected_version)
+      # 检查文件是否存在且大小合理
+      File.exist?(jar_path) && File.size(jar_path) > MIN_GRADLE_WRAPPER_JAR_SIZE
+    end
+
+
+    # 从gradle分发包中提取gradle-wrapper.jar
+    def extract_gradle_wrapper_jar(zip_path, target_path)
+      puts "正在从gradle分发包中提取gradle-wrapper.jar..."
+      puts "ZIP文件: #{zip_path}"
+      puts "ZIP文件大小: #{File.size(zip_path)} 字节"
+      
+      Zip::File.open(zip_path) do |zip_file|
+        puts "ZIP文件包含 #{zip_file.count} 个文件"
+        
+        # 列出ZIP文件中的所有文件（用于调试）
+        puts "ZIP文件内容:"
+        zip_file.each_with_index do |entry, index|
+          puts "  #{index + 1}. #{entry.name}"
+          break if index >= 10  # 只显示前10个文件
+        end
+        puts "  ..." if zip_file.count > 10
+        
+        # 查找gradle-wrapper.jar
+        wrapper_entry = zip_file.find { |entry| entry.name.include?('gradle-wrapper.jar') }
+        
+        if wrapper_entry
+          puts "找到gradle-wrapper.jar: #{wrapper_entry.name}"
+          wrapper_entry.extract(target_path)
+          puts "\e[32m✓ gradle-wrapper.jar提取成功\e[0m"
+          return true
+        else
+          puts "\e[31m✗ 在gradle分发包中未找到gradle-wrapper.jar\e[0m"
+          puts "尝试查找其他可能的wrapper文件..."
+          
+          # 查找其他可能的wrapper文件
+          wrapper_entries = zip_file.select { |entry| entry.name.include?('wrapper') }
+          if wrapper_entries.any?
+            puts "找到以下wrapper相关文件:"
+            wrapper_entries.each do |entry|
+              puts "  - #{entry.name}"
+            end
+          else
+            puts "未找到任何wrapper相关文件"
+          end
+          
+          return false
+        end
+      end
+    rescue => e
+      puts "\e[31m✗ 解压gradle-wrapper.jar失败: #{e.message}\e[0m"
+      false
+    end
+
+    # 生成gradlew脚本
+    def generate_gradlew_script(project_path)
+      gradlew_path = File.join(project_path, "gradlew")
+      
+      # 如果已存在gradlew，检查是否需要更新
+      if File.exist?(gradlew_path)
+        puts "\e[32m✓ gradlew脚本已存在\e[0m"
+        return true
+      end
+
+      puts "正在生成gradlew脚本..."
+      
+      # 生成gradlew脚本内容（通用脚本，不依赖版本）
+      gradlew_content = generate_gradlew_content()
+      
+      # 写入gradlew文件
+      File.write(gradlew_path, gradlew_content)
+      
+      # 设置执行权限
+      system("chmod", "+x", gradlew_path)
+      
+      puts "\e[32m✓ gradlew脚本生成完成\e[0m"
+      true
+    end
+
+    # 生成gradlew脚本内容（通用脚本，适用于所有Gradle项目）
+    def generate_gradlew_content()
+      <<~GRADLEW
+        #!/bin/sh
+
+        #
+        # Copyright © 2015-2021 the original authors.
+        #
+        # Licensed under the Apache License, Version 2.0 (the "License");
+        # you may not use this file except in compliance with the License.
+        # You may obtain a copy of the License at
+        #
+        #      https://www.apache.org/licenses/LICENSE-2.0
+        #
+        # Unless required by applicable law or agreed to in writing, software
+        # distributed under the License is distributed on an "AS IS" BASIS,
+        # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        # See the License for the specific language governing permissions and
+        # limitations under the License.
+        #
+
+        ##############################################################################
+        #
+        #   Gradle start up script for UNIX
+        #
+        ##############################################################################
+
+        # Attempt to set APP_HOME
+
+        # Resolve links: $0 may be a link
+        app_path=$0
+
+        # Need this for daisy-chained symlinks.
+        while
+            APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+            [ -h "$app_path" ]
+        do
+            ls=$( ls -ld "$app_path" )
+            link=${ls#*' -> '}
+            case $link in             #(
+              /*)   app_path=$link ;; #(
+              *)    app_path=$APP_HOME$link ;;
+            esac
+        done
+
+        # This is normally unused
+        # shellcheck disable=SC2034
+        APP_BASE_NAME=${0##*/}
+        APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+        # Use the maximum available, or set MAX_FD != -1 to use that value.
+        MAX_FD=maximum
+
+        warn () {
+            echo "$*"
+        } >&2
+
+        die () {
+            echo
+            echo "$*"
+            echo
+            exit 1
+        } >&2
+
+        # OS specific support (must be 'true' or 'false').
+        cygwin=false
+        msys=false
+        darwin=false
+        nonstop=false
+        case "$( uname )" in                #(
+          CYGWIN* )         cygwin=true  ;; #(
+          Darwin* )         darwin=true  ;; #(
+          MSYS* | MINGW* )  msys=true    ;; #(
+          NONSTOP* )        nonstop=true ;;
+        esac
+
+        CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+        # Determine the Java command to use to start the JVM.
+        if [ -n "$JAVA_HOME" ] ; then
+            if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+                # IBM's JDK on AIX uses strange locations for the executables
+                JAVACMD=$JAVA_HOME/jre/sh/java
+            else
+                JAVACMD=$JAVA_HOME/bin/java
+            fi
+            if [ ! -x "$JAVACMD" ] ; then
+                die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+        Please set the JAVA_HOME variable in your environment to match the
+        location of your Java installation."
+            fi
+        else
+            JAVACMD=java
+            which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+        Please set the JAVA_HOME variable in your environment to match the
+        location of your Java installation."
+        fi
+
+        # Increase the maximum file descriptors if we can.
+        if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+            case $MAX_FD in #(
+              max*)
+                # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+                # shellcheck disable=SC2039,SC3045
+                MAX_FD=$( ulimit -H -n ) ||
+                    warn "Could not query maximum file descriptor limit"
+            esac
+            case $MAX_FD in  #(
+              '' | soft) :;; #(
+              *)
+                # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+                # shellcheck disable=SC2039,SC3045
+                ulimit -n "$MAX_FD" ||
+                    warn "Could not set maximum file descriptor limit to $MAX_FD"
+            esac
+        fi
+
+        # Collect all arguments for the java command, stacking in reverse order:
+        #   * args from the command line
+        #   * the main class name
+        #   * -classpath
+        #   * -D...appname settings
+        #   * --module-path (only if needed)
+        #   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+        # For Cygwin or MSYS, switch paths to Windows format before running java
+        if "$cygwin" || "$msys" ; then
+            APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+            CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+            JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+            # Now convert the arguments - kludge to limit ourselves to /bin/sh
+            for arg do
+                if
+                    case $arg in                                #(
+                      -*)   false ;;                            # don't mess with options #(
+                      /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                            [ -e "$t" ] ;;                      #(
+                      *)    false ;;
+                    esac
+                then
+                    arg=$( cygpath --path --ignore --mixed "$arg" )
+                fi
+                # Roll the args list around exactly as many times as the number of
+                # args, so each arg winds up back in the position where it started, but
+                # possibly modified.
+                #
+                # NB: a `for` loop captures its iteration list before it begins, so
+                # changing the positional parameters here affects neither the number of
+                # iterations, nor the values presented in `arg`.
+                shift                   # remove old arg
+                set -- "$@" "$arg"      # push replacement arg
+            done
+        fi
+
+
+        # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+        DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+        # Collect all arguments for the java command:
+        #   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+        #     and any embedded shellness will be escaped.
+        #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+        #     treated as '${Hostname}' itself on the command line.
+
+        set -- \\
+                "-Dorg.gradle.appname=$APP_BASE_NAME" \\
+                -classpath "$CLASSPATH" \\
+                org.gradle.wrapper.GradleWrapperMain \\
+                "$@"
+
+        # Stop when "xargs" is not available.
+        if ! command -v xargs >/dev/null 2>&1
+        then
+            die "xargs is not available"
+        fi
+
+        # Use "xargs" to parse quoted args.
+        #
+        # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+        #
+        # In Bash we could simply go:
+        #
+        #   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+        #   set -- "${ARGS[@]}" "$@"
+        #
+        # but POSIX shell has neither arrays nor command substitution, so instead we
+        # post-process each arg (as a line of input to sed) to backslash-escape any
+        # character that might be a shell metacharacter, then use eval to reverse
+        # that process (while maintaining the separation between arguments).
+        #
+        # This will of course break if any of these variables contains a newline or
+        # an unmatched quote.
+        #
+
+        eval "set -- $(
+                printf '%s\\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+                xargs -n1 |
+                sed ' s~[^-[:alnum:]+,./:=@_]~\\\\&~g; ' |
+                tr '\\n' ' '
+            )" '"$@"'
+
+        exec "$JAVACMD" "$@"
+      GRADLEW
     end
 
   end