ruflet 0.0.17 → 0.0.19

data/lib/ruflet/cli/extra_command.rb

@@ -6,8 +6,6 @@ module Ruflet
   module CLI
     module ExtraCommand
       include FlutterSdk
-      include EnvironmentSetup
-      include AndroidSdk
       include NewCommand
 
       def command_create(args)
@@ -18,26 +16,23 @@ module Ruflet
         verbose = args.delete("--verbose") || args.delete("-v")
         fix = args.delete("--fix")
         client_dir = detect_client_dir
-        template_root = resolve_ruflet_client_template_root
+        template_root =
+          if fix
+            ensure_cached_ruflet_client_template!(force: true, verbose: !!verbose)
+          else
+            resolve_ruflet_client_template_root
+          end
         puts "Ruflet doctor"
         puts "  Ruby: #{RUBY_VERSION}"
         puts "  Flutter host target: #{flutter_host || 'unsupported'}"
-
-        # System prerequisites first: Flutter cannot be installed (or even
-        # extracted) without them.
-        environment_issues = environment_setup!(fix: !!fix, verbose: !!verbose)
-        return 1 unless flutter_host
-
         if template_root
           puts "  Template: #{template_root}"
+          revision = cached_template_revision if respond_to?(:cached_template_revision, true)
+          puts "  Template revision: #{revision}" if revision
         elsif fix
-          template_root = ensure_cached_ruflet_client_template!(force: true, verbose: !!verbose)
-          unless template_root
-            warn "  Template: missing"
-            warn "Failed to fetch the Ruflet Flutter template from GitHub."
-            return 1
-          end
-          puts "  Template: #{template_root}"
+          warn "  Template: missing"
+          warn "Failed to fetch the Ruflet Flutter template from GitHub."
+          return 1
         else
           warn "  Template: missing"
           warn "Run `ruflet doctor --fix` to fetch the Flutter template from GitHub."
@@ -54,13 +49,9 @@ module Ruflet
           end
         end
         puts "  Flutter: #{flutter_version_summary(tools)}"
-        environment_issues += android_environment_setup!(fix: !!fix, verbose: !!verbose)
-        ok = system(android_build_env(tools[:env]), tools[:flutter], "doctor", *(verbose ? ["-v"] : []))
-        status = ok ? 0 : ($?&.exitstatus || 1)
-        if environment_issues.any?
-          warn "Unresolved environment issues: #{environment_issues.join('; ')}"
-          status = 1 if status.zero?
-        end
+        ok = system(tools[:env], tools[:flutter], "doctor", *(verbose ? ["-v"] : []))
+        status = $?.exitstatus if $?
+        status ||= ok ? 0 : 1
         status
       end
 

data/lib/ruflet/cli/flutter_sdk.rb

@@ -47,9 +47,18 @@ module Ruflet
       private
 
       def flutter_tools(client_dir: nil, auto_install: true)
-        # Prefer FVM when available so Flutter/Dart match a pinned SDK.
-        fvm_tools = flutter_tools_via_fvm(client_dir: client_dir, auto_install: auto_install)
-        return fvm_tools if fvm_tools
+        desired = desired_flutter_spec(client_dir: client_dir)
+
+        # Environment and .fvmrc versions are intentional pins. Flutter's
+        # generated .metadata revision only records which SDK created the
+        # project; it must not force every build to download that old SDK.
+        if %i[env fvmrc].include?(desired[:source])
+          fvm_tools = flutter_tools_via_fvm(client_dir: client_dir, auto_install: auto_install)
+          return fvm_tools if fvm_tools
+        else
+          system_tools = flutter_tools_via_system
+          return system_tools if system_tools
+        end
 
         managed_tools = flutter_tools_via_managed_sdk(client_dir: client_dir, auto_install: auto_install)
         return managed_tools if managed_tools
@@ -57,6 +66,13 @@ module Ruflet
         nil
       end
 
+      def flutter_tools_via_system
+        flutter = which_command("flutter")
+        return nil unless flutter
+
+        tools_from_flutter_bin(flutter)
+      end
+
       def flutter_tools_via_managed_sdk(client_dir: nil, auto_install: true)
         return nil unless auto_install
 
@@ -84,12 +100,8 @@ module Ruflet
           File.write(fvmrc_path, "{\"flutter\":\"#{version}\"}\n")
         end
 
