fastlane 2.50.0.beta.20170731010002 → 2.50.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 609d266f5d04fe6eb726a8c2c2c9e5fd8aa33929
-  data.tar.gz: c028dc002f5ffa051910db3e69769a2ab7ff4a52
+  metadata.gz: 4bcea6a1f68d82ce8f7490a64d9bb4734aba11cc
+  data.tar.gz: a6f24ff351403a7d87e9b614b9b0e5546542d18b
 SHA512:
-  metadata.gz: 192fe79a86c1dc4a5062800f676df4c6783de16cf852bebcc703558c0ffe0cce7930a26ac880aaa80bb52902e2c7dba06e393e9fba80867a25b46fca9b1b1f0b
-  data.tar.gz: b30f38600568d36ca896d8080317afaac20121a5a815240c63b8523f79f2078ee94133f47ffad3196ce1b3a2bcea0498a9536ca4d7225b245b511b9373f1a12c
+  metadata.gz: a18267f30b1f5335b969f9ebc3687d05dd1a2ddbb4cd22edc8c730d53e77bf36efd99ebeb023fa601a853220c5becc66218983fc3b9ad2a57b9251906417be81
+  data.tar.gz: 56aa6d2e0ee98bf8bccf0b0be9e496e68f53b26219ca464ad7b1d79446a7f3b236c7716e2b6bda47ce55a96c98262f2964fa0cd55316e278af57adf998aa3fe6

data/fastlane/lib/assets/Actions.md.erb

