fastlane-plugin-xamarin 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c9c954bc043fb20a4bfc10381a44b7917af930c26f447b284d3df53df2f884c8
+  data.tar.gz: 0fd7da757596866dcd3b29c29686db1c03508d1f01408db8adf402bb27042c63
+SHA512:
+  metadata.gz: f11755dabf174b1fd73349588429550d297fd8649908c181d2c3174d6cb1b6233b7b60e6f07cb80e88462ed486c58f43c57b46cd74f5fe648abf7721de8dbe9a
+  data.tar.gz: 88ebc39616dfb608555704098ae25d47b49841ca6d59b6c762349df630ecd27bb8023f41e44c8cc070ada469b40e8cd7b718a56d8b6451b0246de3e72ad301dd

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Thomas Charriere <thomas.charriere@swisssign.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# xamarin plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-xamarin)
+
+## Getting Started
+
+WORK IN PROGRESS!
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-xamarin`, add it to your project by running:
+
+```bash
+fastlane add_plugin xamarin
+```
+
+## About xamarin
+
+Build Xamarin Android + iOS projects
+
+**Note to author:** Add a more detailed description about this plugin here. If your plugin contains multiple actions, make sure to mention them here.
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+**Note to author:** Please set up a sample project to make it easy for users to explore what your plugin does. Provide everything that is necessary to try out the plugin in this project (including a sample Xcode/Android project if necessary)
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/xamarin.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/xamarin/version'
+
+module Fastlane
+  module Xamarin
+    # 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::Xamarin.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/xamarin/actions/nuget_action.rb

@@ -0,0 +1,94 @@
+module Fastlane
+  module Actions
+   
+
+    class NugetAction < Action
+      def self.run(params)
+        
+        nuget = params[:nuget] || FastlaneCore::CommandExecutor.which('nuget')
+        mono = FastlaneCore::CommandExecutor.which('mono')
+
+        if nuget.nil?
+            UI.error("Could not find nuget")
+            return
+        end
+
+        if FastlaneCore::Globals.verbose?
+          FastlaneCore::PrintTable.print_values(
+            config: params,
+            title: "Summary of parameters passed"
+          )
+        end        
+        command = Array.new
+
+        command.push(mono)
+        command.push(nuget)
+        command.push(params[:cmd])
+        command.push(params[:project_path])
+
+        exit_status = 0
+        result = FastlaneCore::CommandExecutor.execute(command: command,
+                                        print_command: true,
+                                        print_all: FastlaneCore::Globals.verbose?,
+                                        error: proc do |error_output|
+                                          exit_status = $?.exitstatus
+                                        end)
+
+        if exit_status == 0
+          UI.success("Successfully executed nuget")
+        else
+          UI.error("Uhh ohh - failed executing nuget")
+        end
+        
+
+      end
+
+      def self.description
+        "Nuget"
+      end
+
+      def self.authors
+        ["Thomas Charriere"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Nuget"
+      end
+
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :project_path,
+                                       env_name: "NUGET_SOLUTION",
+                                       description: "The location of a solution or a packages.config",
+                                       optional: false,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :cmd,
+                                       env_name: "NUGET_COMMAND",
+                                       description: "",
+                                       default_value: 'restore',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :nuget,
+                                       env_name: "NUGET_PATH",
+                                       description: "",
+                                       default_value: "Path to `nuget`. Default value is found by using `which nuget`",
+                                       optional: true,
+                                       type: String)
+        ]
+
+      end
+
+      def self.is_supported?(platform)
+        [:android, :ios].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xamarin/actions/xamarin_android_action.rb

@@ -0,0 +1,216 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      XAMARIN_ANDROID_APK = :XAMARIN_ANDROID_APK
+      XAMARIN_ANDROID_APK_SIGNED = :XAMARIN_ANDROID_APK_SIGNED
+    end
+
+    class XamarinAndroidAction < Action
+      def self.run(params)
+        
+        msbuild = params[:msbuild] || FastlaneCore::CommandExecutor.which('msbuild')
+
+        if msbuild.nil?
+            UI.error("Could not find msbuild")
+            return
+        end
+
+        if FastlaneCore::Globals.verbose?
+          FastlaneCore::PrintTable.print_values(
+            config: params,
+            title: "Summary of parameters passed"
+          )
+        end        
+        command = Array.new
+
+        command.push(msbuild)
+        command.push(params[:project])
+        command.push("/t:#{params[:target]}")
+        command.push("/p:Configuration=#{params[:configuration]}") unless params[:configuration].nil?
+        command.push("/p:DefineConstants=#{params[:define_constants]}") unless params[:define_constants].nil?
+        command.push("/p:DebugSymbols=#{params[:debug_symbols]}") unless params[:debug_symbols].nil?
+        command.push("/p:DebugType=#{params[:debug_type]}") unless params[:debug_type].nil?
+        command.push("/p:AndroidSupportedAbis=#{params[:android_supported_abis]}") unless params[:android_supported_abis].nil?
+        command.push("/p:AndroidUseSharedRuntime=#{params[:android_use_sharedruntime]}") unless params[:android_use_sharedruntime].nil?
+        command.push("/p:AotAssemblies=#{params[:android_aot_assemblies]}") unless params[:android_aot_assemblies].nil?
+        command.push("/p:EnableLLVM=#{params[:android_enable_llvm]}") unless params[:android_enable_llvm].nil?
+        command.push("/p:EnableProguard=#{params[:android_enable_proguard]}") unless params[:android_enable_proguard].nil?
+        command.push("/p:AndroidKeyStore=#{params[:android_keystore]}") unless params[:android_keystore].nil?
+        command.push("/p:AndroidSigningKeyAlias=#{params[:android_signing_keystore]}") unless params[:android_signing_keystore].nil?
+        command.push("/p:AndroidSigningKeyPass=#{params[:android_signing_storepass]}") unless params[:android_signing_storepass].nil?
+        command.push("/p:AndroidSigningKeyStore=#{params[:android_signing_keyalias]}") unless params[:android_signing_keyalias].nil?
+        command.push("/p:AndroidSigningStorePass=#{params[:android_signing_keypass]}") unless params[:android_signing_keypass].nil?
+
+        exit_status = 0
+        result = FastlaneCore::CommandExecutor.execute(command: command,
+                                        print_command: true,
+                                        print_all: FastlaneCore::Globals.verbose?,
+                                        error: proc do |error_output|
+                                          exit_status = $?.exitstatus
+                                          UI.error("Wups, invalid")
+                                        end)
+
+        if exit_status == 0
+          UI.success("Successfully executed msbuild")
+
+          Dir.glob(File.join(File.dirname(params[:project]), "/**/bin/#{params[:configuration]}/*.apk")) {|file|
+
+            if file.include? "Signed"
+              Actions.lane_context[SharedValues::XAMARIN_ANDROID_APK_SIGNED] = file
+            else
+              Actions.lane_context[SharedValues::XAMARIN_ANDROID_APK] = file
+            end
+
+          }
+
+          FastlaneCore::PrintTable.print_values(
+            config: Actions.lane_context,
+            title: "Summary of Xamarin Build"
+          )
+
+        else
+          UI.error("Unable to build - see log for more info")
+        end
+        
+
+      end
+
+      def self.description
+        "Build Xamarin Android + iOS projects"
+      end
+
+      def self.authors
+        ["Thomas Charriere"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Build Xamarin Android + iOS projects"
+      end
+
+      def self.output
+        [
+          ['XAMARIN_ANDROID_APK', 'Path to the apk'],
+          ['XAMARIN_ANDROID_APK_SIGNED', 'Path to the signed apk']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :project,
+                                       env_name: "XAMARIN_PROJECT",
+                                       description: "Path to Android Project (.csproj) to compile",
+                                       optional: false,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :target,
+                                       env_name: "XAMARIN_TARGET",
+                                       description: "Specifies the Build Targets: Build, SignAndroidPackage",
+                                       default_value: 'SignAndroidPackage',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                                       env_name: "XAMARIN_CONFIGURATION",
+                                       description: "Specifies the build configuration to use, such as 'Debug' or 'Release'. The Configuration property is used to determine default values for other properties which determine target behavior. Additional configurations may be created within your IDE",
+                                       default_value: 'Release',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :msbuild,
+                                       env_name: "XAMARIN_MSBUILD",
+                                       description: "Path to `msbuild`. Default value is found by using `which msbuild`",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :debug_symbols,
+                                       env_name: "XAMARIN_DEBUGSYMBOLS",
+                                       description: "A boolean value which determines whether the Android package is debuggable, in combination with the `debug_type` option. A debuggable package contains debug symbols, sets the `//application/@android:debuggable` attribute to true, and automatically adds the INTERNET permission so that a debugger can attach to the process. An application is debuggable if `debug_symbols` is True and `debug_type` is either the empty string or Full",
+                                       optional: true,
+                                       type: Fastlane::Boolean),
+
+          FastlaneCore::ConfigItem.new(key: :debug_type,
+                                       env_name: "XAMARIN_DEBUGTYPE",
+                                       description: "Specifies the type of debug symbols to generate as part of the build, which also impacts whether the Application is debuggable. Possible values include: Full, PdbOnly",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :define_constants,
+                                       env_name: "XAMARIN_DEFINECONSTANTS",
+                                       description: "Defines conditional compiler constants",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :android_supported_abis,
+                                       env_name: "XAMARIN_ANDROIDSUPPORTEDABIS",
+                                       description: "A string property that contains a semicolon (;)-delimited list of ABIs which should be included into the .apk: armeabi, armeabi-v7a, x86, arm64-v8a, x86_64",
+                                       optional: true,
+                                       type: String), 
+
+          FastlaneCore::ConfigItem.new(key: :android_use_sharedruntime,
+                                       env_name: "XAMARIN_ANDROIDUSESHAREDRUNTIME",
+                                       description: "A boolean property that is determines whether the shared runtime packages are required in order to run the Application on the target device. Relying on the shared runtime packages allows the Application package to be smaller, speeding up the package creation and deployment process, resulting in a faster build/deploy/debug turnaround cycle. This property should be True for Debug builds, and False for Release projects",
+                                       optional: true,
+                                       type: Fastlane::Boolean), 
+
+          FastlaneCore::ConfigItem.new(key: :android_aot_assemblies,
+                                       env_name: "XAMARIN_ANDROIDAOTASSEMBLIES",
+                                       description: "A boolean property that determines whether or not assemblies will be Ahead-of-Time compiled into native code and included in the .apk",
+                                       optional: true,
+                                       type: Fastlane::Boolean), 
+
+          FastlaneCore::ConfigItem.new(key: :android_enable_llvm,
+                                       env_name: "XAMARIN_ANDROIDENABLELLVM",
+                                       description: "A boolean property that determines whether or not LLVM will be used when Ahead-of-Time compiling assemblies into native code",
+                                       optional: true,
+                                       type: Fastlane::Boolean), 
+
+          FastlaneCore::ConfigItem.new(key: :android_enable_proguard,
+                                       env_name: "XAMARIN_ANDROIDENABLEPROGUARD",
+                                       description: "A boolean property that determines whether or not proguard is run as part of the packaging process to link Java code",
+                                       optional: true,
+                                       type: Fastlane::Boolean), 
+
+          FastlaneCore::ConfigItem.new(key: :android_keystore,
+                                       env_name: "XAMARIN_ANDROIDKEYSTORE",
+                                       description: "A boolean value which indicates whether custom signing information should be used. The default value is False, meaning that the default debug-signing key will be used to sign packages",
+                                       optional: true,
+                                       type: Fastlane::Boolean), 
+
+          FastlaneCore::ConfigItem.new(key: :android_signing_keystore,
+                                       env_name: "XAMARIN_ANDROIDSIGNINGKEYSTORE",
+                                       description: "Specifies the alias for the key in the keystore. This is the keytool -alias value used when creating the keystore",
+                                       optional: true,
+                                       type: String), 
+
+          FastlaneCore::ConfigItem.new(key: :android_signing_storepass,
+                                       env_name: "XAMARIN_ANDROIDSIGNINGSTOREPASS",
+                                       description: "Specifies the password of the keystore file",
+                                       optional: true,
+                                       type: String), 
+
+          FastlaneCore::ConfigItem.new(key: :android_signing_keyalias,
+                                       env_name: "XAMARIN_ANDROIDSINGINGKEYALIAS",
+                                       description: "Specifies the filename of the keystore file created by keytool",
+                                       optional: true,
+                                       type: String), 
+
+          FastlaneCore::ConfigItem.new(key: :android_signing_keypass,
+                                       env_name: "XAMARIN_ANDROIDSIGNINGKEYPASS",
+                                       description: "Specifies the password of the key within the keystore file",
+                                       optional: true,
+                                       type: String)
+        ]
+
+      end
+
+      def self.is_supported?(platform)
+        [:android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xamarin/actions/xamarin_ios_action.rb

@@ -0,0 +1,195 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      XAMARIN_IOS_IPA = :XAMARIN_IOS_IPA
+      XAMARIN_IOS_SYM = :XAMARIN_IOS_SYM
+    end
+
+    class XamarinIosAction < Action
+      def self.run(params)
+
+        msbuild = params[:msbuild] || FastlaneCore::CommandExecutor.which('msbuild')
+
+        if msbuild.nil?
+            UI.error("Could not find msbuild")
+            return
+        end
+
+        if FastlaneCore::Globals.verbose?
+          FastlaneCore::PrintTable.print_values(
+            config: params,
+            title: "Summary of parameters passed"
+          )
+        end        
+        command = Array.new
+
+        command.push(msbuild)
+        command.push(params[:solution])
+        command.push("/t:#{params[:target]}")
+        command.push("/p:Configuration=#{params[:configuration]}") unless params[:configuration].nil?
+        command.push("/p:Platform=#{params[:platform]}") unless params[:platform].nil?
+        command.push("/p:DefineConstants=#{params[:define_constants]}") unless params[:define_constants].nil?
+        command.push("/p:BuildIpa=#{params[:build_ipa]}") unless params[:build_ipa].nil?
+        command.push("/p:IpaPackageDir=#{params[:ipa_package_dir]}") unless params[:ipa_package_dir].nil?
+        command.push("/p:CodesignEntitlements=#{params[:codesign_entitlements]}") unless params[:codesign_entitlements].nil?
+        command.push("/p:IpaIncludeArtwork=#{params[:include_itunes_artwork]}") unless params[:include_itunes_artwork].nil?
+        command.push("/p:CodesignKey=#{params[:codesign_key]}") unless params[:codesign_key].nil?
+        command.push("/p:CodesignProvision=#{params[:codesign_provision]}") unless params[:codesign_provision].nil?
+
+        exit_status = 0
+        result = FastlaneCore::CommandExecutor.execute(command: command,
+                                        print_command: true,
+                                        print_all: FastlaneCore::Globals.verbose?,
+                                        error: proc do |error_output|
+                                          exit_status = $?.exitstatus
+                                          UI.error("Wups, invalid")
+                                        end)
+
+        if exit_status == 0
+          UI.success("Successfully executed msbuild")
+
+          if params[:ipa_package_dir].nil?
+
+          end
+
+          Dir.glob(File.join(File.dirname(params[:solution]), "/**/bin/#{params[:platform]}/#{params[:configuration]}/*.ipa")) {|file|
+
+            Actions.lane_context[SharedValues::XAMARIN_IOS_IPA] = file
+            Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] = file
+          }
+
+          Dir.glob(File.join(File.dirname(params[:solution]), "/**/bin/#{params[:platform]}/#{params[:configuration]}/*.dSYM")) {|file|
+
+            zipfile = file + ".zip"
+
+            File.delete(zipfile) if File.exist?(zipfile)
+
+            Actions::ZipAction.run(path: file, output_path:  zipfile)
+            Actions.lane_context[SharedValues::XAMARIN_IOS_SYM] = zipfile
+            Actions.lane_context[SharedValues::DSYM_OUTPUT_PATH] = zipfile
+
+          }
+
+          FastlaneCore::PrintTable.print_values(
+            config: Actions.lane_context,
+            title: "Summary of Xamarin Build"
+          )
+
+        else
+          UI.error("Unable to build - see log for more info")
+        end
+        
+
+      end
+
+      def self.description
+        "Build Xamarin Android + iOS projects"
+      end
+
+      def self.authors
+        ["Thomas Charriere"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Build Xamarin Android + iOS projects"
+      end
+
+      def self.output
+        [
+          ['XAMARIN_IOS_IPA', 'Path to the ipa'],
+          ['XAMARIN_IOS_SYM', 'Path to the dysm of the ipa']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :solution,
+                                       env_name: "XAMARIN_SOLUTION",
+                                       description: "Path to Solution to compile",
+                                       optional: false,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :target,
+                                       env_name: "XAMARIN_TARGET",
+                                       description: "Specifies the Build Targets: Build",
+                                       default_value: 'Build',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                                       env_name: "XAMARIN_CONFIGURATION",
+                                       description: "Specifies the build configuration to use, such as 'Debug' or 'Release'. The Configuration property is used to determine default values for other properties which determine target behavior. Additional configurations may be created within your IDE",
+                                       default_value: 'Release',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "XAMARIN_PLATFORM",
+                                       description: "Specifies the platform configuration to use, such as 'iPhone' or 'iPhoneSimulator'. The Platform property is used to determine default values for other properties which determine target behavior. Additional configurations may be created within your IDE",
+                                       default_value: 'iPhone',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :define_constants,
+                                       env_name: "XAMARIN_DEFINECONSTANTS",
+                                       description: "Defines conditional compiler constants",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :msbuild,
+                                       env_name: "XAMARIN_MSBUILD",
+                                       description: "Path to `msbuild`. Default value is found by using `which msbuild`",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :build_ipa,
+                                       env_name: "XAMARIN_BUILDIPA",
+                                       description: "A boolean value which determines whether the ipa should be built",
+                                       default_value: true,
+                                       optional: true,
+                                       type: Fastlane::Boolean),
+
+          FastlaneCore::ConfigItem.new(key: :ipa_package_dir,
+                                       env_name: "XAMARIN_IPAPACKAGEDIR",
+                                       description: "Set custom IPA directory",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :codesign_entitlements,
+                                       env_name: "XAMARIN_CODESIGNENTITLEMENTS",
+                                       description: "",
+                                       optional: true,
+                                       type: Fastlane::Boolean), 
+
+          FastlaneCore::ConfigItem.new(key: :include_itunes_artwork,
+                                       env_name: "XAMARIN_INCLUDEITUNESARTWORK",
+                                       description: "Includes ITunesArtwork images",
+                                       optional: true,
+                                       type: Fastlane::Boolean), 
+
+          FastlaneCore::ConfigItem.new(key: :codesign_key,
+                                       env_name: "XAMARIN_CODESIGNKEY",
+                                       description: "A signing identity",
+                                       optional: true,  
+                                       type: String), 
+
+          FastlaneCore::ConfigItem.new(key: :codesign_provision,
+                                       env_name: "XAMARIN_CODESIGNPROVISION",
+                                       description: "Id/Name of the provisioning profile",
+                                       optional: true,
+                                       type: String)
+        ]
+
+      end
+
+      def self.is_supported?(platform)
+        [:ios].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xamarin/helper/xamarin_helper.rb

@@ -0,0 +1,10 @@
+module Fastlane
+  module Helper
+    class XamarinHelper
+      # class methods that you define here become available in your action
+      # as `Helper::XamarinHelper.your_method`
+      #
+      
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Xamarin
+    VERSION = "0.2.0"
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-xamarin
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Thomas Charriere
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.28.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.28.3
+description: 
+email: git@a.charri.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/xamarin.rb
+- lib/fastlane/plugin/xamarin/actions/nuget_action.rb
+- lib/fastlane/plugin/xamarin/actions/xamarin_android_action.rb
+- lib/fastlane/plugin/xamarin/actions/xamarin_ios_action.rb
+- lib/fastlane/plugin/xamarin/helper/xamarin_helper.rb
+- lib/fastlane/plugin/xamarin/version.rb
+homepage: https://github.com/charri/fastlane-plugin-xamarin
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Build Xamarin Android + iOS projects
+test_files: []