ann-flavor-flutter 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab09bf5aa8c6c9049419123f6ff1beb4f2a08cc4c25984f4f1e94efe4712da0b
+  data.tar.gz: e6bd5b196b3716ef79440ad2977287dff9278702747b7d1483fe96126b839d99
+SHA512:
+  metadata.gz: 7e754735605d623ba6bbb0d3f7bed2742f1d6fff56a912057064e484a78feac8f2eaedc2e5e487633dc6aa336ac48a969f1e76de1fa4802e1141da2839202aa0
+  data.tar.gz: fa535b179dd36c5e9af712ac58884f3325b40947cdd392f07c9aed6f9a7fc53f391f34065fb0ef3f134ab56ff04449a4235fb9656300acfde1dabcb499387e86

data/.gitignore

@@ -0,0 +1 @@
+/pkg/

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,274 @@
+# ANN Flutter Flavor — Fastlane Plugin
+
+[![RubyGems](https://img.shields.io/gem/v/ann-flavor-flutter)](https://rubygems.org/gems/ann-flavor-flutter)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Fastlane plugin that reads `annspec.yaml` and provides lanes for building, signing, uploading and testing all Flutter flavors across Android, iOS and Web — without writing repetitive Fastfile boilerplate for each flavor.
+
+---
+
+## Installation
+
+Add to your `Pluginfile`:
+
+```ruby
+gem 'ann-flavor-flutter'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or add directly via Fastlane:
+
+```bash
+fastlane add_plugin ann_flavor_flutter
+```
+
+---
+
+## Quick start
+
+```ruby
+# Fastfile
+lane :deploy_android do
+  ann_compile_build(platform: :android, build_config: "release")
+  ann_upload_to_play_store(platform: :android)
+end
+
+lane :deploy_ios do
+  ann_compile_build(platform: :ios, build_config: "release")
+  ann_upload_to_app_store(platform: :ios)
+end
+```
+
+```bash
+bundle exec fastlane deploy_android
+bundle exec fastlane deploy_ios
+```
+
+---
+
+## Actions
+
+### `ann_compile_build` — Build all flavors for a platform
+
+```ruby
+ann_compile_build(
+  platform:               :android,     # :ios, :android, or :web
+  build_config:           "release",    # "debug", "profile", "release"
+  sub_command:            "appbundle",  # "apk", "appbundle", "ipa", "web"
+  flavor:                 "production", # Comma-separated. Omit to build ALL flavors
+  clean:                  false,
+  main_file:              "lib/main.dart",
+  skip_sound_null_safety: false,
+  skip_code_sign:         false,
+  export_options_plist:   "",           # iOS only
+  additional_parameter:   "",
+  spec_file:              nil           # Custom path to annspec.yaml (optional)
+)
+```
+
+**Examples:**
+
+```ruby
+ann_compile_build(platform: :android)                                         # All Android flavors
+ann_compile_build(platform: :ios, flavor: "production,staging")               # Specific iOS flavors
+ann_compile_build(platform: :web, sub_command: "web", clean: true)            # Web with clean
+```
+
+---
+
+### `ann_upload_to_play_store` — Upload Android to Google Play
+
+```ruby
+ann_upload_to_play_store(
+  flavor:    "production",   # Specific flavor(s). Omit for all
+  clean:     false,
+  spec_file: nil
+)
+```
+
+---
+
+### `ann_upload_to_app_store` — Upload iOS to App Store
+
+```ruby
+ann_upload_to_app_store(
+  flavor:    "production",
+  clean:     false,
+  spec_file: nil
+)
+```
+
+---
+
+### `ann_upload_to_firebase` — Deploy web to Firebase Hosting
+
+```ruby
+ann_upload_to_firebase(
+  flavor:    "web",
+  clean:     false,
+  spec_file: nil
+)
+```
+
+---
+
+### `ann_run_tests` — Run integration tests
+
+```ruby
+ann_run_tests(
+  platform:       :android,
+  test_spec_file: nil
+)
+```
+
+---
+
+### `ann_open_emulators` — Start emulators/simulators
+
+```ruby
+ann_open_emulators(
+  platform:       :android,
+  test_spec_file: nil
+)
+```
+
+---
+
+### `annai_upgrade_setup` — Maintenance setup
+
+```ruby
+annai_upgrade_setup              # Skip if already up to date
+annai_upgrade_setup(force: true) # Force run
+```
+
+---
+
+### `annai_cleanup` — Clean build artifacts
+
+```ruby
+annai_cleanup
+annai_cleanup(force: true)
+```
+
+---
+
+## Configuration
+
+The plugin reads `annspec.yaml` from your Flutter project root. Keys used by Fastlane actions:
+
+```yaml
+annai_app:
+  android:
+    default:
+      signature:
+        key_file: "../annai_app_data/keys/android/my_key.properties"
+    stores:
+      google_play:
+        api_key: "../annai_app_data/keys/android/google-api-key.json"
+    flavor:
+      production:
+        main_file: "lib/flavors/main_prod.dart"
+        version_name: 2.1.0
+        version_code: 20100
+
+  ios:
+    default:
+      team_id: "XXXXXXXXXX"
+    stores:
+      app_store:
+        api_key: "../annai_app_data/keys/ios/apple_api_key.json"
+        export_options_plist: "../annai_app_data/keys/ios/exportOptions.plist"
+    flavor:
+      production:
+        apple_id: "1234567890"
+        main_file: "lib/flavors/main_prod.dart"
+        version_name: 2.1.0
+        version_code: 20100
+```
+
+See the [Gradle plugin README](../ann-flavor-gradle#configuration) for the complete `annspec.yaml` field reference.
+
+---
+
+## Typical CI/CD Fastfile
+
+```ruby
+default_platform(:android)
+
+platform :android do
+  lane :build do
+    ann_compile_build(platform: :android, build_config: "release", sub_command: "appbundle", clean: true)
+  end
+
+  lane :deploy do
+    ann_upload_to_play_store
+  end
+
+  lane :test do
+    ann_open_emulators(platform: :android)
+    ann_run_tests(platform: :android)
+  end
+end
+
+platform :ios do
+  lane :build do
+    ann_compile_build(platform: :ios, build_config: "release", sub_command: "ipa")
+  end
+
+  lane :deploy do
+    ann_upload_to_app_store
+  end
+end
+```
+
+---
+
+## Testing
+
+The plugin has an RSpec test suite:
+
+```bash
+# From ann-flavor-tooling root
+cd plugins/ann-flavor-fastlane && bundle exec rake spec
+
+# Or via the publish script (also saves results + posts Check Run)
+cd ../.. && ./scripts/publish.sh fastlane 0.1.3
+```
+
+---
+
+## Publishing
+
+Publishing is managed from the `ann-flavor-tooling` root:
+
+```bash
+cd ../..
+./scripts/publish.sh fastlane 0.1.3
+```
+
+---
+
+## Requirements
+
+- Fastlane `>= 2.232.2`
+- Ruby `>= 3.0`
+- Flutter project with `annspec.yaml` at the project root
+
+---
+
+## Related plugins
+
+- **[ann-flavor-gradle](../ann-flavor-gradle)** — Gradle plugin for Android build configuration
+- **[ann-flavor-studio](../ann-flavor-studio)** — Android Studio plugin for interactive spec sync
+- **[ann-flavor-flutter](../ann-flavor-flutter)** — Dart runtime API
+
+---
+
+## License
+
+[MIT](LICENSE) © [ANN Solutions](https://github.com/anntech-dev)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/ann-flavor-flutter.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'ann_flavor_flutter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ann-flavor-flutter"
+  spec.version       = AnnFlavorFlutter::VERSION
+  spec.authors       = ["ANN Solutions"]
+  spec.email         = ["support@annaibrands.com"]
+  spec.summary       = "A fastlane plugin to manage Flutter build flavors and shared setup."
+  spec.homepage      = "https://github.com/anntech-dev"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Defines the fastlane dependency
+  spec.add_dependency "fastlane", ">= 2.232.2"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec', '~> 3.4.0'
+  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.6'
+end

data/lib/ann_flavor_flutter/version.rb

@@ -0,0 +1,3 @@
+module AnnFlavorFlutter
+  VERSION = "0.1.7"
+end

data/lib/ann_flavor_flutter.rb

@@ -0,0 +1,10 @@
+# This file is loaded by require 'annai-flutter-flavor'
+
+# Load the version (Good Practice)
+require 'ann_flavor_flutter/version'
+
+require 'fastlane'
+
+# Load the Fastlane plugin structure (which defines the Plugin class)
+require 'fastlane/plugin/ann_flavor_flutter'
+

data/lib/fastlane/plugin/ann_flavor_flutter/actions/ann_compile_build_action.rb

@@ -0,0 +1,219 @@
+require 'fastlane/action'
+require 'fastlane/plugin/ann_flavor_flutter/helper/lanes_annai'
+require 'fastlane/plugin/ann_flavor_flutter/helper/utils_spec_loader'
+
+module Fastlane
+  module Actions
+    class AnnaiCompileBuildAction < Action
+
+      def self.run(params)
+        platform = params[:platform]
+        requested_flavor = params[:flavor]
+        requested_clean_build = params[:clean]
+        spec_file = params[:spec_file]
+
+        # 1. Initialize AnnaiLanes
+        annai_lanes = FastlaneFlutterFlavor::AnnaiLanes.new(
+          lane: self,
+          platform: platform, # Pass platform symbol directly
+          spec_file: spec_file # Pass optional spec_file
+        )
+
+        # Get the StatusManager instance for logging errors explicitly
+        status_manager = annai_lanes.instance_variable_get(:@statusManager)
+
+        spec_loader = annai_lanes.instance_variable_get(:@specLoader)
+        UI.user_error!("Internal Error: AnnaiLanes failed to initialize specLoader.") unless spec_loader
+
+        # Flag to track if any flavor compilation failed
+        any_build_failed = false
+
+        # 2. Perform clean build if requested
+        if requested_clean_build
+            UI.header("🧹 Cleaning builds as requested...")
+            begin
+              annai_lanes.clean_build
+            rescue => e
+              UI.error("Failed to perform clean build: #{e.message}. Attempting to proceed with compilation.")
+              status_manager.logError("All", "annai_clean_build", platform, "Clean build failed: #{e.message}")
+            end
+        end
+
+        # 3. Get the list of all flavors defined for the platform
+        flavors_hash = spec_loader.get_platform_flavors(platform)
+
+        if flavors_hash.empty?
+          UI.important("No flavors found for platform '#{platform}' in the Annai spec. Nothing to build.")
+          annai_lanes.finalize
+          return
+        end
+
+        all_flavor_names = flavors_hash.keys
+
+        # 4. Determine which flavors to build
+        if requested_flavor && !requested_flavor.to_s.empty?
+            requested_flavors = requested_flavor.to_s.split(',').map(&:strip).reject(&:empty?)
+
+            # Validate all requested flavors
+            invalid_flavors = requested_flavors.reject { |f| all_flavor_names.include?(f) }
+
+            if invalid_flavors.any?
+                UI.user_error!("The following requested flavor(s) are not found in the Annai spec for platform '#{platform}': #{invalid_flavors.join(', ')}. Available flavors: #{all_flavor_names.join(', ')}")
+            end
+
+            flavors_to_build = requested_flavors
+
+        else
+            # No specific flavor requested, build all of them
+            flavors_to_build = all_flavor_names
+        end
+
+        UI.header("Starting build for #{platform}. Flavors to compile: #{flavors_to_build.join(', ')}")
+
+
+        # 5. Loop through each flavor and directly call compile_build on AnnaiLanes
+        flavors_to_build.each do |flavor_key|
+
+          flavor = flavor_key.to_s
+
+          # Use the new getter, which uses the internal spec data
+          flavor_main_file = spec_loader.get_main_file(platform, flavor)
+
+          # Use the main_file provided by the user as a fallback if the spec doesn't define one
+          final_main_file = flavor_main_file || params[:main_file]
+
+          if final_main_file.nil? || final_main_file.empty?
+            error_msg = "Could not determine 'main_file' for flavor '#{flavor}' on platform '#{platform}'. Check your Annai spec or provide a default 'main_file'."
+            UI.error("❌ #{error_msg}")
+            status_manager.logError(flavor, "ann_compile_build_all", platform, error_msg)
+            any_build_failed = true
+            next
+          end
+
+          UI.message("⚙️ Compiling **#{flavor}** flavor using main file: #{final_main_file}...")
+
+          begin
+            # CRITICAL: Direct call to the AnnaiLanes helper method
+            success = annai_lanes.compile_build(
+              flavor: flavor,
+              sub_command: params[:sub_command],
+              build_config: params[:build_config],
+              main_file: final_main_file,
+              skip_sound_null_safety: params[:skip_sound_null_safety],
+              skip_code_sign: params[:skip_code_sign],
+              export_options_plist: params[:export_options_plist],
+              additional_parameter: params[:additional_parameter],
+              platform: platform.to_s # Ensure platform is passed as a string/symbol as expected by the helper
+            )
+
+            if success
+              UI.success("🎉 Successfully compiled flavor: #{flavor}")
+            else
+              # If compile_build returns false (meaning it caught an error and logged it), flag the overall failure.
+              raise "Compilation failed for flavor '#{flavor}' (error logged previously)."
+            end
+          rescue => e
+            # Failure handling: Log the error using StatusManager (if not already logged by compile_build) and continue
+            if !status_manager.instance_variable_get(:@status).key?([flavor, "compile_build", platform.to_s])
+              status_manager.logError(flavor, "ann_compile_build_all", platform, e.message)
+            end
+
+            UI.error("❌ Failed to compile flavor: #{flavor}. Continuing to next flavor...")
+            any_build_failed = true
+            # Continue to the next flavor
+          end
+        end
+
+        # 6. Final Reporting and Status Check
+        # Finalize calls statusManager.displayStatus to show the comprehensive report
+        annai_lanes.finalize
+
+        if any_build_failed
+            # If any build failed, we stop the lane with an error after the summary is displayed.
+            UI.user_error!("Compilation failed for one or more flavors. See the Annai Fastlane summary above.")
+        else
+            UI.success("✅ Successfully compiled all #{flavors_to_build.count} requested flavor(s) for #{platform}!")
+        end
+      end
+
+      # ----------------------------------------------------
+      # Define Parameters
+      # ----------------------------------------------------
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       description: "The platform (:ios, :android, or :web)",
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                          UI.user_error!("Platform must be :ios, :android, or :web") unless [:ios, :android, :web].include?(value)
+                                       end),
+
+          FastlaneCore::ConfigItem.new(key: :spec_file,
+                                       description: "Path to the annai spec configuration file (relative to flutter root). Defaults to standard discovery",
+                                       optional: true,
+                                       default_value: nil),
+
+          FastlaneCore::ConfigItem.new(key: :clean,
+                                       description: "If true, runs annai_clean_build before compiling all flavors",
+                                       type: Boolean,
+                                       default_value: false),
+
+          FastlaneCore::ConfigItem.new(key: :flavor,
+                                       description: "The specific flavor(s) to build (comma-separated). If nil, all flavors are built",
+                                       optional: true,
+                                       default_value: nil),
+
+          # All following options are passed directly to the single build action
+          FastlaneCore::ConfigItem.new(key: :sub_command,
+                                       description: "Flutter build subcommand (e.g., appbundle, ipa, web) to use for all flavors",
+                                       # Note: If platform is :web, this should typically be 'web' or similar.
+                                       default_value: "appbundle"),
+          FastlaneCore::ConfigItem.new(key: :build_config,
+                                       description: "Build configuration (e.g., debug, profile, release) to use for all flavors",
+                                       default_value: "release"),
+          FastlaneCore::ConfigItem.new(key: :main_file,
+                                       description: "Path to the main dart file (used as default for all flavors unless overridden in the Annai spec)",
+                                       default_value: "lib/main.dart"),
+          FastlaneCore::ConfigItem.new(key: :skip_sound_null_safety,
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_code_sign,
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :export_options_plist,
+                                       description: "Path to export options plist (iOS only)",
+                                       optional: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :additional_parameter,
+                                       description: "Additional flutter build parameters",
+                                       optional: true,
+                                       default_value: ""),
+        ]
+      end
+
+      def self.description
+        "Compiles all defined Flutter flavors for a single platform (:ios, :android, or :web) using the Annai spec configuration"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android, :web].include?(platform)
+      end
+
+      def self.example_code
+        'ann_compile_build_all(
+          platform: :android,
+          spec_file: "config/my_annai.yaml", # Optional custom spec path
+          build_config: "release",
+          clean: true,
+          flavor: "staging,production" # Optional comma-separated list
+        )
+        ann_compile_build_all(
+          platform: :web,
+          sub_command: "web", # Specify the web subcommand
+          build_config: "release",
+          flavor: "test_web"
+        )'
+      end
+    end
+  end
+end