ruflet 0.0.18 → 0.0.20

data/lib/ruflet/cli/extra_command.rb

@@ -16,20 +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'}"
         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."

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
 
@@ -115,7 +131,21 @@ module Ruflet
       end
 
       def fvm_env
-        { "PATH" => "#{pub_cache_bin_dir}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}" }
+        utf8_locale_env.merge("PATH" => "#{pub_cache_bin_dir}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}")
+      end
+
+      # CocoaPods aborts with "Unicode Normalization not appropriate for
+      # ASCII-8BIT" when it inherits a non-UTF-8 locale, which takes the whole
+      # iOS and macOS build with it. Hand the toolchain a UTF-8 locale unless
+      # the environment already has one.
+      def utf8_locale_env
+        return {} if utf8_locale?(ENV["LC_ALL"]) || utf8_locale?(ENV["LANG"])
+
+        { "LANG" => "en_US.UTF-8", "LC_ALL" => "en_US.UTF-8" }
+      end
+
+      def utf8_locale?(value)
+        value.to_s.match?(/utf-?8/i)
       end
 
       def tools_from_flutter_bin(flutter_bin)
@@ -127,11 +157,11 @@ module Ruflet
         {
           flutter: flutter_bin,
           dart: (File.executable?(dart) ? dart : "dart"),
-          env: {
+          env: utf8_locale_env.merge(
             "PATH" => "#{bin_dir}#{File::PATH_SEPARATOR}#{pub_cache_bin_dir}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}",
             "FLUTTER_ROOT" => sdk_root,
             "FVM_FLUTTER_SDK" => sdk_root
-          }
+          )
         }
       end
 
@@ -199,7 +229,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

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,6 +25,7 @@ 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" },
+        "qrcode_scanner" => { package: "ruflet_qrcode_scanner", alias: "ruflet_qrcode_scanner" },
         "rive" => { package: "flet_rive", alias: "ruflet_rive" },
         "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
         "video" => { package: "flet_video", alias: "ruflet_video" },
@@ -53,11 +55,11 @@ module Ruflet
         puts "Run:"
         puts "  cd #{project_name}"
         puts "  bundle install"
-        puts "  bundle exec ruflet run main.rb"
+        puts "  ruflet run main.rb"
         puts
         puts "Build:"
-        puts "  bundle exec ruflet build android --self"
-        puts "  bundle exec ruflet build ios --self"
+        puts "  ruflet build android --self"
+        puts "  ruflet build ios --self"
         0
       end
 
@@ -69,8 +71,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)
@@ -78,29 +82,29 @@ module Ruflet
       end
 
       def resolve_ruflet_client_template_root
-        [
-          File.expand_path("../../../../../templates/ruflet_flutter_template", __dir__)
-        ].each do |template|
-          return template if Dir.exist?(template)
+        explicit = ENV["RUFLET_TEMPLATE_ROOT"].to_s.strip
+        unless explicit.empty?
+          explicit_template = [
+            explicit,
+            File.join(explicit, "templates", "ruflet_flutter_template")
+          ].find { |path| valid_ruflet_template?(path) }
+          return explicit_template if explicit_template
         end
 
-        cached_template = cached_ruflet_client_template_root
-        return cached_template if Dir.exist?(cached_template)
+        sibling_template = File.expand_path(
+          "../../../../../../ruflet-template/templates/ruflet_flutter_template",
+          __dir__
+        )
+        return sibling_template if valid_ruflet_template?(sibling_template)
 
-        [
-          File.expand_path("../../../ruflet_client", __dir__),
-          File.expand_path("../../../../../ruflet_client", __dir__)
-        ].each do |fallback|
-          return fallback if Dir.exist?(fallback)
-        end
+        cached_template = cached_ruflet_client_template_root
+        return cached_template if valid_ruflet_template?(cached_template)
 
         nil
       end
 
       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
@@ -113,6 +117,10 @@ module Ruflet
         File.join(template_cache_root, "ruflet_flutter_template")
       end
 
+      def cached_ruflet_client_template_revision_path
+        File.join(template_cache_root, "ruflet_flutter_template.revision")
+      end
+
       def cached_ruby_runtime_root
         File.join(cache_root, "ruby_runtime")
       end
@@ -126,40 +134,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
 
         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)
@@ -186,12 +258,6 @@ module Ruflet
       def write_default_ruflet_config(root, app_name)
         File.write(File.join(root, "ruflet.yaml"), <<~YAML)
           app:
-            name: #{app_name}
-            display_name: #{humanize_name(app_name)}
-            package_name: #{app_name.gsub(/[^a-zA-Z0-9_]+/, "_").downcase}
-            organization: com.example
-            version: 1.0.0+1
-            description: A new Ruflet app.
             # Required for server-driven builds: `ruflet build ios`, `apk`, `web`, etc. without `--self`.
             # Example: https://api.example.com
             backend_url: ""
@@ -215,6 +281,16 @@ module Ruflet
         YAML
 
         File.write(File.join(root, "services.yaml"), <<~YAML)
+          # Application identity used by the Flutter build pipeline. Ruflet derives
+          # the mobile identifier as organization.package_name and passes it to
+          # change_app_package_name for Android and iOS builds.
+          app:
+            app_name: #{humanize_name(app_name)}
+            package_name: #{app_name.gsub(/[^a-zA-Z0-9_]+/, "_").downcase}
+            organization: com.example
+            version: 1.0.0+1
+            description: A new Ruflet app.
+
           # Native capabilities that require platform permissions. Ruflet activates
           # the matching client extensions and writes Android/iOS permissions.
           # Supported services: camera, microphone, location, motion