fastlane-plugin-sunny_project 0.1.17 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 426973fe5f7c18010e37c7b8ff92669cde5f41248810362002422880f0963fb3
-  data.tar.gz: dc20fc4d05f9393fea6a2120196b51b286dcf11406df5d62d08ea961b25b6d97
+  metadata.gz: 42911dd4d19f1f6d97f8a405a4fd77297f9cbaa4bb3799f4aeea86171c7e4937
+  data.tar.gz: 41feddd1a00ba67e10a18330bed8561b9ebccf52c26c606b2806ef9298fc34af
 SHA512:
-  metadata.gz: ba58a0be7e3d4aea68a5b3891832e77448d9158de7374cf1a70f46bac23424e7ded5ccba011fd1788c6e10079fe4a3091e1c1f4809dd743f57d2e95e4abb0013
-  data.tar.gz: ab7cc77b694686df6786c30f9f4e40dc389cf9f3b7737140ee29cbccc128d219ca7d1fc55963fa94a0da7e8e1252f230558e4f77ceaec245fb0db4bf9d945a33
+  metadata.gz: 9f01acd98e752ed2d5a2d55574bb6e5cd6730ff83a679c9a1a476871a29781dab9be46b5fb367f790ed3f09821a1001957de22c8a02e3e6b4891ee8adb6de2cb
+  data.tar.gz: 9d3fa97eb577500c022baced2c03e5f5ed6be59a827d1f2303a1133f162b25f413fd846ee80a8d13f10ade62812d74ee788f0b1c8a8948b725bfb4f57f5fbe06

data/lib/fastlane/plugin/sunny_project/actions/finalize_version_action.rb

@@ -5,21 +5,7 @@ module Fastlane
   module Actions
     class FinalizeVersionAction < Action
       def self.run(options)
-        version = Sunny.current_semver
-        # If we got this far, let's commit the build number and update the git tags.  If the rest of the pro
-        # process fails, we should revert this because it will mess up our commit logs
-        Sunny.run_action(GitCommitAction, path: %w[./pubspec.yaml ./pubspec.lock ./CHANGELOG.md],
-                         allow_nothing_to_commit: true,
-                         message: "Version bump to: #{version.major}.#{version.minor}.#{version.patch}#800#{version.build}")
-        Sunny.run_action(AddGitTagAction,
-                         tag: "sunny/builds/v#{version.build}",
-                         force: true,
-                         sign: false,
-        )
-        Sunny.run_action(PushGitTagsAction, log: true)
-        if File.exist?(Sunny.release_notes_file)
-          File.delete(Sunny.release_notes_file)
-        end
+        Sunny.finalize_version(options)
       end
 
       def self.description
@@ -40,15 +26,15 @@ module Fastlane
       end
 
       def self.available_options
-        [
+         [
           FastlaneCore::ConfigItem.new(key: :tag_group,
                                        env_name: "SUNNY_PROJECT_TAG_GROUP",
                                        description: "The name of the tag group",
                                        optional: false,
                                        type: String,
                                        default_value: "sunny/builds"),
+                     ]
 
-        ]
       end
 
       def self.is_supported?(platform)

data/lib/fastlane/plugin/sunny_project/actions/local_packages_action.rb