@@ -22,10 +22,14 @@ For _fastlane_ plugins, check out the [available plugins](https://docs.fastlane.
 <%- end -%>
 - [Plugins](https://docs.fastlane.tools/plugins/available-plugins)
 
-
 <%- @categories.each do |category, actions| %>
 # <%= category %>
-  <%- actions.sort.to_h.each do |_number_of_launches, action| -%>
+
+<div class='category-actions'>
+
+<%- actions.sort.to_h.each do |_number_of_launches, action| -%>
+
+<div class='action'>
 
 ### <%= action.action_name %>
 
@@ -51,8 +55,8 @@ Returns | <%= action.return_value %>
 ```ruby
 <%= current_sample.gsub("          ", "") %>
 ```
-<% end %>
-<% end %>
+<% end %><%# End of action.example_code... %>
+<% end %><%# End of if %>
 </details>
 
 <% if action.available_options && action.available_options.first.kind_of?(FastlaneCore::ConfigItem) %>
@@ -67,9 +71,11 @@ Key | Description
   `<%= config_item.key %>` | <%= config_item.description %>
 <%- end %>
 </details>
-<% end %>
+</div>
 
+<% end %><%# End of action.available_options... %>
 
+  <%- end %><%# End of actions.sort... %>
+</div>
 
-  <%- end %>
-<%- end %>
+<%- end %><%# End of categories.each %>

data/fastlane/lib/fastlane/actions/commit_github_file.rb

@@ -0,0 +1,178 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      COMMIT_GITHUB_FILE_HTML_LINK = :COMMIT_GITHUB_FILE_HTML_LINK
+      COMMIT_GITHUB_FILE_SHA = :COMMIT_GITHUB_FILE_SHA
+      COMMIT_GITHUB_FILE_JSON = :COMMIT_GITHUB_FILE_JSON
+    end
+
+    class CommitGithubFileAction < Action
+      def self.run(params)
+        repo_name = params[:repository_name]
+        branch = params[:branch] ||= 'master'
+        commit_message = params[:message]
+
+        file_path = params[:path]
+        file_name = File.basename(file_path)
+        expanded_file_path = File.expand_path(file_path)
+
+        UI.important("Creating commit on #{repo_name} on branch \"#{branch}\" for file \"#{file_path}\"")
+
+        api_file_path = file_path
+        api_file_path = "/#{api_file_path}" unless api_file_path.start_with? '/'
+        api_file_path = api_file_path[0..-2] if api_file_path.end_with? '/'
+
+        payload = {
+          path: api_file_path,
+          message: commit_message || "Updated : #{file_name}",
+          content: Base64.encode64(File.open(expanded_file_path).read),
+          branch: branch
+        }
+
+        UI.message("Committing #{api_file_path}")
+        GithubApiAction.run({
+          server_url: params[:server_url],
+          api_token: params[:api_token],
+          secure: params[:secure],
+          http_method: "PUT",
+          path: File.join("repos", params[:repository_name], "contents", api_file_path),
+          body: payload,
+          error_handlers: {
+            422 => proc do |result|
+              json = result[:json]
+              UI.error(json || result[:body])
+              error = if json['message'] == "Invalid request.\n\n\"sha\" wasn't supplied."
+                        "File already exists - please remove from repo before uploading or rename this upload"
+                      else
+                        "Uprocessable error"
+                      end
+              UI.user_error!(error)
+            end
+          }
+        }) do |result|
+          UI.success("Successfully commited file to GitHub")
+          json = result[:json]
+          html_url = json['commit']['html_url']
+          download_url = json['content']['download_url']
+          commit_sha = json['commit']['sha']
+
+          UI.important("Commit: \"#{html_url}\"")
+          UI.important("SHA: \"#{commit_sha}\"")
+          UI.important("Download at: \"#{download_url}\"")
+
+          Actions.lane_context[SharedValues::COMMIT_GITHUB_FILE_HTML_LINK] = html_url
+          Actions.lane_context[SharedValues::COMMIT_GITHUB_FILE_SHA] = commit_sha
+          Actions.lane_context[SharedValues::COMMIT_GITHUB_FILE_JSON] = json
+        end
+
+        Actions.lane_context[SharedValues::COMMIT_GITHUB_FILE_JSON]
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "This will commit a file directly on GitHub via the API"
+      end
+
+      def self.details
+        "Commits a file directly to GitHub. You must provide your GitHub Personal token
+        (get one from https://github.com/settings/tokens/new), the repository name and the relative file path from the root git project.
+        Out parameters provide the commit sha created, which can be used for later usage for examples such as releases, the direct download link and the full response JSON.
+        Documentation: https://developer.github.com/v3/repos/contents/#create-a-file"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository_name,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_REPOSITORY_NAME",
+                                       description: "The path to your repo, e.g. 'fastlane/fastlane'",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please only pass the path, e.g. 'fastlane/fastlane'") if value.include? "github.com"
+                                         UI.user_error!("Please only pass the path, e.g. 'fastlane/fastlane'") if value.split('/').count != 2
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :server_url,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_SERVER_URL",
+                                       description: "The server url. e.g. 'https://your.internal.github.host/api/v3' (Default: 'https://api.github.com')",
+                                       default_value: "https://api.github.com",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please include the protocol in the server url, e.g. https://your.github.server/api/v3") unless value.include? "//"
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_API_TOKEN",
+                                       description: "Personal API Token for GitHub - generate one at https://github.com/settings/tokens",
+                                       sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["GITHUB_API_TOKEN"],
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :branch,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_BRANCH",
+                                       description: "The branch that the file should be committed on (default: master)",
+                                       default_value: 'master',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: 'FL_COMMIT_GITHUB_FILE_PATH',
+                                       description: 'The relative path to your file from project root e.g. assets/my_app.xcarchive',
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         value = File.expand_path(value)
+                                         UI.user_error!("File not found at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_MESSAGE",
+                                       description: "The commit message. Defaults to the file name",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :secure,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_SECURE",
+                                       description: "Optionally disable secure requests (ssl_verify_peer)",
+                                       is_string: false,
+                                       default_value: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['COMMIT_GITHUB_FILE_HTML_LINK', 'Link to your committed file'],
+          ['COMMIT_GITHUB_FILE_SHA', 'Commit SHA generated'],
+          ['COMMIT_GITHUB_FILE_JSON', 'The whole commit JSON object response']
+        ]
+      end
+
+      def self.return_value
+        [
+          "A hash containing all relevant information for this commit",
+          "Access things like 'html_url', 'sha', 'message'"
+        ].join("\n")
+      end
+
+      def self.authors
+        ["tommeier"]
+      end
+
+      def self.example_code
+        [
+          'response = commit_github_file(
+            repository_name: "fastlane/fastlane",
+            server_url: "https://api.github.com",
+            api_token: ENV["GITHUB_TOKEN"],
+            message: "Add my new file",
+            branch: "master",
+            path: "assets/my_new_file.xcarchive"
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/create_pull_request.rb

@@ -6,34 +6,35 @@ module Fastlane
 
     class CreatePullRequestAction < Action
       def self.run(params)
-        require 'excon'
-        require 'base64'
-
         UI.message("Creating new pull request from '#{params[:head]}' to branch '#{params[:base]}' of '#{params[:repo]}'")
 
-        url = "#{params[:api_url]}/repos/#{params[:repo]}/pulls"
-        headers = { 'User-Agent' => 'fastlane-create_pull_request' }
-        headers['Authorization'] = "Basic #{Base64.strict_encode64(params[:api_token])}" if params[:api_token]
-
-        data = {
+        payload = {
           'title' => params[:title],
           'head' => params[:head],
           'base' => params[:base]
         }
+        payload['body'] = params[:body] if params[:body]
 
-        data['body'] = params[:body] if params[:body]
-
-        response = Excon.post(url, headers: headers, body: data.to_json)
-
-        if response[:status] == 201
-          body = JSON.parse(response.body)
-          number = body['number']
-          html_url = body['html_url']
+        GithubApiAction.run(
+          server_url: params[:api_url],
+          api_token: params[:api_token],
+          http_method: 'POST',
+          path: "repos/#{params[:repo]}/pulls",
+          body: payload,
+          error_handlers: {
+            '*' => proc do |result|
+              UI.error("GitHub responded with #{result[:status]}: #{result[:body]}")
+              return nil
+            end
+          }
+        ) do |result|
+          json = result[:json]
+          number = json['number']
+          html_url = json['html_url']
           UI.success("Successfully created pull request ##{number}. You can see it at '#{html_url}'")
 
           Actions.lane_context[SharedValues::CREATE_PULL_REQUEST_HTML_URL] = html_url
-        elsif response[:status] != 200
-          UI.error("GitHub responded with #{response[:status]}: #{response[:body]}")
+          return json
         end
       end
 
@@ -91,13 +92,17 @@ module Fastlane
       end
 
       def self.author
-        ["seei"]
+        ["seei", "tommeier"]
       end
 
       def self.is_supported?(platform)
         return true
       end
 
+      def self.return_value
+        "The parsed JSON when successful"
+      end
+
       def self.example_code
         [
           'create_pull_request(

data/fastlane/lib/fastlane/actions/get_github_release.rb

@@ -7,43 +7,38 @@ module Fastlane
     class GetGithubReleaseAction < Action
       def self.run(params)
         UI.message("Getting release on GitHub (#{params[:server_url]}/#{params[:url]}: #{params[:version]})")
-        require 'excon'
-        require 'base64'
 
-        server_url = params[:server_url]
-        server_url = server_url[0..-2] if server_url.end_with? '/'
-
-        headers = { 'User-Agent' => 'fastlane-get_github_release' }
-        headers['Authorization'] = "Basic #{Base64.strict_encode64(params[:api_token])}" if params[:api_token]
-
-        # To still get the data when a repo has been moved
-        middlewares = Excon.defaults[:middlewares] + [Excon::Middleware::RedirectFollower]
-        response = Excon.get("#{server_url}/repos/#{params[:url]}/releases", headers: headers, middlewares: middlewares)
-
-        case response[:status]
-        when 404
-          UI.error("Repository #{params[:url]} cannot be found, please double check its name and that you provided a valid API token (if it's a private repository).")
-          return nil
-        when 401
-          UI.error("You are not authorized to access #{params[:url]}, please make sure you provided a valid API token.")
-          return nil
-        else
-          if response[:status] != 200
-            UI.error("GitHub responded with #{response[:status]}:#{response[:body]}")
-            return nil
+        GithubApiAction.run(
+          server_url: params[:server_url],
+          api_token: params[:api_token],
+          http_method: 'GET',
+          path: "repos/#{params[:url]}/releases",
+          error_handlers: {
+            404 => proc do |result|
+              UI.error("Repository #{params[:url]} cannot be found, please double check its name and that you provided a valid API token (if it's a private repository).")
+              return nil
+            end,
+            401 => proc do |result|
+              UI.error("You are not authorized to access #{params[:url]}, please make sure you provided a valid API token.")
+              return nil
+            end,
+            '*' => proc do |result|
+              UI.error("GitHub responded with #{result[:status]}:#{result[:body]}")
+              return nil
+            end
+          }
+        ) do |result|
+          json = result[:json]
+          json.each do |current|
+            next unless current['tag_name'] == params[:version]
+
+            # Found it
+            Actions.lane_context[SharedValues::GET_GITHUB_RELEASE_INFO] = current
+            UI.message("Version is already live on GitHub.com 🚁")
+            return current
           end
         end
 
-        result = JSON.parse(response.body)
-        result.each do |current|
-          next unless current['tag_name'] == params[:version]
-
-          # Found it
-          Actions.lane_context[SharedValues::GET_GITHUB_RELEASE_INFO] = current
-          UI.message("Version is already live on GitHub.com 🚁")
-          return current
-        end
-
         UI.important("Couldn't find GitHub release #{params[:version]}")
         return nil
       end
@@ -128,15 +123,15 @@ module Fastlane
                                        env_name: "FL_GET_GITHUB_RELEASE_VERSION",
                                        description: "The version tag of the release to check"),
           FastlaneCore::ConfigItem.new(key: :api_token,
-                             env_name: "FL_GITHUB_RELEASE_API_TOKEN",
-                             sensitive: true,
-                             description: "GitHub Personal Token (required for private repositories)",
-                             optional: true)
+                                       env_name: "FL_GITHUB_RELEASE_API_TOKEN",
+                                       sensitive: true,
+                                       description: "GitHub Personal Token (required for private repositories)",
+                                       optional: true)
         ]
       end
 
       def self.authors
-        ["KrauseFx", "czechboy0", "jaleksynas"]
+        ["KrauseFx", "czechboy0", "jaleksynas", "tommeier"]
       end
 
       def self.is_supported?(platform)

data/fastlane/lib/fastlane/actions/github_api.rb

@@ -0,0 +1,258 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      GITHUB_API_STATUS_CODE = :GITHUB_API_STATUS_CODE
+      GITHUB_API_RESPONSE = :GITHUB_API_RESPONSE
+      GITHUB_API_JSON = :GITHUB_API_JSON
+    end
+
+    class GithubApiAction < Action
+      class << self
+        def run(params)
+          require 'json'
+
+          http_method = (params[:http_method] || 'GET').to_s.upcase
+          url = construct_url(params[:server_url], params[:path], params[:url])
+          headers = construct_headers(params[:api_token], params[:headers])
+          payload = construct_body(params[:body], params[:raw_body])
+          error_handlers = params[:error_handlers] || {}
+          secure = params[:secure] || true
+
+          response = call_endpoint(
+            url,
+            http_method,
+            headers,
+            payload,
+            secure
+          )
+
+          status_code = response[:status]
+          result = {
+            status: status_code,
+            body: response.body || "",
+            json: parse_json(response.body) || {}
+          }
+
+          if status_code.between?(200, 299)
+            UI.verbose("Response:")
+            UI.verbose(response.body)
+            UI.verbose("---")
+            yield(result) if block_given?
+          else
+            handled_error = error_handlers[status_code] || error_handlers['*']
+            if handled_error
+              handled_error.call(result)
+            else
+              UI.error("---")
+              UI.error("Request failed:\n#{http_method}: #{url}")
+              UI.error("Headers:\n#{headers}")
+              UI.error("---")
+              UI.error("Response:")
+              UI.error(response.body)
+              UI.user_error!("GitHub responded with #{status_code}\n---\n#{response.body}")
+            end
+          end
+
+          Actions.lane_context[SharedValues::GITHUB_API_STATUS_CODE] = result[:status]
+          Actions.lane_context[SharedValues::GITHUB_API_RESPONSE] = result[:body]
+          Actions.lane_context[SharedValues::GITHUB_API_JSON] = result[:json]
+
+          return result
+        end
+
+        #####################################################
+        # @!group Documentation
+        #####################################################
+
+        def description
+          "Call a GitHub API endpoint and get the resulting JSON response"
+        end
+
+        def details
+          "Calls any GitHub API endpoint. You must provide your GitHub Personal token (get one from https://github.com/settings/tokens/new).
+          Out parameters provide the status code and the full response JSON if valid, otherwise the raw response body.
+          Documentation: https://developer.github.com/v3"
+        end
+
+        def available_options
+          [
+            FastlaneCore::ConfigItem.new(key: :server_url,
+                                         env_name: "FL_GITHUB_API_SERVER_URL",
+                                         description: "The server url. e.g. 'https://your.internal.github.host/api/v3' (Default: 'https://api.github.com')",
+                                         default_value: "https://api.github.com",
+                                         optional: true,
+                                         verify_block: proc do |value|
+                                           UI.user_error!("Please include the protocol in the server url, e.g. https://your.github.server/api/v3") unless value.include? "//"
+                                         end),
+            FastlaneCore::ConfigItem.new(key: :api_token,
+                                         env_name: "FL_GITHUB_API_TOKEN",
+                                         description: "Personal API Token for GitHub - generate one at https://github.com/settings/tokens",
+                                         sensitive: true,
+                                         is_string: true,
+                                         default_value: ENV["GITHUB_API_TOKEN"],
+                                         optional: false),
+            FastlaneCore::ConfigItem.new(key: :http_method,
+                                         env_name: "FL_GITHUB_API_HTTP_METHOD",
+                                         description: "The HTTP method. e.g. GET / POST",
+                                         default_value: "GET",
+                                         optional: true,
+                                         verify_block: proc do |value|
+                                           unless %w(GET POST PUT DELETE HEAD CONNECT).include?(value.to_s.upcase)
+                                             UI.user_error!("Unrecognised HTTP method")
+                                           end
+                                         end),
+            FastlaneCore::ConfigItem.new(key: :body,
+                                         env_name: "FL_GITHUB_API_REQUEST_BODY",
+                                         description: "The request body in JSON or hash format",
+                                         is_string: false,
+                                         default_value: {},
+                                         optional: true),
+            FastlaneCore::ConfigItem.new(key: :raw_body,
+                                         env_name: "FL_GITHUB_API_REQUEST_RAW_BODY",
+                                         description: "The request body taken vertabim instead of as JSON, useful for file uploads",
+                                         is_string: true,
+                                         optional: true),
+            FastlaneCore::ConfigItem.new(key: :path,
+                                         env_name: "FL_GITHUB_API_PATH",
+                                         description: "The endpoint path. e.g. '/repos/:owner/:repo/readme'",
+                                         optional: true),
+            FastlaneCore::ConfigItem.new(key: :url,
+                                         env_name: "FL_GITHUB_API_URL",
+                                         description: "The complete full url - used instead of path. e.g. 'https://uploads.github.com/repos/fastlane...'",
+                                         optional: true,
+                                         verify_block: proc do |value|
+                                           UI.user_error!("Please include the protocol in the url, e.g. https://uploads.github.com") unless value.include? "//"
+                                         end),
+            FastlaneCore::ConfigItem.new(key: :error_handlers,
+                                         description: "Optional error handling hash based on status code, or pass '*' to handle all errors",
+                                         is_string: false,
+                                         default_value: {},
+                                         optional: true),
+            FastlaneCore::ConfigItem.new(key: :headers,
+                                         description: "Optional headers to apply",
+                                         is_string: false,
+                                         default_value: {},
+                                         optional: true),
+            FastlaneCore::ConfigItem.new(key: :secure,
+                                         env_name: "FL_GITHUB_API_SECURE",
+                                         description: "Optionally disable secure requests (ssl_verify_peer)",
+                                         is_string: false,
+                                         default_value: true,
+                                         optional: true)
+          ]
+        end
+
+        def output
+          [
+            ['GITHUB_API_STATUS_CODE', 'The status code returned from the request'],
+            ['GITHUB_API_RESPONSE', 'The full response body'],
+            ['GITHUB_API_JSON', 'The parsed json returned from GitHub']
+          ]
+        end
+
+        def return_value
+          "A hash including the HTTP status code (:status), the response body (:body), and if valid JSON has been returned the parsed JSON (:json)."
+        end
+
+        def authors
+          ["tommeier"]
+        end
+
+        def example_code
+          [
+            'result = github_api(
+            server_url: "https://api.github.com",
+            api_token: ENV["GITHUB_TOKEN"],
+            http_method: "GET",
+            path: "/repos/:owner/:repo/readme",
+            body: { ref: "master" }
+          )',
+            '# Alternatively call directly with optional error handling or block usage
+            GithubApiAction.run(
+              server_url: "https://api.github.com",
+              api_token: ENV["GITHUB_TOKEN"],
+              http_method: "GET",
+              path: "/repos/:owner/:repo/readme",
+              error_handlers: {
+                404 => proc do |result|
+                  UI.message("Something went wrong - I couldn\'t find it...")
+                end,
+                \'*\' => proc do |result|
+                  UI.message("Handle all error codes other than 404")
+                end
+              }
+            ) do |result|
+              UI.message("JSON returned: #{result[:json]}")
+            end
+          '
+          ]
+        end
+
+        def is_supported?(platform)
+          true
+        end
+
+        def category
+          :source_control
+        end
+
+        private
+
+        def construct_headers(api_token, overrides)
+          require 'base64'
+          headers = { 'User-Agent' => 'fastlane-github_api' }
+          headers['Authorization'] = "Basic #{Base64.strict_encode64(api_token)}" if api_token
+          headers.merge(overrides || {})
+        end
+
+        def construct_url(server_url, path, url)
+          UI.user_error!("Please provide server URL, eg: https://api.github.com") unless server_url
+
+          return_url = path ? File.join(server_url, path) : url
+
+          UI.user_error!("Please provide either 'path' or full 'url' for GitHub API endpoint") unless return_url
+
+          return_url
+        end
+
+        def construct_body(body, raw_body)
+          body ||= {}
+
+          if raw_body
+            raw_body
+          elsif body.kind_of?(Hash)
+            body.to_json
+          else
+            UI.user_error!("Please provide valid JSON, or a hash as request body") unless parse_json(body)
+            body
+          end
+        end
+
+        def parse_json(value)
+          JSON.parse(value)
+        rescue JSON::ParserError
+          nil
+        end
+
+        def call_endpoint(url, http_method, headers, body, secure)
+          require 'excon'
+
+          Excon.defaults[:ssl_verify_peer] = secure
+          middlewares = Excon.defaults[:middlewares] + [Excon::Middleware::RedirectFollower] # allow redirect in case of repo renames
+
+          UI.verbose("#{http_method} : #{url}")
+
+          connection = Excon.new(url)
+          connection.request(
+            method: http_method,
+            headers: headers,
+            middlewares: middlewares,
+            body: body,
+            debug_request: FastlaneCore::Globals.verbose?,
+            debug_response: FastlaneCore::Globals.verbose?
+          )
+        end
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/install_xcode_plugin.rb

@@ -4,11 +4,24 @@ module Fastlane
       def self.run(params)
         require 'fileutils'
 
-        unless params[:github].nil?
-          github_api_url = params[:github].sub('https://github.com', 'https://api.github.com/repos')
-          release = self.fetch_json(github_api_url + '/releases/latest')
-          return if release.nil?
-          params[:url] = release['assets'][0]['browser_download_url']
+        if params[:github]
+          base_api_url = params[:github].sub('https://github.com', 'https://api.github.com/repos')
+
+          GithubApiAction.run(
+            url: File.join(base_api_url, 'releases/latest'),
+            http_method: 'GET',
+            error_handlers: {
+              404 => proc do |result|
+                UI.error("No latest release found for the specified GitHub repository")
+              end,
+              '*' => proc do |result|
+                UI.error("GitHub responded with #{response[:status]}:#{response[:body]}")
+              end
+            }
+          ) do |result|
+            return nil if result[:json].nil?
+            params[:url] = result[:json]['assets'][0]['browser_download_url']
+          end
         end
 
         zip_path = File.join(Dir.tmpdir, 'plugin.zip')
@@ -21,24 +34,6 @@ module Fastlane
         UI.message("Please restart Xcode to use the newly installed plugin")
       end
 
-      def self.fetch_json(url)
-        require 'excon'
-        require 'json'
-
-        response = Excon.get(url)
-
-        if response[:status] != 200
-          if response[:status] == 404
-            UI.error("No latest release found for the specified GitHub repository")
-          else
-            UI.error("GitHub responded with #{response[:status]}:#{response[:body]}")
-          end
-          return nil
-        end
-
-        JSON.parse(response.body)
-      end
-
       #####################################################
       # @!group Documentation
       #####################################################
@@ -74,7 +69,7 @@ module Fastlane
       end
 
       def self.authors
-        ["NeoNachoSoto"]
+        ["NeoNachoSoto", "tommeier"]
       end
 
       def self.is_supported?(platform)

data/fastlane/lib/fastlane/actions/set_github_release.rb

@@ -11,70 +11,83 @@ module Fastlane
         UI.important("Creating release of #{params[:repository_name]} on tag \"#{params[:tag_name]}\" with name \"#{params[:name]}\".")
         UI.important("Will also upload assets #{params[:upload_assets]}.") if params[:upload_assets]
 
-        require 'json'
-        body_obj = {
+        repo_name = params[:repository_name]
+        api_token = params[:api_token]
+        server_url = params[:server_url]
+        tag_name = params[:tag_name]
+
+        payload = {
           'tag_name' => params[:tag_name],
           'name' => params[:name],
           'body' => params[:description],
           'draft' => !!params[:is_draft],
           'prerelease' => !!params[:is_prerelease]
         }
-        body_obj['target_commitish'] = params[:commitish] if params[:commitish]
-        body = body_obj.to_json
-
-        repo_name = params[:repository_name]
-        api_token = params[:api_token]
-        server_url = params[:server_url]
-        server_url = server_url[0..-2] if server_url.end_with? '/'
+        payload['target_commitish'] = params[:commitish] if params[:commitish]
 
-        # create the release
-        response = call_releases_endpoint("post", server_url, repo_name, "/releases", api_token, body)
+        GithubApiAction.run(
+          server_url: server_url,
+          api_token: api_token,
+          http_method: 'POST',
+          path: "repos/#{repo_name}/releases",
+          body: payload,
+          error_handlers: {
+            422 => proc do |result|
+              UI.error(result[:body])
+              UI.error("Release on tag #{tag_name} already exists!")
+              return nil
+            end,
+            404 => proc do |result|
+              UI.error(result[:body])
+              UI.user_error!("Repository #{repo_name} cannot be found, please double check its name and that you provided a valid API token (GITHUB_API_TOKEN)")
+            end,
+            401 => proc do |result|
+              UI.error(result[:body])
+              UI.user_error!("You are not authorized to access #{repo_name}, please make sure you provided a valid API token (GITHUB_API_TOKEN)")
+            end,
+            '*' => proc do |result|
+              UI.error("GitHub responded with #{result[:status]}:#{result[:body]}")
+              return nil
+            end
+          }
+        ) do |result|
+          json = result[:json]
+          html_url = json['html_url']
+          release_id = json['id']
 
-        case response[:status]
-        when 201
-          UI.success("Successfully created release at tag \"#{params[:tag_name]}\" on GitHub")
-          body = JSON.parse(response.body)
-          html_url = body['html_url']
-          release_id = body['id']
+          UI.success("Successfully created release at tag \"#{tag_name}\" on GitHub")
           UI.important("See release at \"#{html_url}\"")
+
           Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_HTML_LINK] = html_url
           Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_RELEASE_ID] = release_id
-          Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_JSON] = body
+          Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_JSON] = json
 
           assets = params[:upload_assets]
           if assets && assets.count > 0
             # upload assets
