fastlane-plugin-sapfire 1.0.0

data/lib/fastlane/plugin/sapfire/msbuild/runner.rb

@@ -0,0 +1,171 @@
+require "open3"
+require "fastlane_core/print_table"
+require_relative "module"
+require_relative "options"
+require_relative "../sln_project/module"
+require_relative "../helper/sapfire_helper"
+
+module Msbuild
+  class Runner
+    def run
+      params = Msbuild.config.params
+
+      FastlaneCore::PrintTable.print_values(config: params, title: "Summary for msbuild")
+      UI.user_error!("Can't find MSBuild") unless Fastlane::Helper::SapfireHelper.msbuild_specified?
+      UI.user_error!("Can't find dotnet. You selected MSBuild as a library, so dotnet is required to work with it. ") if
+        Msbuild.config.msbuild_type == Msbuild::MsbuildType::LIBRARY && !Fastlane::Helper::SapfireHelper.dotnet_specified?
+
+      prev_cwd = Dir.pwd
+      working_directory = File.dirname(File.expand_path(params[:project]))
+      UI.message("Change working directory to #{working_directory}")
+      Dir.chdir(working_directory)
+
+      params[:jobs] = 1 if params[:jobs].zero?
+      msbuild_path = Msbuild.config.msbuild_path
+      msbuild_args = get_msbuild_args(params, Msbuild.config.overwritten_props)
+      cmd = "#{msbuild_path} #{msbuild_args.join(" ")}"
+
+      check_configuration_platform(params)
+      UI.command(cmd)
+
+      Open3.popen2(cmd) do |_, stdout, wait_thr|
+        until stdout.eof?
+          stdout.each do |l|
+            line = l.force_encoding("utf-8").chomp
+            puts line
+          end
+        end
+
+        UI.user_error!("MSBuild execution failed. See the log above.") unless wait_thr.value.success?
+        UI.success("MSBuild has ended successfully") if wait_thr.value.success?
+      end
+
+      rename_package(params)
+
+      UI.message("Change working directory back to #{prev_cwd}")
+      Dir.chdir(prev_cwd)
+    end
+
+    def get_project_property_string(key, value)
+      "-p:#{key}=#{value}"
+    end
+
+    def get_msbuild_args(params, overwritten_props)
+      args = []
+
+      if params.values.include?(:properties)
+        params[:properties].each do |key, value|
+          unless overwritten_props.include?(key)
+            args.append(get_project_property_string(key, value))
+            next
+          end
+
+          # Remove properties that would be overwritten by this action
+          UI.important("Property #{key} will be ignored. Use `#{overwritten_props[key]}` option instead.")
+        end
+      end
+
+      configuration = params[:configuration] if
+        params.values.include?(:configuration) && !params[:configuration].empty?
+
+      platform = params[:platform] if
+        params.values.include?(:platform) && !params[:platform].empty?
+
+      need_restore = ([true].include?(params[:restore]) if params.values.include?(:restore)) || false
+
+      need_clean = ([true].include?(params[:clean]) if params.values.include?(:clean)) || false
+
+      appx_output_path = File.expand_path(params[:appx_output_path]) if
+        params.values.include?(:appx_output_path) && !params[:appx_output_path].empty?
+
+      appx_bundle_platforms = params[:appx_bundle_platforms] if
+        params.values.include?(:appx_bundle_platforms) && !params[:appx_bundle_platforms].empty?
+
+      build_mode = params[:build_mode] if
+        params.values.include?(:build_mode) && !params[:build_mode].empty?
+
+      certificate = Msbuild.config.certificate unless
+        Msbuild.config.certificate.nil? || Msbuild.config.certificate.empty?
+
+      certificate_password = Msbuild.config.certificate_password unless
+        Msbuild.config.certificate_password.nil? || Msbuild.config.certificate_password.empty?
+
+      certificate_thumbprint = Msbuild.config.certificate_thumbprint unless
+        Msbuild.config.certificate_thumbprint.nil? || Msbuild.config.certificate_thumbprint.empty?
+
+      signing_enabled = !params[:skip_codesigning] if params.values.include?(:skip_codesigning)
+
+      args.append("-p:Configuration=\"#{configuration}\"") unless configuration.nil?
+      args.append("-p:Platform=\"#{platform}\"") unless platform.nil?
+      args.append("-p:AppxPackageDir=\"#{appx_output_path}\"") unless appx_output_path.nil?
+      args.append("-p:AppxBundlePlatforms=\"#{appx_bundle_platforms}\"") unless appx_bundle_platforms.nil?
+      args.append("-p:AppxBundle=Always") if Msbuild.config.build_type == Msbuild::BuildType::UWP
+      args.append("-p:UapAppxPackageBuildMode=#{build_mode}") unless build_mode.nil?
+      args.append("-p:AppxPackageSigningEnabled=#{signing_enabled}") unless signing_enabled.nil?
+      args.append("-p:PackageCertificateKeyFile=\"#{certificate}\"") unless certificate.nil?
+      args.append("-p:PackageCertificatePassword=#{certificate_password}") unless certificate_password.nil?
+      args.append("-p:PackageCertificateThumbprint=#{certificate_thumbprint}") unless certificate_thumbprint.nil?
+      args.append("-m#{params[:jobs].positive? ? ":#{params[:jobs]}" : ""}")
+      args.append("-r") if need_restore || Msbuild.config.build_type == Msbuild::BuildType::NUGET
+
+      args.append("-t:Clean;Build") if need_clean
+      args.append("-t:Pack") if Msbuild.config.build_type == Msbuild::BuildType::NUGET
+
+      args
+    end
+
+    def check_configuration_platform(params)
+      configuration = params[:configuration] if
+        params.values.include?(:configuration) && !params[:configuration].empty?
+
+      platform = params[:platform] if
+        params.values.include?(:platform) && !params[:platform].empty?
+
+      root_block = SlnProject.open(params[:project])
+      platforms = root_block.global.solution_configuration_platforms.platforms
+
+      UI.user_error!("Configuration #{configuration} was not found in the solution") if
+        configuration.nil? || !platforms.key?(configuration)
+      UI.user_error!("Platform #{platform} for configuration #{configuration} was not found in the solution") if
+        platform.nil? || !platforms[configuration].include?(platform)
+
+      appx_bundle_platforms = params[:appx_bundle_platforms] if
+        params.values.include?(:appx_bundle_platforms) && !params[:appx_bundle_platforms].empty?
+      return if appx_bundle_platforms.nil?
+
+      appx_bundle_platforms.split("|").each do |x|
+        UI.user_error!("Platform #{x} for APPX bundle was not found in the solution") if
+          x.nil? || !platforms[configuration].include?(x)
+      end
+    end
+
+    def rename_package(params)
+      appx_output_name = params[:appx_output_name] if
+        params.values.include?(:appx_output_name) && !params[:appx_output_name].empty?
+
+      return if appx_output_name.nil? || appx_output_name.empty?
+
+      appx_output_path = File.expand_path(params[:appx_output_path]) if
+        params.values.include?(:appx_output_path) && !params[:appx_output_path].empty?
+      appx_output_path = "./" if appx_output_path.nil? || appx_output_path.empty?
+
+      Msbuild::Options::PACKAGE_FORMATS.each do |extension|
+        entries = Dir.entries(appx_output_path).find_all { |x| x.end_with?(extension) }
+        next if entries.nil? || entries.empty?
+
+        old_name = entries[0]
+        new_name = "#{appx_output_name}#{extension}"
+
+        UI.message("Rename #{old_name} to #{new_name}")
+        File.rename(File.join(appx_output_path, old_name), File.join(appx_output_path, new_name))
+      end
+
+    end
+
+    public(:run)
+    private(:get_project_property_string)
+    private(:get_msbuild_args)
+    private(:check_configuration_platform)
+    private(:rename_package)
+  end
+end

data/lib/fastlane/plugin/sapfire/sln_project/block.rb

@@ -0,0 +1,30 @@
+module SlnProject
+  class Assignment
+    attr_accessor :key, :value
+
+    def initialize(line)
+      parts = line.split("=")
+
+      if parts.empty?
+        self.key = ""
+        self.value = ""
+        return
+      end
+
+      self.key = parts[0].strip
+      self.value = parts[1].strip
+    end
+  end
+
+  class InnerBlockResult
+    attr_accessor :block, :is_end
+  end
+
+  class BaseBlock
+    def parse(block_str)
+      nil
+    end
+
+    protected(:parse)
+  end
+end

data/lib/fastlane/plugin/sapfire/sln_project/global_block.rb

@@ -0,0 +1,147 @@
+require_relative "block"
+
+module SlnProject
+  class GlobalBlock < BaseBlock
+    START_TOKENS = {
+      GlobalSectionToken: "GlobalSection"
+    }.freeze
+
+    END_TOKENS = {
+      GlobalSectionToken: "EndGlobalSection"
+    }.freeze
+
+    attr_accessor :solution_configuration_platforms, :solution_properties
+
+    def parse(block_str)
+      inner_block = nil
+      inner_block_str = ""
+      content_reader = StringIO.new(block_str)
+
+      content_reader.each_line do |line|
+        trim_line = line.strip
+        inner_block = check_start_token(trim_line, inner_block)
+        inner_block = check_end_token(trim_line, inner_block, inner_block_str)
+
+        inner_block_str += "#{trim_line}\n" unless inner_block.nil?
+        inner_block_str = "" if inner_block.nil?
+      end
+    end
+
+    def check_start_token(line, inner_block)
+      inner_block = GlobalSectionFactory.create(line) if line.start_with?("#{START_TOKENS[:GlobalSectionToken]}(")
+      inner_block
+    end
+
+    def check_end_token(line, inner_block, inner_block_str)
+      return inner_block unless END_TOKENS.any? { |_, v| line == v }
+
+      inner_block.parse(inner_block_str)
+
+      case inner_block.type
+      when GlobalSectionBlock::TYPES[:SolutionConfigurationPlatforms]
+        self.solution_configuration_platforms = inner_block
+      when GlobalSectionBlock::TYPES[:SolutionProperties]
+        self.solution_properties = inner_block
+      end
+
+      nil
+    end
+
+    public(:parse)
+    private(:check_start_token)
+    private(:check_end_token)
+    private(:solution_configuration_platforms=)
+    private(:solution_properties=)
+  end
+
+  class GlobalSectionFactory
+    def self.create(line)
+      type = parse_header(line)
+
+      case type
+      when GlobalSectionBlock::TYPES[:SolutionConfigurationPlatforms]
+        SolutionConfigurationPlatformsBlock.new(type)
+      when GlobalSectionBlock::TYPES[:SolutionProperties]
+        SolutionPropertiesBlock.new(type)
+      else
+        GlobalSectionBlock.new(GlobalSectionBlock::TYPES[:Unknown])
+      end
+    end
+
+    def self.parse_header(line)
+      key = Assignment.new(line).key
+      pattern = /\((.*?)\)/
+      key.match(pattern)[1]
+    end
+
+    private_class_method(:parse_header, :new)
+    public_class_method(:create)
+  end
+
+  class GlobalSectionBlock < BaseBlock
+    TYPES = {
+      SolutionConfigurationPlatforms: "SolutionConfigurationPlatforms",
+      SolutionProperties: "SolutionProperties",
+      Unknown: "Unknown" # must be always the last
+    }.freeze
+
+    attr_accessor :type
+
+    def initialize(type)
+      self.type = type
+    end
+
+    private(:type=)
+  end
+
+  class SolutionConfigurationPlatformsBlock < GlobalSectionBlock
+    attr_accessor :platforms
+
+    def parse(block_str)
+      is_header = false
+      content_reader = StringIO.new(block_str)
+      self.platforms = {}
+
+      content_reader.each_line do |line|
+        unless is_header
+          is_header = true
+          next
+        end
+
+        assignment = Assignment.new(line).key
+        assignment_parts = assignment.split("|")
+        configuration = assignment_parts[0]
+        platform = assignment_parts[1]
+
+        self.platforms[configuration] = [] unless self.platforms[configuration].is_a?(Array) && !self.platforms[configuration].empty?
+        self.platforms[configuration].append(platform)
+      end
+    end
+
+    public(:parse)
+    private(:platforms=)
+  end
+
+  class SolutionPropertiesBlock < GlobalSectionBlock
+    attr_accessor :entries
+
+    def parse(block_str)
+      is_header = false
+      content_reader = StringIO.new(block_str)
+      self.entries = {}
+
+      content_reader.each_line do |line|
+        unless is_header
+          is_header = true
+          next
+        end
+
+        assignment = Assignment.new(line)
+        self.entries[assignment.key] = assignment.value
+      end
+    end
+
+    public(:parse)
+    private(:entries=)
+  end
+end

data/lib/fastlane/plugin/sapfire/sln_project/module.rb

@@ -0,0 +1,14 @@
+require_relative "root_block"
+
+module SlnProject
+  def self.open(path)
+    path = path.to_s
+    raise "Path to SLN-file can't be empty or null" unless path && !path.empty?
+    raise "The SLN-file at path #{path} doesn't exist" unless File.exist?(path)
+
+    content = File.read(path)
+    root_block = RootBlock.new
+    root_block.parse(content)
+    root_block
+  end
+end

data/lib/fastlane/plugin/sapfire/sln_project/project_block.rb

@@ -0,0 +1,82 @@
+require_relative "block"
+
+module SlnProject
+  class ProjectBlock < BaseBlock
+    START_TOKENS = {
+      ProjectSectionToken: "ProjectSection"
+    }.freeze
+
+    END_TOKENS = {
+      ProjectSectionToken: "EndProjectSection"
+    }.freeze
+
+    attr_accessor :guid, :name, :path
+
+    def parse(block_str)
+      is_header_passed = false
+      inner_block = nil
+      inner_block_str = ""
+      content_reader = StringIO.new(block_str)
+
+      content_reader.each_line do |line|
+        trim_line = line.strip
+
+        unless is_header_passed
+          is_header_passed = true if parse_header(trim_line)
+        end
+
+        inner_block = check_start_token(trim_line, inner_block)
+        inner_block = check_end_token(trim_line, inner_block, inner_block_str)
+
+        inner_block_str += "#{trim_line}\n" unless inner_block.nil?
+        inner_block_str = "" if inner_block.nil?
+      end
+    end
+
+    def to_s
+      name
+    end
+
+    def check_start_token(line, inner_block)
+      inner_block = ProjectSectionBlock.new if line.start_with?("#{START_TOKENS[:ProjectSectionToken]}(")
+      inner_block
+    end
+
+    def check_end_token(line, inner_block, inner_block_str)
+      return inner_block unless END_TOKENS.any? { |_, v| line == v }
+
+      inner_block.parse(inner_block_str)
+      nil
+    end
+
+    def parse_header(line)
+      assignment = Assignment.new(line)
+      parts = assignment.value.split(",")
+      return false if parts.empty?
+
+      self.name = parts[0].strip.delete("\"")
+      self.path = parts[1].strip.delete("\"")
+      self.guid = parts[2].strip
+                          .delete("\"")
+                          .delete("{")
+                          .delete("}")
+
+      true
+    end
+
+    public(:parse)
+    public(:to_s)
+    private(:check_start_token)
+    private(:check_end_token)
+    private(:parse_header)
+    private(:guid=)
+    private(:name=)
+    private(:path=)
+  end
+
+  class ProjectSectionBlock < BaseBlock
+    def parse(block_str)
+      nil
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/sln_project/root_block.rb

@@ -0,0 +1,72 @@
+require_relative "project_block"
+require_relative "global_block"
+require_relative "block"
+
+module SlnProject
+  class RootBlock < BaseBlock
+    TOKENS = {
+      VisualStudioVersionToken: "VisualStudioVersion",
+      MinimumVisualStudioVersionToken: "MinimumVisualStudioVersion"
+    }.freeze
+
+    START_TOKENS = {
+      ProjectToken: "Project",
+      GlobalToken: "Global"
+    }.freeze
+
+    END_TOKENS = {
+      ProjectToken: "EndProject",
+      GlobalToken: "EndGlobal"
+    }.freeze
+
+    attr_accessor :visual_studio_version, :min_visual_studio_version, :projects, :global
+
+    def parse(block_str)
+      inner_block = nil
+      inner_block_str = ""
+      content_reader = StringIO.new(block_str)
+
+      content_reader.each_line do |line|
+        trim_line = line.strip
+        inner_block = check_start_token(trim_line, inner_block)
+        inner_block = check_end_token(trim_line, inner_block, inner_block_str)
+
+        inner_block_str += "#{trim_line}\n" unless inner_block.nil?
+        inner_block_str = "" if inner_block.nil?
+      end
+    end
+
+    def check_start_token(line, inner_block)
+      self.visual_studio_version = Assignment.new(line).value if line.start_with?(TOKENS[:VisualStudioVersionToken])
+      self.min_visual_studio_version = Assignment.new(line).value if line.start_with?(TOKENS[:MinimumVisualStudioVersionToken])
+
+      inner_block = ProjectBlock.new if line.start_with?("#{START_TOKENS[:ProjectToken]}(")
+      inner_block = GlobalBlock.new if line.start_with?(START_TOKENS[:GlobalToken])
+
+      inner_block
+    end
+
+    def check_end_token(line, inner_block, inner_block_str)
+      return inner_block unless END_TOKENS.any? { |_, v| line == v }
+
+      inner_block.parse(inner_block_str)
+
+      if line.start_with?(END_TOKENS[:ProjectToken])
+        self.projects = [] if self.projects.nil?
+        self.projects.append(inner_block)
+      elsif line.start_with?(END_TOKENS[:GlobalToken])
+        self.global = inner_block
+      end
+
+      nil
+    end
+
+    public(:parse)
+    private(:check_start_token)
+    private(:check_end_token)
+    private(:visual_studio_version=)
+    private(:min_visual_studio_version=)
+    private(:projects=)
+    private(:global=)
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Sapfire
+    VERSION = "1.0.0"
+  end
+end

data/lib/fastlane/plugin/sapfire.rb

@@ -0,0 +1,16 @@
+require "fastlane/plugin/sapfire/version"
+
+module Fastlane
+  module Sapfire
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::Sapfire.all_classes.each do |current|
+  require current
+end