-        # Installing a Flutter SDK through FVM downloads/extracts hundreds of
-        # megabytes. Stream FVM's output so the run does not look frozen.
-        puts "  $ fvm install #{version}"
-        system(fvm_env, fvm, "install", version.to_s, chdir: project_dir, out: $stdout, err: $stderr)
-        puts "  $ fvm use --force #{version}"
-        system(fvm_env, fvm, "use", "--force", version.to_s, chdir: project_dir, out: $stdout, err: $stderr)
+        system(fvm_env, fvm, "install", version.to_s, chdir: project_dir, out: File::NULL, err: File::NULL)
+        system(fvm_env, fvm, "use", "--force", version.to_s, chdir: project_dir, out: File::NULL, err: File::NULL)
 
         flutter = flutter_bin_path(project_dir)
         return nil unless File.executable?(flutter)
@@ -111,8 +123,7 @@ module Ruflet
         end
         return nil unless dart && File.executable?(dart)
 
-        puts "  $ dart pub global activate fvm"
-        system(dart, "pub", "global", "activate", "fvm", out: $stdout, err: $stderr)
+        system(dart, "pub", "global", "activate", "fvm", out: File::NULL, err: File::NULL)
         installed_fvm = File.join(pub_cache_bin_dir, fvm_executable_name)
         return installed_fvm if File.executable?(installed_fvm)
 
@@ -153,13 +164,10 @@ module Ruflet
         return sdk_root if File.executable?(flutter_bin)
 
         FileUtils.mkdir_p(install_root)
-        puts "  Installing Flutter #{release.fetch('version')} (#{host}) into #{install_root}"
         Dir.mktmpdir("ruflet-flutter-sdk-") do |tmpdir|
           archive_path = File.join(tmpdir, File.basename(archive))
-          download_file("#{RELEASES_BASE}/#{archive}", archive_path, label: "Flutter SDK")
-          puts "  Extracting #{File.basename(archive)} (this can take a minute)"
+          download_file("#{RELEASES_BASE}/#{archive}", archive_path)
           extract_archive(archive_path, install_root)
-          puts "  Extracted Flutter SDK"
         end
 
         return sdk_root if File.executable?(flutter_bin)
@@ -207,7 +215,12 @@ module Ruflet
         return { version: fvm, source: :fvmrc } if fvm
 
         metadata = parse_flutter_metadata(find_flutter_metadata(client_dir))
-        return metadata.merge(source: :metadata) if metadata
+        if metadata
+          return {
+            channel: metadata[:channel] || DEFAULT_FLUTTER_CHANNEL,
+            source: :metadata
+          }
+        end
 
         { channel: DEFAULT_FLUTTER_CHANNEL, version: DEFAULT_FLUTTER_CHANNEL, source: :default }
       end
@@ -297,8 +310,6 @@ module Ruflet
         return JSON.parse(response.body) if response.is_a?(Net::HTTPSuccess)
 
         nil
-      rescue OpenSSL::SSL::SSLError
-        JSON.parse(curl_get(url, headers: ["User-Agent: ruflet-cli"]))
       end
 
       def pick_release(manifest, version: nil, revision: nil, channel: nil)
@@ -330,10 +341,7 @@ module Ruflet
         if os.match?(/darwin/i)
           return machine_arch.include?("arm") ? "macos_arm64" : "macos"
         end
-        if os.match?(/linux/i)
-          # Flutter publishes Linux archives for x64 only.
-          return machine_arch.match?(/arm|aarch64/) ? nil : "linux"
-        end
+        return "linux" if os.match?(/linux/i)
         return "windows" if os.match?(/mswin|mingw|cygwin/i)
 
         nil
@@ -374,7 +382,7 @@ module Ruflet
         nil
       end
 
-      def download_file(url, destination, limit: 5, label: nil)
+      def download_file(url, destination, limit: 5)
         raise "Too many redirects while downloading #{url}" if limit <= 0
 
         uri = URI(url)
@@ -384,73 +392,15 @@ module Ruflet
           http.request(req) do |res|
             case res
             when Net::HTTPSuccess
-              name = label || File.basename(destination)
-              total = res["content-length"].to_i
-              downloaded = 0
-              marker = -1
-              File.open(destination, "wb") do |f|
-                res.read_body do |chunk|
-                  f.write(chunk)
-                  downloaded += chunk.bytesize
-                  marker = report_download_progress(name, downloaded, total, marker)
-                end
-              end
-              finish_download_progress(name, downloaded, total)
+              File.open(destination, "wb") { |f| res.read_body { |chunk| f.write(chunk) } }
               return destination
             when Net::HTTPRedirection