-            self.upload_assets(assets, body['upload_url'], api_token)
+            self.upload_assets(assets, json['upload_url'], api_token)
 
             # fetch the release again, so that it contains the uploaded assets
-            get_response = self.call_releases_endpoint("get", server_url, repo_name, "/releases/#{release_id}", api_token, nil)
-            if get_response[:status] != 200
-              UI.error("GitHub responded with #{response[:status]}:#{response[:body]}")
-              UI.user_error!("Failed to fetch the newly created release, but it *has been created* successfully.")
+            GithubApiAction.run(
+              server_url: server_url,
+              api_token: api_token,
+              http_method: 'GET',
+              path: "repos/#{repo_name}/releases/#{release_id}",
+              error_handlers: {
+                '*' => proc do |get_result|
+                  UI.error("GitHub responded with #{get_result[:status]}:#{get_result[:body]}")
+                  UI.user_error!("Failed to fetch the newly created release, but it *has been created* successfully.")
+                end
+              }
+            ) do |get_result|
+              Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_JSON] = get_result[:json]
+              UI.success("Successfully uploaded assets #{assets} to release \"#{html_url}\"")
+              return get_result[:json]
             end
-
-            get_body = JSON.parse(get_response.body)
-            Actions.lane_context[SharedValues::SET_GITHUB_RELEASE_JSON] = get_body
-            UI.success("Successfully uploaded assets #{assets} to release \"#{html_url}\"")
-            return get_body
           else