@@ -0,0 +1,155 @@
+require 'fastlane/action'
+
+# require 'ci'
+require_relative '../helper/sunny_project_helper'
+require 'yaml'
+
+require_relative '../helper/plugin_options'
+
+module Fastlane
+  module Actions
+    class LocalPackagesAction < Action
+      def self.run(options)
+        puts("Incoming: #{options.class}")
+
+        unless options
+          options = FastlaneCore::Configuration.create(self.available_options, {})
+        end
+        options.load_configuration_file("Sunnyfile")
+        options.load_configuration_file(".Sunnyfile")
+
+        params = options
+        params.all_keys.each do |k|
+          puts("#{k} => #{params[k]}")
+        end
+
+        plugins = params[:sunny_plugins]
+        plugin_folder = params[:sunny_plugin_folder]
+        # pubspec = YAML.load_file("pubspec.yaml")
+        local_mode = params[:sunny_local_mode]
+        is_local = "local".eql?(local_mode)
+        UI.command_output("Local  #{local_mode} creates #{is_local}")
+
+        unless is_local
+          UI.user_error!("Not set to local development.  Not checking out")
+          return
+        end
+
+        roots = []
+        Dir.chdir(plugin_folder) do
+          plugins.keys.each do |key|
+            info = plugins[key] ? plugins[key] : "#{key}"
+            folder = key
+            root_folder = nil
+            branch = nil
+            path = nil
+            repo = key
+            if info.is_a?(String)
+              repo = info
+              root_folder = key
+            else
+              path = info[:path]
+              branch = info[:branch] if info[:branch]
+              repo = info[:repo] if info[:repo]
+              folder = repo
+              root_folder = if path
+                              repo
+                            else
+                              key
+                            end
+            end
+            UI.header("#{folder}")
+            if roots.include?(root_folder)
+              UI.message "Skipping root #{root_folder} - already processed"
+            else
+              git_repo = "git@github.com:SunnyApp/#{repo}.git"
+
+              plugin_exists = Dir.exist?("./#{root_folder}")
+              if !plugin_exists || options[:force]
+                UI.important("Checking out plugin #{repo} to #{root_folder}")
+                Sunny.exec_cmd("clone #{key}", "git clone #{git_repo} #{root_folder}", quiet: true)
+              else
+                UI.message("Plugin already cloned: #{root_folder}")
+              end
+
+              roots.push(root_folder)
+
+              Dir.chdir("./#{folder}") do
+                if branch
+                  UI.important("Verifying branch #{branch}")
+                  unless Sunny.is_branch(branch)
+                    if Sunny.is_clean
+                      Sunny.exec_cmd("checkout branch #{branch}", "git checkout #{branch}")
+                    else
+                      UI.user_error!("Needs to be on branch #{branch}, but repo is not clean.  You will need to manually fix this")
+                    end
+                  end
+                end
+
+                if params[:update]
+                  begin
+                    Sunny.run_action(GitPullAction, rebase: true)
+                  rescue StandardError => e
+                    UI.error("----------    Failed to update   ---------------")
+                    UI.error("There are changes to the working tree.  Check ")
+                    UI.error("the status of each repo below and make any fixes.")
+                    UI.error("------------------------------------------------")
+
+                    UI.command_output(cmd("myrepos status", "git status --porcelain", args = options))
+                  end
+                end
+              end
+            end
+          end
+        end
+
+      end
+
+      def self.description
+        "Checks out local dart packages"
+      end
+
+      def self.authors
+        ["ericmartineau"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        ""
+      end
+
+      def self.available_options
+        opts = [
+          FastlaneCore::ConfigItem.new(key: :update,
+                                       env_name: "SUNNY_UPDATE",
+                                       description: "Whether to update each plugin",
+                                       type: Object,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "SUNNY_FORCE",
+                                       description: "Whether to update each plugin",
+                                       type: Object,
+                                       optional: true),
+        ]
+
+        Fastlane::SunnyProject::Options.available_options.each do |option|
+          opts.push(option)
+        end
+        opts
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end
+

data/lib/fastlane/plugin/sunny_project/actions/pub_release_action.rb

@@ -0,0 +1,68 @@
+require 'fastlane/action'
+require_relative '../helper/sunny_project_helper'
+require 'semantic'
+
+module Fastlane
+  module Actions
+    class PubReleaseAction < Action
+      def self.run(options)
+        unless options[:skip_dirty_check]
+          Sunny.run_action(EnsureGitStatusCleanAction)
+        end
+
+        Sunny.do_increase_version(options)
+        # Whatever happened with the incrementing, this is the build number we're
+        # going with
+        changes = Sunny.release_notes(options)
+        puts(changes)
+
+        Sunny.exec_cmd("pub publish", "pub publish -f")
+        Sunny.finalize_version(options)
+      end
+
+      def self.description
+        "Releases a dart package"
+      end
+
+      def self.authors
+        ["ericmartineau"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        ""
+      end
+
+      def self.available_options
+        opts = [
+          FastlaneCore::ConfigItem.new(key: :skip_dirty_check,
+                                       description: "Whether to skip dirty repo check",
+                                       optional: true, type: Object),
+
+        ]
+        Fastlane::Actions::FinalizeVersionAction.available_options.each do |option|
+          opts.push(option)
+        end
+        Fastlane::Actions::IncreaseVersionAction.available_options.each do |option|
+          opts.push(option)
+        end
+        Fastlane::Actions::ReleaseNotesAction.available_options.each do |option|
+          opts.push(option)
+        end
+        opts
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sunny_project/actions/pubspec_doctor_action.rb

@@ -26,20 +26,15 @@ end
 module Fastlane
   module Actions
     class PubspecDoctorAction < Action
-      def self.run(options)
+      def self.run(params)
 
-        params = FastlaneCore::Configuration.create(Fastlane::SunnyProject::Options.available_options, {})
-        params.load_configuration_file("Sunnyfile")
-        options.all_keys.each do |key|
-          puts("override #{key} => #{options[key]}")
-          params.set(key, options[key])
-        end
-        params.all_keys.each do |k|
-          puts("#{k} => #{params[k]}")
+        unless params
+          params = FastlaneCore::Configuration.create(self.available_options, {})
         end
+        params.load_configuration_file("Sunnyfile")
+        params.load_configuration_file(".Sunnyfile")
 
         plugins = params[:sunny_plugins]
-        branches = params[:sunny_plugins_branches]
         plugin_folder = params[:sunny_plugin_folder]
         pubspec = YAML.load_file("pubspec.yaml")
         local_mode = params[:sunny_local_mode]
@@ -116,7 +111,14 @@ module Fastlane
       end
 
       def self.available_options
-        Fastlane::SunnyProject::Options.available_options
+        opts = [
+
+        ]
+
+        Fastlane::SunnyProject::Options.available_options.each do |option|
+          opts.push(option)
+        end
+        opts
       end
 
       def self.is_supported?(platform)

data/lib/fastlane/plugin/sunny_project/actions/release_notes_action.rb

@@ -8,7 +8,7 @@ module Fastlane
 
     class ReleaseNotesAction < Action
       def self.run(options)
-
+        Sunny.release_notes(options)
       end
 
       def self.description
@@ -30,7 +30,7 @@ module Fastlane
 
       def self.available_options
         [
-            FastlaneCore::ConfigItem.new(key: :changes,
+            FastlaneCore::ConfigItem.new(key: :changelog,
                                          env_name: "SUNNY_PROJECT_CHANGES",
                                          description: "Change log text",
                                          optional: true,

data/lib/fastlane/plugin/sunny_project/actions/sunny_build_runner.rb

@@ -0,0 +1,71 @@
+require_relative '../helper/sunny_project_helper'
+require 'semantic'
+require 'yaml'
+
+require_relative '../helper/plugin_options'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+  module Actions
+    class SunnyBuildRunnerAction < Action
+      def self.run(options)
+        Sunny.build_runner(options)
+      end
+
+      def self.description
+        "Cleans and runs flutter build_runner"
+      end
+
+      def self.authors
+        ["ericmartineau"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        ""
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :clean,
+                                       env_name: "SUNNY_CLEAN",
+                                       description: "Whether to clean",
+                                       optional: true, type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :flutter,
+                                       env_name: "SUNNY_FLUTTER",
+                                       description: "Path to flutter sdk",
+                                       optional: true, type: String),
+          FastlaneCore::ConfigItem.new(key: :skip_pub,
+                                       env_name: "SUNNY_SKIP_PUB",
+                                       description: "Whether to skip pub get",
+                                       optional: true, type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :skip_gen,
+                                       env_name: "SUNNY_SKIP_GEN",
+                                       description: "Whether to skip generation",
+                                       optional: true, type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "SUNNY_VERBOSE",
+                                       description: "Verbose or not",
+                                       optional: true, type: Object),
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end
+

data/lib/fastlane/plugin/sunny_project/actions/sunny_build_web.rb

@@ -0,0 +1,110 @@
+require_relative '../helper/sunny_project_helper'
+require 'semantic'
+require 'yaml'
+
+require_relative '../helper/plugin_options'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+  module Actions
+    class SunnyBuildWebAction < Action
+      def self.run(options)
+        unless options[:skip_build_runner]
+          Sunny.build_runner(options)
+        end
+        flutter = Sunny.get_flutter(options[:flutter])
+        profile = if options[:profile]
+                    " --profile"
+                  else
+                    ""
+                  end
+
+        build_cmd = "build web#{profile} --web-renderer #{options[:renderer]}"
+        Sunny.exec_cmd_options("flutter #{build_cmd}", "#{flutter} #{build_cmd}", options)
+
+        if options[:deploy]
+          Sunny.exec_cmd_options("firebase deploy", "firebase deploy", options)
+        end
+      end
+
+      def self.description
+        "Builds a web project"
+      end
+
+      def self.authors
+        ["ericmartineau"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        ""
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :skip_build_runner,
+                                       env_name: "SUNNY_SKIP_BUILD_RUNNER",
+                                       description: "Whether to skip the build_runner phase",
+                                       optional: true, type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :clean,
+                                       env_name: "SUNNY_CLEAN",
+                                       description: "Whether to clean",
+                                       optional: true, type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :flutter,
+                                       env_name: "SUNNY_FLUTTER",
+                                       description: "Path to flutter sdk",
+                                       optional: true, type: String),
+          FastlaneCore::ConfigItem.new(key: :skip_pub,
+                                       env_name: "SUNNY_SKIP_PUB",
+                                       description: "Whether to skip pub get",
+                                       optional: true, type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :skip_gen,
+                                       env_name: "SUNNY_SKIP_GEN",
+                                       description: "Whether to skip generation",
+                                       optional: true, type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :renderer,
+                                       env_name: "SUNNY_RENDERER",
+                                       description: "The flutter web renderer to build with",
+                                       optional: false,
+                                       default_value: "auto", type: String),
+
+          FastlaneCore::ConfigItem.new(key: :profile,
+                                       env_name: "SUNNY_PROFILE",
+                                       description: "Whether to run in profile mode",
+                                       optional: true,
+                                       type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :deploy,
+                                       env_name: "SUNNY_DEPLOY",
+                                       description: "Whether to deploy to firebase",
+                                       optional: true,
+                                       type: Object),
+
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "SUNNY_VERBOSE",
+                                       description: "Whether to show verbose output",
+                                       optional: true,
+                                       type: Object),
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end
+

data/lib/fastlane/plugin/sunny_project/actions/sunny_release_action.rb

@@ -9,7 +9,7 @@ def resort_keys(input)
   keys = []
   input.each_key do |key|
     puts("Key #{key} #{key.class}")
-    keys.push("#{key}")
+    keys.push(key.to_s)
   end
 
   keys = keys.sort
@@ -29,50 +29,76 @@ module Fastlane
           Sunny.run_action(EnsureGitStatusCleanAction)
         end
 
-
         sunny_file = Sunny.config(SunnyProject::Options.available_options, {})
-        sunny_file.load_configuration_file("Sunnyfile")
+        sunny_file.load_configuration_file("Sunnyfile", skip_printing_values = true)
 
         app_file = CredentialsManager::AppfileConfig
-        firebase_app_id=sunny_file[:firebase_app_id]
+        firebase_app_id = sunny_file[:firebase_app_id]
         unless firebase_app_id
           UI.user_error!("Missing firebase_app_id.  Set this in Sunnyfile")
         end
 
         old_version = Sunny.current_semver
-        build_number = ''
+        old_version_no_build = "#{old_version.major}.#{old_version.minor}.#{old_version.patch}"
+
+        new_version = ''
+
         ## If we're not going to build, we don't need to update
         # version numbers.
-        if options[:build] and not options[:no_bump]
-          if options[:release]
-            build_number = Sunny.do_increase_version(build: true, patch: true)
+
+        if (not options[:skip_build]) && (not options[:no_bump])
+          if options[:patch]
+            new_version = Sunny.do_increase_version(type: "patch")
+            Sunny.update_ios_project_version(new_version)
+          elsif options[:minor]
+            new_version = Sunny.do_increase_version(type: "minor")
+            Sunny.update_ios_project_version(new_version)
+          elsif options[:build]
+            new_version = Sunny.do_increase_version(type: "build")
+            Sunny.update_ios_project_version(new_version)
           else
-            build_number = Sunny.do_increase_version(build: true)
+            UI.user_error!("You must provide the type of version change.  options are minor, patch, build.
+You can also provide no_bump:true to keep the same build number")
           end
 
-          unless build_number
+          unless new_version
             UI.user_error!("Version incrementing failed")
             return
           end
         end
 
+
+
         # Whatever happened with the incrementing, this is the build number we're
         # going with
-        version = Sunny.current_semver
-        UI.command_output("Build Version: #{version}")
+        version = new_version
+        version_no_build = "#{version.major}.#{version.minor}.#{version.patch}"
+        is_version_changed = old_version_no_build.eql?(version_no_build) != true
+        build_number = version.build
         changes = Sunny.release_notes(options)
-        UI.important('--------------- CHANGELOG ------------------')
-        UI.important(changes)
-        UI.important('--------------------------------------------')
-
+        app_name = options[:app_name]
+        release_target = options[:release_target]
+
+        puts("")
+        build_summary = [
+          ["App name", (app_file.try_fetch_value(:app_identifier)).to_s],
+          ["Target", app_name],
+          ["Major version", is_version_changed ? "#{old_version_no_build} -> #{version_no_build}" : "#{version_no_build} (no change)"],
+          ["Build number", "#{old_version.build} -> #{build_number}"],
+          ["Releasing to", release_target,],
+          %W[Changelog #{changes}],
+        ]
+        UI.important("\n\n#{Terminal::Table.new(rows: FastlaneCore::PrintTable.transform_output(build_summary),
+                                                title: 'Build Summary')}")
+        puts("")
         # TRY to execute a build.  if it fails, revert the version number changes
         begin
-          if options[:build]
+          unless options[:skip_build]
             if options[:skip_flutter_build]
-              UI.important "Skipping Flutter Build"
+              UI.important("Skipping Flutter Build")
             else
-              UI.header "Run Flutter Build"
-              Sunny.build_ios(build_number)
+              UI.header("Run Flutter Build")
+              Sunny.build_ios(version_no_build, build_number)
             end
             require 'match'
             build_opts = options[:build_options]
@@ -84,16 +110,16 @@ module Fastlane
 
             match_opts.load_configuration_file("Matchfile")
 
-            UI.header "Read Appfile info"
+            UI.header("Read Appfile info")
             # Read the app identifier from Appfile
             app_identifier = app_file.try_fetch_value(:app_identifier)
-            UI.command_output "App: #{app_identifier}"
+            UI.command_output("App: #{app_identifier}")
             unless app_identifier
               UI.user_error!("No app_identifier could be found")
             end
 
             MatchAction.run(match_opts)
-            UI.header "Run Xcode Build"
+            UI.header("Run Xcode Build")
             Sunny.run_action(BuildAppAction, workspace: "ios/Runner.xcworkspace",
                              scheme: "Runner",
                              export_method: build_opts[1],
@@ -102,7 +128,7 @@ module Fastlane
                              clean: options[:clean],
                              export_options: {
                                provisioningProfiles: {
-                                 "#{app_identifier}" => "match #{build_opts[2]} #{app_identifier}",
+                                 app_identifier.to_s => "match #{build_opts[2]} #{app_identifier}",
                                }
                              },
                              output_directory: "build/ios")
@@ -116,28 +142,27 @@ module Fastlane
           return
         end
 
-        app_name = options[:app_name]
         # Commits the version number, deletes changelog file
-        if options[:build] or options[:post_build]
+        if (not options[:skip_build]) || options[:post_build]
           unless options[:skip_symbols]
-            UI.header "Upload Symbols to Crashlytics"
+            UI.header("Upload Symbols to Crashlytics")
             Sunny.run_action(UploadSymbolsToCrashlyticsAction, dsym_path: "./build/ios/#{app_name}.app.dSYM.zip",
                              binary_path: "./ios/Pods/FirebaseCrashlytics/upload-symbols")
           end
 
-          UI.header "Commit pubspec.yaml, Info.plist for version updates"
+          UI.header("Commit pubspec.yaml, Info.plist for version updates")
           # If we got this far, let's commit the build number and update the git tags.  If the rest of the pro
           # process fails, we should revert this because it will mess up our commit logs
           Sunny.run_action(GitCommitAction,
                            allow_nothing_to_commit: true,
-                           path: %w[./pubspec.yaml ./pubspec.lock ./Gemfile.lock ./ios/Runner/Info.plist],
-                           message: "\"Version bump to: #{version.major}.#{version.minor}.#{version.patch}#800#{version.build}\"")
-          UI.header "Tagging repo v#{version.build}"
+                           path: %w[./pubspec.yaml ./pubspec.lock ./ios/Podfile.lock ./Gemfile.lock ./ios/Runner/Info.plist],
+                           message: "\"Version bump to: #{version_no_build}##{build_number}\"")
+          UI.header("Tagging repo v#{version.build}")
           Sunny.run_action(AddGitTagAction,
                            grouping: "sunny-builds",
                            prefix: "v",
                            force: true,
-                           build_number: version.build
+                           build_number: build_number
           )
           Sunny.run_action(PushGitTagsAction, force: false)
         end
@@ -145,10 +170,9 @@ module Fastlane
         unless options[:no_upload]
 
           # platform :ios do
-          release_target = options[:release_target]
+
           if release_target == "firebase"
-            UI.header "Firebase: uploading build/ios/#{app_name}.ipa"
-            #require 'fastlane-plugin-firebase_app_distribution'
+            UI.header("Firebase: uploading build/ios/#{app_name}.ipa")
 
             Sunny.run_action(FirebaseAppDistributionAction,
                              app: firebase_app_id,
@@ -157,7 +181,7 @@ module Fastlane
                              debug: true
             )
           elsif release_target == "testflight"
-            UI.header "Testflight: uploading build/ios/#{app_name}.ipa"
+            UI.header("Testflight: uploading build/ios/#{app_name}.ipa")
             Sunny.run_action(UploadToTestflightAction,
                              ipa: "build/ios/#{app_name}.ipa",
                              localized_build_info: {
@@ -178,7 +202,7 @@ module Fastlane
       end
 
       def self.description
-        "Modify pubspec for local or git development"
+        "Perform ios or firebase release"
       end
 
       def self.authors
@@ -200,25 +224,34 @@ module Fastlane
                                        env_name: "SUNNY_NO_BUMP",
                                        description: "Whether to skip a bump",
                                        optional: true, type: Object),
-          FastlaneCore::ConfigItem.new(key: :build,
-                                       env_name: "SUNNY_BUILD",
-                                       description: "Whether to perform a complete build",
+          FastlaneCore::ConfigItem.new(key: :skip_build,
+                                       env_name: "SUNNY_SKIP_BUILD",
+                                       description: "Whether to skip the building of the project",
                                        optional: true, type: Object),
           FastlaneCore::ConfigItem.new(key: :post_build,
                                        env_name: "SUNNY_POST_BUILD",
-                                       description: "Whether to execute actions after building",
+                                       description: "Whether to execute actions after building. Can be used in conjunction with skip_build to avoid building the entire project, but still applying tags",
                                        optional: true, type: Object),
           FastlaneCore::ConfigItem.new(key: :skip_dirty_check,
                                        env_name: "SUNNY_SKIP_DIRTY_CHECK",
                                        description: "Whether to skip dirty repo check",
                                        optional: true, type: Object),
+
           FastlaneCore::ConfigItem.new(key: :clean,
                                        env_name: "SUNNY_CLEAN",
                                        description: "Whether to do a clean build",
                                        optional: true, type: Object),
-          FastlaneCore::ConfigItem.new(key: :release,
-                                       env_name: "SUNNY_RELEASE",
-                                       description: "Whether to make a release vs patch build",
+          FastlaneCore::ConfigItem.new(key: :minor,
+                                       env_name: "SUNNY_MINOR",
+                                       description: "Whether to make a minor release",
+                                       optional: true, type: Object),
+          FastlaneCore::ConfigItem.new(key: :patch,
+                                       env_name: "SUNNY_PATCH",
+                                       description: "Whether to make a patch release",
+                                       optional: true, type: Object),
+          FastlaneCore::ConfigItem.new(key: :build,
+                                       env_name: "SUNNY_BUILD",
+                                       description: "Whether to increment only the build number for the release",
                                        optional: true, type: Object),
           FastlaneCore::ConfigItem.new(key: :changelog,
                                        env_name: "SUNNY_CHANGELOG",
@@ -237,7 +270,7 @@ module Fastlane
 
           FastlaneCore::ConfigItem.new(key: :release_target,
                                        env_name: "SUNNY_RELEASE_TARGET",
-                                       description: "Where we're releasing to",
+                                       description: "Where we're releasing to, must be either fastlane or testflight",
                                        optional: false,
                                        type: String),
 
@@ -287,7 +320,7 @@ module Fastlane
 
       def visit_Psych_Nodes_Scalar(o)
         if o.value.is_a?(String)
-          str = "#{o.value}"
+          str = (o.value).to_s
           if str.start_with?('^') || str.start_with?('..')
             @handler.scalar(o.value, o.anchor, o.tag, o.plain, o.quoted, 1)
           elsif str.start_with?('https://') || str.start_with?('git@')

data/lib/fastlane/plugin/sunny_project/helper/plugin_options.rb

@@ -12,38 +12,34 @@ module Fastlane
 
       def self.available_options
         [
-            FastlaneCore::ConfigItem.new(key: :sunny_plugins,
-                                         env_name: "SUNNY_PLUGINS",
-                                         description: "The plugins",
-                                         type: Hash,
-                                         optional: true,),
-            FastlaneCore::ConfigItem.new(key: :firebase_app_id,
-                                         env_name: "SUNNY_FIREBASE_APP_ID",
-                                         description: "Firebase app id",
-                                         type: String,
-                                         optional: true,),
-            FastlaneCore::ConfigItem.new(key: :firebase_cli_path,
-                                         env_name: "SUNNY_FIREBASE_CLI_PATH",
-                                         description: "Firebase cli path",
-                                         type: String,
-                                         optional: true,),
-            FastlaneCore::ConfigItem.new(key: :sunny_plugin_folder,
-                                         env_name: "SUNNY_PLUGIN_FOLDER",
-                                         description: "Folder that contains the packages",
-                                         type: String,
-                                         optional: false,
-                                         default_value: '../plugin'),
-            FastlaneCore::ConfigItem.new(key: :sunny_plugins_branches,
-                                         env_name: "SUNNY_PLUGINS_BRANCHES",
-                                         description: "Specific branches to use",
-                                         type: Hash,
-                                         optional: true,),
-            FastlaneCore::ConfigItem.new(key: :sunny_local_mode,
-                                         env_name: "SUNNY_LOCAL_MODE",
-                                         description: "Whether the project uses local checked out packages",
-                                         type: String,
-                                         optional: true,
-                                         default_value: "git"),
+          FastlaneCore::ConfigItem.new(key: :sunny_plugins,
+                                       env_name: "SUNNY_PLUGINS",
+                                       description: "The plugins",
+                                       type: Hash,
+                                       optional: true,),
+          FastlaneCore::ConfigItem.new(key: :firebase_app_id,
+                                       env_name: "SUNNY_FIREBASE_APP_ID",
+                                       description: "Firebase app id",
+                                       type: String,
+                                       optional: true,),
+          FastlaneCore::ConfigItem.new(key: :firebase_cli_path,
+                                       env_name: "SUNNY_FIREBASE_CLI_PATH",
+                                       description: "Firebase cli path",
+                                       type: String,
+                                       optional: true,),
+          FastlaneCore::ConfigItem.new(key: :sunny_plugin_folder,
+                                       env_name: "SUNNY_PLUGIN_FOLDER",
+                                       description: "Folder that contains the packages",
+                                       type: String,
+                                       optional: false,
+                                       default_value: '../plugin'),
+          # value should be 'git' or 'local'
+          FastlaneCore::ConfigItem.new(key: :sunny_local_mode,
+                                       env_name: "SUNNY_LOCAL_MODE",
+                                       description: "Whether the project uses local checked out packages",
+                                       type: String,
+                                       optional: true,
+                                       default_value: "git"),
 
         ]
       end

data/lib/fastlane/plugin/sunny_project/helper/sunny_project_helper.rb

@@ -1,4 +1,5 @@
 require 'fastlane_core/ui/ui'
+require 'fastlane/helper/sh_helper'
 require "fastlane"
 
 module Fastlane
@@ -21,6 +22,20 @@ module Fastlane
       end
     end
 
+    def self.is_clean
+      self.run_action(Fastlane::Actions::EnsureGitStatusCleanAction)
+      true
+    rescue
+      false
+    end
+
+    def self.is_branch(branch_name)
+      self.run_action(Fastlane::Actions::EnsureGitBranchAction, branch: branch_name)
+      true
+    rescue
+      false
+    end
+
     def self.config(available_options, options)
       FastlaneCore::Configuration.create(available_options, options)
     end
@@ -29,47 +44,98 @@ module Fastlane
       action.run(self.config(action.available_options, options))
     end
 
+    def self.mmp(semver)
+      "#{semver.major}.#{semver.minor}.#{semver.patch}"
+    end
+
     def self.do_increase_version(options)
-      command = "pubver bump #{options[:type]} "
-      if options[:type] == 'patch'
-        command += "-b"
+      bump_type = options[:type]
+      bump_type = "build" unless bump_type
+      command = "pubver bump #{bump_type}"
+      unless bump_type.eql?('build')
+        command += " -b"
+      end
+      self.exec_cmd(command.to_s, command)
+
+      unless bump_type.eql?('build')
+        self.exec_cmd("also bump build", "pubver bump build")
       end
-      self.exec_cmd("bump patch", command)
+
       self.current_semver
     end
 
+    def self.update_ios_project_version(new_version)
+      Dir.chdir("ios") {
+        puts("Updating XCode Project files: version:#{mmp(new_version)}, build: #{new_version.build}")
+        self.run_action(Fastlane::Actions::IncrementVersionNumberAction, version_number: mmp(new_version))
+        self.run_action(Fastlane::Actions::IncrementBuildNumberAction, build_number: new_version.build)
+      }
+    end
+
+    def self.config_to_hash(options)
+      hash = Hash([])
+      options.all_keys.each do |key|
+        hash.store(key, options.fetch(key, ask: false))
+      end
+      return hash
+    end
+
     def self.exec_cmd(name, *command, **args)
-      if (command.count > 1)
-        command = command.map { |item| Shellwords.escape item }
+      if command.count > 1
+        command = command.map { |item| Shellwords.escape(item) }
       end
       joined = command.join(" ")
       if args[:verbose]
         begin
-          return sh(command)
+          return Fastlane::Actions.sh(*command, log:true, error_callback: ->(str) { UI.user_error!(">> #{name} failed << \n #{str}") })
         rescue StandardError => e
-          UI.user_error! ">> #{name} failed << \n  #{e}"
+          UI.user_error!(">> #{name} failed << \n  #{e}")
         end
       else
         if args[:cmd_out]
-          UI.command_output name
+          UI.command_output(name)
         elsif args[:quiet]
         else
           UI.command name
         end
 
         stdout, err, status = Open3.capture3(joined)
-        UI.user_error! ">> #{name} failed << \n  command: #{joined}\n  error: #{err}" unless status == 0
+        UI.user_error!(">> #{name} failed << \n  command: #{joined}\n  error: #{err}") unless status == 0
         stdout
       end
     end
 
+    def self.exec_cmd_options(name, command, options)
+      return exec_cmd(name, command, **config_to_hash(options))
+    end
+
     def self.release_notes_file
       ".release-notes"
     end
 
     ### Reads the latest version from pubspec.yaml
     def self.current_semver
-      Semantic::Version.new current_version_string
+      Semantic::Version.new(current_version_string)
+    end
+
+    def self.finalize_version(options)
+      version = self.current_semver
+      # If we got this far, let's commit the build number and update the git tags.  If the rest of the pro
+      # process fails, we should revert this because it will mess up our commit logs
+      self.run_action(Fastlane::Actions::GitAddAction, path: %w[./pubspec.yaml ./pubspec.lock ./CHANGELOG.md])
+      self.run_action(Fastlane::Actions::GitCommitAction, path: %w[./pubspec.yaml ./pubspec.lock ./CHANGELOG.md],
+                       allow_nothing_to_commit: false,
+
+                       message: "Version bump to: #{version.major}.#{version.minor}.#{version.patch}#800#{version.build}")
+      self.run_action(Fastlane::Actions::AddGitTagAction,
+                       tag: "sunny/builds/v#{version.build}",
+                       force: true,
+                       sign: false,
+                       )
+      self.run_action(Fastlane::Actions::PushGitTagsAction, force: true)
+      if File.exist?(self.release_notes_file)
+        File.delete(self.release_notes_file)
+      end
     end
 
     def self.release_notes(options)
@@ -113,7 +179,7 @@ module Fastlane
         lines = ["## [#{v}]\n", " * #{changes}\n", "\n"] + lines
 
         output = File.new("CHANGELOG.md", "w")
-        lines.each { |line| output.write line }
+        lines.each { |line| output.write(line) }
         output.close
       end
       changes
@@ -123,10 +189,36 @@ module Fastlane
       provided || ".fvm/flutter_sdk/bin/flutter"
     end
 
+    def self.build_runner(options)
+      flutter = get_flutter(options[:flutter])
+      opt_hash = config_to_hash(options)
+      if options[:clean]
+        exec_cmd("flutter clean", "#{flutter} clean", **opt_hash)
+      end
+
+      if options[:clean] || (!options[:skip_pub])
+        exec_cmd("flutter pub get", "#{flutter} pub get", **opt_hash)
+      end
+
+      if options[:clean] || (!options[:skip_gen])
+        dc = if options[:clean]
+               " --delete-conflicting-outputs"
+             else
+               ""
+             end
+        vb = if options[:verbose]
+               " -v"
+             else
+               ""
+             end
+        exec_cmd("flutter pub run build_runner build#{dc}#{vb}", "#{flutter} pub run build_runner build#{dc}#{vb}", **opt_hash)
+      end
+    end
+
     def self.override_version(**options)
       semver = options[:version]
       unless semver
-        UI.user_error! "No version parameter found"
+        UI.user_error!("No version parameter found")
         return
       end
       self.exec_cmd("set_version", "pubver set #{semver}", quiet: true)
@@ -138,16 +230,17 @@ module Fastlane
         self.run_action(Fastlane::Actions::IncrementVersionNumberAction,
                         version_number: "#{version.major}.#{version.minor}.#{version.patch}",
                         xcodeproj: "ios/Runner.xcodeproj"
-        )
+                       )
       else
-        UI.user_error! "No version found"
+        UI.user_error!("No version found")
       end
 
     end
 
-    def self.build_ios(build_num, **options)
+    def self.build_ios(build_ver, build_num, **options)
       flutter = get_flutter(options[:flutter])
-      self.exec_cmd("build flutter ios release #{build_num}", "#{flutter} build ios --release --no-tree-shake-icons --no-codesign --build-number=#{build_num}")
+
+      self.exec_cmd("build flutter ios release #{build_ver} #{build_num}", "#{flutter} build ios --release --no-tree-shake-icons --no-codesign")
     end
 
     ### Reads the latest version from pubspec.yaml

data/lib/fastlane/plugin/sunny_project/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module SunnyProject
-    VERSION = "0.1.17"
+    VERSION = "0.2.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-sunny_project
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.2.2
 platform: ruby
 authors:
 - ericmartineau
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-05 00:00:00.000000000 Z
+date: 2021-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -150,10 +150,14 @@ files:
 - lib/fastlane/plugin/sunny_project/actions/finalize_version_action.rb
 - lib/fastlane/plugin/sunny_project/actions/generate_icons_action.rb
 - lib/fastlane/plugin/sunny_project/actions/increase_version_action.rb
+- lib/fastlane/plugin/sunny_project/actions/local_packages_action.rb
 - lib/fastlane/plugin/sunny_project/actions/pub_publish_action.rb
+- lib/fastlane/plugin/sunny_project/actions/pub_release_action.rb
 - lib/fastlane/plugin/sunny_project/actions/pubspec_doctor_action.rb
 - lib/fastlane/plugin/sunny_project/actions/release_notes_action.rb
 - lib/fastlane/plugin/sunny_project/actions/rename_assets_action.rb
+- lib/fastlane/plugin/sunny_project/actions/sunny_build_runner.rb
+- lib/fastlane/plugin/sunny_project/actions/sunny_build_web.rb
 - lib/fastlane/plugin/sunny_project/actions/sunny_release_action.rb
 - lib/fastlane/plugin/sunny_project/helper/plugin_options.rb
 - lib/fastlane/plugin/sunny_project/helper/sunny_project_helper.rb