-              return download_file(res["location"], destination, limit: limit - 1, label: label)
+              return download_file(res["location"], destination, limit: limit - 1)
             else
               raise "Download failed (#{res.code})"
             end
           end
         end
-      rescue OpenSSL::SSL::SSLError
-        curl_download(url, destination)
-      end
-
-      # Net::HTTP gives no progress for a multi-hundred-MB SDK download, which
-      # looks like a hang. Report percentage on a TTY (rewritten in place) and
-      # at coarse steps when piped, so logs stay readable either way.
-      def report_download_progress(name, downloaded, total, marker)
-        if total.positive?
-          percent = downloaded * 100 / total
-          return marker if percent <= marker
-
-          line = "  Downloading #{name}: #{percent}% (#{human_size(downloaded)} / #{human_size(total)})"
-          if $stdout.tty?
-            $stdout.print("\r#{line}")
-          elsif (percent % 10).zero?
-            puts line
-          end
-          percent
-        else
-          step = downloaded / (5 * 1024 * 1024)
-          return marker if step <= marker
-
-          line = "  Downloading #{name}: #{human_size(downloaded)}"
-          $stdout.tty? ? $stdout.print("\r#{line}") : puts(line)
-          step
-        end
-      end
-
-      def finish_download_progress(name, downloaded, total)
-        summary = total.positive? ? "#{human_size(downloaded)} / #{human_size(total)}" : human_size(downloaded)
-        if $stdout.tty?
-          $stdout.print("\r  Downloaded #{name}: #{summary}\n")
-        else
-          puts "  Downloaded #{name}: #{summary}"
-        end
-      end
-
-      def human_size(bytes)
-        units = %w[B KB MB GB TB]
-        size = bytes.to_f
-        unit = units.shift
-        while size >= 1024 && units.any?
-          size /= 1024
-          unit = units.shift
-        end
-        format("%.1f %s", size, unit)
       end
 
       def extract_archive(archive, destination)
@@ -458,25 +408,14 @@ module Ruflet
           if windows_host?
             return system("powershell", "-NoProfile", "-Command", "Expand-Archive -Path '#{archive}' -DestinationPath '#{destination}' -Force")
           end
-
-          require_extract_tool!("unzip")
           return system("unzip", "-oq", archive, "-d", destination)
         end
 
         if archive.end_with?(".tar.xz") || archive.end_with?(".tar.gz") || archive.end_with?(".tgz")
-          require_extract_tool!("tar")
-          require_extract_tool!("xz") if archive.end_with?(".tar.xz") && !windows_host?
           return system("tar", "-xf", archive, "-C", destination)
         end
 
-        raise "Unsupported archive format: #{File.basename(archive)}"
-      end
-
-      def require_extract_tool!(name)
-        return if which_command(name)
-
-        raise "`#{name}` is required to extract the Flutter SDK but was not found. " \
-              "Run `ruflet doctor --fix` to install the missing system tools."
+        false
       end
     end
   end

data/lib/ruflet/cli/new_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "open3"
 require "tmpdir"
 require "yaml"
 
@@ -8,10 +9,10 @@ module Ruflet
   module CLI
     module NewCommand
       TEMPLATE_REPO_URL = ENV.fetch("RUFLET_TEMPLATE_REPO_URL", "https://github.com/AdamMusa/ruflet-template.git")
+      TEMPLATE_REPO_REF = ENV.fetch("RUFLET_TEMPLATE_REPO_REF", "main")
       RUNTIME_REPO_URL = ENV.fetch("RUFLET_RUNTIME_REPO_URL", "https://github.com/AdamMusa/ruflet.git")
 
       CLIENT_EXTENSION_MAP = {
-        "ads" => { package: "flet_ads", alias: "ruflet_ads" },
         "audio" => { package: "flet_audio", alias: "ruflet_audio" },
         "audio_recorder" => { package: "flet_audio_recorder", alias: "ruflet_audio_recorder" },
         "camera" => { package: "flet_camera", alias: "ruflet_camera" },
@@ -24,8 +25,8 @@ module Ruflet
         "lottie" => { package: "flet_lottie", alias: "ruflet_lottie" },
         "map" => { package: "flet_map", alias: "ruflet_map" },
         "permission_handler" => { package: "flet_permission_handler", alias: "ruflet_permission_handler" },
+        "rive" => { package: "flet_rive", alias: "ruflet_rive" },
         "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
-        "spinkit" => { package: "flet_spinkit", alias: "ruflet_spinkit" },
         "video" => { package: "flet_video", alias: "ruflet_video" },
         "webview" => { package: "flet_webview", alias: "ruflet_webview" }
       }.freeze