-            return body
-          end
-        when 422
-          UI.error(response.body)
-          UI.error("Release on tag #{params[:tag_name]} already exists!")
-        when 404
-          UI.error(response.body)
-          UI.user_error!("Repository #{params[:repository_name]} cannot be found, please double check its name and that you provided a valid API token (GITHUB_API_TOKEN)")
-        when 401
-          UI.error(response.body)
-          UI.user_error!("You are not authorized to access #{params[:repository_name]}, please make sure you provided a valid API token (GITHUB_API_TOKEN)")
-        else
-          if response[:status] != 200
-            UI.error("GitHub responded with #{response[:status]}:#{response[:body]}")
+            return json || result[:body]
           end
         end
-        return nil
       end
 
       def self.upload_assets(assets, upload_url_template, api_token)
@@ -90,65 +103,41 @@ module Fastlane
         # check that the asset even exists
         UI.user_error!("Asset #{absolute_path} doesn't exist") unless File.exist?(absolute_path)
 
-        name = File.basename(absolute_path)
-        response = nil
         if File.directory?(absolute_path)
           Dir.mktmpdir do |dir|
             tmpzip = File.join(dir, File.basename(absolute_path) + '.zip')
-            name = File.basename(tmpzip)
             sh "cd \"#{File.dirname(absolute_path)}\"; zip -r --symlinks \"#{tmpzip}\" \"#{File.basename(absolute_path)}\" 2>&1 >/dev/null"
-            response = self.upload_file(tmpzip, upload_url_template, api_token)
+            self.upload_file(tmpzip, upload_url_template, api_token)
           end
         else
-          response = self.upload_file(absolute_path, upload_url_template, api_token)
+          self.upload_file(absolute_path, upload_url_template, api_token)
         end
-        return response
       end
 
       def self.upload_file(file, url_template, api_token)
         require 'addressable/template'
-        name = File.basename(file)
-        expanded_url = Addressable::Template.new(url_template).expand(name: name).to_s
-        headers = self.headers(api_token)
-        headers['Content-Type'] = 'application/zip' # how do we detect other types e.g. other binary files? file extensions?
-
-        UI.important("Uploading #{name}")
-        response = self.call_endpoint(expanded_url, "post", headers, File.read(file))
-
-        # inspect the response
-        case response.status
-        when 201
-          # all good in the hood
-          UI.success("Successfully uploaded #{name}.")
-        else
-          UI.error("GitHub responded with #{response[:status]}:#{response[:body]}")
-          UI.user_error!("Failed to upload asset #{name} to GitHub.")
+        file_name = File.basename(file)
+        expanded_url = Addressable::Template.new(url_template).expand(name: file_name).to_s
+        headers = {}
+        if File.extname(file_name).to_s.casecmp('.zip').zero?
+          headers['Content-Type'] = 'application/zip'
         end