@@ -69,8 +70,10 @@ module Ruflet
 
         target = hidden_flutter_client_dir(root)
         FileUtils.mkdir_p(File.dirname(target))
+        FileUtils.rm_rf(target)
         FileUtils.cp_r(template_root, target)
         prune_client_template(target)
+        write_client_template_revision(target, installed_template_revision(template_root))
       end
 
       def hidden_flutter_client_dir(root = Dir.pwd)
@@ -85,20 +88,7 @@ module Ruflet
         end
 
         cached_template = cached_ruflet_client_template_root
-        if Dir.exist?(cached_template)
-          return cached_template if cached_template_current?(cached_template)
-
-          # The cache was written by a different ruflet version; stale
-          # framework Dart breaks newer asset layouts. Refresh, but never
-          # block a build on the network: fall back to the stale copy loudly.
-          refreshed = download_ruflet_template(force: true)
-          return refreshed if refreshed && Dir.exist?(refreshed)
-
-          warn "ruflet: could not refresh the Flutter client template cache; " \
-               "using a stale copy from another ruflet version at #{cached_template}. " \
-               "Delete it or run with network access to update."
-          return cached_template
-        end
+        return cached_template if Dir.exist?(cached_template)
 
         [
           File.expand_path("../../../ruflet_client", __dir__),
@@ -112,8 +102,6 @@ module Ruflet
 
       def ensure_cached_ruflet_client_template!(force: false, verbose: false)
         cached_template = cached_ruflet_client_template_root
-        return cached_template if !force && Dir.exist?(cached_template)
-
         download_ruflet_template(force: force, verbose: verbose)
         Dir.exist?(cached_template) ? cached_template : nil
       end
@@ -126,19 +114,8 @@ module Ruflet
         File.join(template_cache_root, "ruflet_flutter_template")
       end
 
-      TEMPLATE_CACHE_STAMP = ".ruflet_template_version"
-
-      def cached_template_current?(target)
-        stamp = File.join(target, TEMPLATE_CACHE_STAMP)
-        File.file?(stamp) && File.read(stamp).strip == Ruflet::VERSION
-      rescue StandardError
-        false
-      end
-
-      def write_template_cache_stamp(target)
-        File.write(File.join(target, TEMPLATE_CACHE_STAMP), Ruflet::VERSION)
-      rescue StandardError
-        nil
+      def cached_ruflet_client_template_revision_path
+        File.join(template_cache_root, "ruflet_flutter_template.revision")
       end
 
       def cached_ruby_runtime_root
@@ -154,41 +131,104 @@ module Ruflet
       end
 
       def download_ruflet_assets(force: false, verbose: false)
-        template_target = cached_ruflet_client_template_root
-        return true if !force && Dir.exist?(template_target)
-
-        Dir.exist?(template_target) || download_ruflet_template(force: force, verbose: verbose)
+        !ensure_cached_ruflet_client_template!(force: force, verbose: verbose).nil?
       end
 
       def download_ruflet_template(force: false, verbose: false)
         target = cached_ruflet_client_template_root
-        return target if !force && Dir.exist?(target)
+        remote_revision = remote_template_revision(verbose: verbose)
+        current_revision = cached_template_revision
+        cache_available = valid_ruflet_template?(target)
+        if !force && cache_available && remote_revision && current_revision == remote_revision
+          return target
+        end
+        if !force && cache_available && remote_revision.nil?
+          build_log(verbose, "Unable to check the Ruflet template revision; using cached #{current_revision || 'template'}") if respond_to?(:build_log, true)
+          return target
+        end
 
         FileUtils.mkdir_p(template_cache_root)
 
         Dir.mktmpdir("ruflet-assets") do |tmp|
           repo_dir = File.join(tmp, "Ruflet")
-          clone_cmd = ["git", "clone", "--depth", "1", "--filter=blob:none", "--sparse", TEMPLATE_REPO_URL, repo_dir]
-          return nil unless run_template_command(clone_cmd, verbose: verbose)
-          return nil unless run_template_command(["git", "-C", repo_dir, "sparse-checkout", "set", "templates/ruflet_flutter_template"], verbose: verbose)
+          clone_cmd = ["git", "clone", "--depth", "1", "--branch", TEMPLATE_REPO_REF, "--filter=blob:none", "--sparse", TEMPLATE_REPO_URL, repo_dir]
+          return target_if_present(target) unless run_template_command(clone_cmd, verbose: verbose)
+          return target_if_present(target) unless run_template_command(["git", "-C", repo_dir, "sparse-checkout", "set", "templates/ruflet_flutter_template"], verbose: verbose)
 
           source = File.join(repo_dir, "templates", "ruflet_flutter_template")
-          return nil unless Dir.exist?(source)
+          return target_if_present(target) unless valid_ruflet_template?(source)
 
+          fetched_revision = git_revision(repo_dir) || remote_revision
+          staged_target = File.join(tmp, "ruflet_flutter_template")
+          FileUtils.cp_r(source, staged_target)
           FileUtils.rm_rf(target)
-          FileUtils.cp_r(source, target)
+          FileUtils.mv(staged_target, target)
+          File.write(cached_ruflet_client_template_revision_path, "#{fetched_revision}\n") if fetched_revision
         end
 
-        write_template_cache_stamp(target)
         target
       rescue StandardError => e
         warn "Failed to fetch Ruflet template: #{e.class}: #{e.message}"
-        nil
+        target_if_present(target)
       end
 
       def run_template_command(cmd, verbose: false)
         output = verbose ? $stdout : File::NULL
-        system(*cmd, out: output, err: verbose ? $stderr : File::NULL)
+        env = { "GIT_TERMINAL_PROMPT" => "0" }
+        system(env, *cmd, out: output, err: verbose ? $stderr : File::NULL)
+      end
+
+      def remote_template_revision(verbose: false)
+        return @ruflet_template_remote_revision if defined?(@ruflet_template_remote_revision)
+
+        env = { "GIT_TERMINAL_PROMPT" => "0" }
+        stdout, stderr, status = Open3.capture3(env, "git", "ls-remote", TEMPLATE_REPO_URL, "refs/heads/#{TEMPLATE_REPO_REF}")
+        warn stderr unless status.success? || !verbose || stderr.empty?
+        @ruflet_template_remote_revision = status.success? ? stdout.split.first : nil
+      rescue StandardError => e
+        warn "Failed to check Ruflet template revision: #{e.message}" if verbose
+        @ruflet_template_remote_revision = nil
+      end
+
+      def cached_template_revision
+        return nil unless File.file?(cached_ruflet_client_template_revision_path)
+
+        File.read(cached_ruflet_client_template_revision_path).strip.then { |value| value.empty? ? nil : value }
+      end
+
+      def installed_template_revision(template_root)
+        return cached_template_revision if File.expand_path(template_root) == File.expand_path(cached_ruflet_client_template_root)
+
+        git_revision(File.expand_path("../..", template_root))
+      end
+
+      def write_client_template_revision(target, revision)
+        return unless revision
+
+        File.write(File.join(target, ".ruflet-template-revision"), "#{revision}\n")
+      end
+
+      def client_template_current?(target, template_root)
+        expected = installed_template_revision(template_root)
+        return false unless expected
+
+        marker = File.join(target, ".ruflet-template-revision")
+        File.file?(marker) && File.read(marker).strip == expected
+      end
+
+      def git_revision(repo_dir)
+        stdout, _stderr, status = Open3.capture3("git", "-C", repo_dir, "rev-parse", "HEAD")
+        status.success? ? stdout.strip : nil
+      rescue StandardError
+        nil
+      end
+
+      def valid_ruflet_template?(path)
+        Dir.exist?(path) && File.file?(File.join(path, "pubspec.yaml")) && File.file?(File.join(path, "lib", "main.dart"))
+      end
+
+      def target_if_present(target)
+        valid_ruflet_template?(target) ? target : nil
       end
 
       def prune_client_template(target)
@@ -225,10 +265,8 @@ module Ruflet
             # Example: https://api.example.com
             backend_url: ""
 
-          # Flutter extension packages included in the managed client.
-          # Permission-backed extensions such as camera, audio_recorder,
-          # geolocator, and permission_handler are activated by services.yaml
-          # and ignored here.
+          # Optional Flutter client extensions. Only listed extensions are bundled.
+          # Examples: audio, charts, code_editor, map, rive, video, webview
           extensions: []
 
           # Build assets configuration consumed by `ruflet build`.
@@ -246,7 +284,9 @@ module Ruflet
         YAML
 
         File.write(File.join(root, "services.yaml"), <<~YAML)
-          # Protected device access requested by this app.
+          # Native capabilities that require platform permissions. Ruflet activates
+          # the matching client extensions and writes Android/iOS permissions.
+          # Supported services: camera, microphone, location, motion
           services: []
         YAML
       end