-      end
-
-      def self.call_endpoint(url, method, headers, body)
-        require 'excon'
-        case method
-        when "post"
-          response = Excon.post(url, headers: headers, body: body)
-        when "get"
-          response = Excon.get(url, headers: headers, body: body)
-        else
-          UI.user_error!("Unsupported method #{method}")
+        UI.important("Uploading #{file_name}")
+        GithubApiAction.run(
+          api_token: api_token,
+          http_method: 'POST',
+          headers: headers,
+          url: expanded_url,
+          raw_body: File.read(file),
+          error_handlers: {
+            '*' => proc do |result|
+              UI.error("GitHub responded with #{result[:status]}:#{result[:body]}")
+              UI.user_error!("Failed to upload asset #{file_name} to GitHub.")
+            end
+          }
+        ) do |result|
+          UI.success("Successfully uploaded #{file_name}.")
         end
-        return response
-      end
-
-      def self.call_releases_endpoint(method, server, repo, endpoint, api_token, body)
-        url = "#{server}/repos/#{repo}#{endpoint}"
-        self.call_endpoint(url, method, self.headers(api_token), body)
-      end
-
-      def self.headers(api_token)
-        require 'base64'
-        headers = { 'User-Agent' => 'fastlane-set_github_release' }
-        headers['Authorization'] = "Basic #{Base64.strict_encode64(api_token)}" if api_token
-        headers
       end
 
       #####################################################
@@ -251,7 +240,7 @@ module Fastlane
       end
 
       def self.authors
-        ["czechboy0"]
+        ["czechboy0", "tommeier"]
       end
 
       def self.is_supported?(platform)
@@ -273,7 +262,7 @@ module Fastlane
       end
 
       def self.category
-        :misc
+        :source_control
       end
     end
   end

data/fastlane/lib/fastlane/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
-  VERSION = '2.50.0.beta.20170731010002'.freeze
+  VERSION = '2.50.0'.freeze
   DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
   MINIMUM_XCODE_RELEASE = "7.0".freeze
 end

data/gym/README.md

@@ -157,7 +157,7 @@ output_name "MyApp"           # the name of the ipa file
 
 ## Export options
 
-Since Xcode 7, `gym` is using new Xcode API which allows us to specify export options using `plist` file. By default `gym` creates this file for you and you are able to modify some parameters by using `export_method`, `export_team_id`, `include_symbols` or `include_bitcode`. If you want to have more options, like creating manifest file or app thinning, you can provide your own `plist` file:
+Since Xcode 7, `gym` is using new Xcode API which allows us to specify export options using `plist` file. By default `gym` creates this file for you and you are able to modify some parameters by using `export_method`, `export_team_id`, `include_symbols` or `include_bitcode`. If you want to have more options, like creating manifest file for app thinning, you can provide your own `plist` file:
 
 ```ruby
 export_options "./ExportOptions.plist"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane
 version: !ruby/object:Gem::Version
-  version: 2.50.0.beta.20170731010002
+  version: 2.50.0
 platform: ruby
 authors:
 - Felix Krause
@@ -863,6 +863,7 @@ files:
 - fastlane/lib/fastlane/actions/clipboard.rb
 - fastlane/lib/fastlane/actions/cloc.rb
 - fastlane/lib/fastlane/actions/cocoapods.rb
+- fastlane/lib/fastlane/actions/commit_github_file.rb
 - fastlane/lib/fastlane/actions/commit_version_bump.rb
 - fastlane/lib/fastlane/actions/copy_artifacts.rb
 - fastlane/lib/fastlane/actions/crashlytics.rb
@@ -899,6 +900,7 @@ files:
 - fastlane/lib/fastlane/actions/git_commit.rb
 - fastlane/lib/fastlane/actions/git_pull.rb
 - fastlane/lib/fastlane/actions/git_tag_exists.rb
+- fastlane/lib/fastlane/actions/github_api.rb
 - fastlane/lib/fastlane/actions/google_play_track_version_codes.rb
 - fastlane/lib/fastlane/actions/gradle.rb
 - fastlane/lib/fastlane/actions/gym.rb
@@ -1091,6 +1093,7 @@ files:
 - fastlane_core/README.md
 - fastlane_core/lib/assets/XMLTemplate.xml.erb
 - fastlane_core/lib/fastlane_core.rb
+- fastlane_core/lib/fastlane_core/.DS_Store
 - fastlane_core/lib/fastlane_core/build_watcher.rb
 - fastlane_core/lib/fastlane_core/cert_checker.rb
 - fastlane_core/lib/fastlane_core/command_executor.rb
@@ -1382,6 +1385,7 @@ files:
 - spaceship/lib/spaceship/two_step_client.rb
 - spaceship/lib/spaceship/ui.rb
 - supply/README.md
+- supply/lib/.DS_Store
 - supply/lib/supply.rb
 - supply/lib/supply/apk_listing.rb
 - supply/lib/supply/client.rb
@@ -1399,24 +1403,24 @@ metadata:
 post_install_message: 
 rdoc_options: []
 require_paths:
-- spaceship/lib
-- scan/lib
-- sigh/lib
-- snapshot/lib
-- screengrab/lib
-- fastlane/lib
 - cert/lib
-- pem/lib
-- gym/lib
-- produce/lib
+- credentials_manager/lib
 - deliver/lib
-- supply/lib
-- match/lib
+- fastlane/lib
+- fastlane_core/lib
 - frameit/lib
-- credentials_manager/lib
+- gym/lib
+- match/lib
+- pem/lib
 - pilot/lib
 - precheck/lib
-- fastlane_core/lib
+- produce/lib
+- scan/lib
+- screengrab/lib
+- sigh/lib
+- snapshot/lib
+- spaceship/lib
+- supply/lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -1424,14 +1428,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: The easiest way to automate beta deployments and releases for your iOS and
   Android apps
 test_files: []
+has_rdoc: