fastlane-plugin-publish_dropbox 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f40c312a18e32b37066462936b247142cd133ae6
+  data.tar.gz: dc0d935adc1edaacf2875378fadd31cbfa277a8f
+SHA512:
+  metadata.gz: 29a4d1d441e9f1c7210e614e45bfc6434d7149045902c20526e2da258763e07e0f514e4b8cb4ffd97e190c67ad8234b232623fa26ac16901ada107ea33cdbdb1
+  data.tar.gz: 974c7ad390dffef0d635ca81bdd2c32c53e7b68c7a9511486bb5bd8213b4fa9cce2971677f2ffe8b6468f0ab0a9f70f7f994523f9018bbc7a6a4e1ef37de6086

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Tommyvanvliet <tommy@twcapps.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,99 @@
+# publish_dropbox plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-publish_dropbox)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-publish_dropbox`, add it to your project by running:
+
+```bash
+fastlane add_plugin publish_dropbox
+```
+
+## About publish_dropbox
+
+This plugin  publishes artifacts over to Dropbox via a generated api token from Dropbox Developer API.
+
+**Note to author:** Add a more detailed description about this plugin here. If your plugin contains multiple actions, make sure to mention them here.
+
+## Setting up
+
+**Note:** Dropbox allows accessing their API only for authorized applications, so in order to use this plugin you must register a Dropbox app.
+
+In order to register a Dropbox app you need to go to [Dropbox Developers](https://www.dropbox.com/developers/apps) site and create your own app. 
+
+1. You only need a generated token from the Dropbox API (OAuth2 token).
+2. For Fastlane you only need the app key and app secret if you don't have a token generated. You'll also have to come up with some name for the app, but this is not used by Fastlane in any way.
+3. You also don't need to apply for production state of your app, and keep it in development phase unless you make heavy use of it. Even Dropbox themselves encourage staying in development state when the app is used as an internal tool. Read more [here](https://www.dropbox.com/developers/reference/developer-guide#production-approval).
+4. You start with access for one user only, but in development state you can request access for up to 500 users, which should cover most of the use cases for Fastlane integration.
+
+## Example
+
+### Basic usage
+
+    dropbox(
+        file_path: '/some/local-path/to/file.txt',
+        dropbox_path: '/path/to/Dropbox/destination/folder',
+        app_key: 'your-dropbox-app-key',
+        app_secret: 'your-dropbox-app-secret'
+    )
+
+The `dropbox_path` parameter is optional - if not provided, the file at `file_path` would be put in the Dropbox root directory.
+
+### Write modes
+
+The default `write_mode` is `add`, which means that plugin will raise an error if the file already exists at the destination path. If you want to allow for overwriting, set the `write_mode` parameter like so:
+
+    dropbox(
+        file_path: '/some/local-path/to/file.txt',
+        dropbox_path: '/path/to/Dropbox/destination/folder',
+        write_mode: 'overwrite',
+        app_key: 'your-dropbox-app-key',
+        app_secret: 'your-dropbox-app-secret'
+    )
+
+For the more fine-grained overwriting you can set the `update` write mode, and pass the current file revision to update:
+
+    dropbox(
+        file_path: '/some/local-path/to/file.txt',
+        dropbox_path: '/path/to/Dropbox/destination/folder',
+        write_mode: 'update',
+        update_rev: 'filerevisiontoupdate',
+        app_key: 'your-dropbox-app-key',
+        app_secret: 'your-dropbox-app-secret'
+    )
+
+The `update_rev` parameter is required for `update` write mode and ignored in other cases. Currently, if the current file revision on Dropbox doesn't match the provided revision, the plugin will fail (Dropbox API won't allow for the update).
+
+## 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).
+
+## Thanks
+Based on:
+https://github.com/ayoy/fastlane-plugin-dropbox

data/lib/fastlane/plugin/publish_dropbox.rb

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

data/lib/fastlane/plugin/publish_dropbox/actions/publish_dropbox_action.rb

@@ -0,0 +1,275 @@
+require 'fastlane/action'
+require_relative '../helper/publish_dropbox_helper'
+require 'net/http'
+require 'dropbox_api'
+
+module Fastlane
+  module Actions
+    class PublishDropboxAction < Action
+      KEYCHAIN_SERVICE_NAME = 'fastlane-plugin-dropbox'.freeze
+
+      def self.run(params)
+        UI.message ''
+        UI.message "Starting upload of #{params[:file_path]} to Dropbox"
+        UI.message ''
+
+        params[:keychain] ||= default_keychain
+
+        write_mode =
+          if params[:write_mode].nil?
+            'add'
+          elsif params[:write_mode].eql? 'update'
+            if params[:update_rev].nil?
+              UI.user_error! 'You need to specify `update_rev` when using `update` write_mode.'
+            else
+              DropboxApi::Metadata::WriteMode.new({
+                  '.tag' => 'update',
+                  'update' => params[:update_rev]
+                })
+            end
+          else
+            params[:write_mode]
+          end
+
+        access_token = get_token_from_keychain(params[:keychain], params[:keychain_password])
+        unless access_token
+          if params[:app_token]
+            access_token = params[:app_token]
+          else
+            access_token = request_token(params[:app_key], params[:app_secret])
+          end
+          unless save_token_to_keychain(params[:keychain], access_token)
+            UI.user_error! 'Failed to store access token in the keychain'
+          end
+        end
+
+        client = DropboxApi::Client.new(access_token)
+
+        output_file = nil
+
+        chunk_size = 157_286_400 # 150 megabytes
+
+        if File.size(params[:file_path]) < chunk_size
+          output_file = upload(client, params[:file_path], destination_path(params), write_mode)
+        else
+          output_file = upload_chunked(client, chunk_size, params[:file_path], destination_path(params), write_mode)
+        end
+
+        if output_file.name != File.basename(params[:file_path])
+          UI.user_error! 'Failed to upload file to Dropbox'
+        else
+          UI.success "File revision: '#{output_file.rev}'"
+          UI.success "Successfully uploaded file to Dropbox at '#{destination_path(params)}'"
+        end
+      end
+
+      def self.upload(client, file_path, destination_path, write_mode)
+        begin
+          client.upload destination_path, File.read(file_path), mode: write_mode
+        rescue DropboxApi::Errors::UploadWriteFailedError => e
+          UI.user_error! "Failed to upload file to Dropbox. Error message returned by Dropbox API: \"#{e.message}\""
+        end
+      end
+
+      def self.upload_chunked(client, chunk_size, file_path, destination_path, write_mode)
+        parts = chunker file_path, './part', chunk_size
+        UI.message ''
+        UI.important "The archive is a big file so we're uploading it in 150MB chunks"
+        UI.message ''
+
+        begin
+          UI.message "Uploading part #1 (#{File.size(parts[0])} bytes)..."
+          cursor = client.upload_session_start File.read(parts[0])
+          parts[1..parts.size].each_with_index do |part, index|
+            UI.message "Uploading part ##{index + 2} (#{File.size(part)} bytes)..."
+            client.upload_session_append_v2 cursor, File.read(part)
+          end
+
+          client.upload_session_finish cursor, DropboxApi::Metadata::CommitInfo.new('path' => destination_path,
+                                                                                    'mode' => write_mode)
+        rescue DropboxApi::Errors::UploadWriteFailedError => e
+          UI.user_error! "Error uploading file to Dropbox: \"#{e.message}\""
+        ensure
+          parts.each { |part| File.delete(part) }
+        end
+      end
+
+      def self.destination_path(params)
+        "#{params[:dropbox_path]}/#{File.basename(params[:file_path])}"
+      end
+      
+      def self.get_token_from_keychain(keychain, password)
+        other_action.unlock_keychain(
+          path: keychain,
+          password: password
+        )
+        token = `security find-generic-password -s #{KEYCHAIN_SERVICE_NAME} -w "#{keychain}" 2>/dev/null`.chomp
+        $CHILD_STATUS >> 8 == 0 ? token : nil
+      end
+
+      def self.save_token_to_keychain(keychain, access_token)
+        `security add-generic-password -a #{KEYCHAIN_SERVICE_NAME} -s #{KEYCHAIN_SERVICE_NAME} -w "#{access_token}" "#{keychain}"`
+        $CHILD_STATUS >> 8 == 0
+      end
+
+      def self.chunker(f_in, out_pref, chunksize)
+        parts = []
+        File.open(f_in, 'r') do |fh_in|
+          until fh_in.eof?
+            part = "#{out_pref}_#{format('%05d', (fh_in.pos / chunksize))}"
+            File.open(part, 'w') do |fh_out|
+              fh_out << fh_in.read(chunksize)
+            end
+            parts << part
+          end
+        end
+        parts
+      end
+
+      def self.request_token(app_key, app_secret)
+        sh("open 'https://www.dropbox.com/oauth2/authorize?response_type=code&require_role=work&client_id=#{app_key}'")
+        UI.message 'Please autorize fastlane Dropbox plugin to access your Dropbox account via your Dropbox app'
+        authorization_code = UI.input('Once authorized, please paste the authorization code here: ')
+
+        uri = URI('https://api.dropboxapi.com/oauth2/token')
+        req = Net::HTTP::Post.new(uri)
+        req.basic_auth app_key, app_secret
+        req.set_form_data(
+          'grant_type' => 'authorization_code',
+          'code' => authorization_code
+        )
+
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+
+        case res
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          json = JSON.parse(res.body)
+          access_token = json['access_token']
+          UI.success('Successfully authorized fastlane plugin to access Dropbox')
+          access_token
+        else
+          UI.user_error!("Error during authorization with Dropbox: #{res.code} - #{res.body}")
+        end
+      end
+
+      # GROUP DOCUMENTATION
+
+      def self.run(params)
+        UI.message("The publish_dropbox plugin is working!")
+      end
+
+      def self.description
+        "This plugin  publishes artifacts over to Dropbox via a generated api token from Dropbox Developer API."
+      end
+
+      def self.authors
+        ["Tommyvanvliet"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+        'nil or error message'
+      end
+
+      def self.details
+        # Optional:
+        'You have to authorize the action before using it. The access token is stored in your default keychain'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :file_path,
+                                       env_name: 'DROPBOX_FILE_PATH',
+                                       description: 'Path to the uploaded file',
+                                       type: String,
+                                       optional: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No file path specified for upload to Dropbox, pass using `file_path: 'path_to_file'`") unless value && !value.empty?
+                                         UI.user_error!("Couldn't find file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :dropbox_path,
+                                       env_name: 'DROPBOX_PATH',
+                                       description: 'Path to the destination Dropbox folder',
+                                       type: String,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :write_mode,
+                                       env_name: 'DROPBOX_WRITE_MODE',
+                                       description: 'Determines uploaded file write mode. Supports `add`, `overwrite` and `update`',
+                                       type: String,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.command_output("write_mode '#{value}' not recognized. Defaulting to `add`.") unless value =~ /(add|overwrite|update)/
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :update_rev,
+                                       env_name: 'DROPBOX_UPDATE_REV',
+                                       description: 'Revision of the file uploaded in `update` write_mode',
+                                       type: String,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Revision no. must be at least 9 hexadecimal characters ([0-9a-f]).") unless value =~ /[0-9a-f]{9,}/
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app_key,
+                                       env_name: 'DROPBOX_APP_KEY',
+                                       description: 'App Key of your Dropbox app',
+                                       type: String,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("App Key not specified for Dropbox app. Provide your app's App Key or create a new app at https://www.dropbox.com/developers if you don't have an app yet.") unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app_secret,
+                                       env_name: 'DROPBOX_APP_SECRET',
+                                       description: 'App Secret of your Dropbox app',
+                                       type: String,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("App Secret not specified for Dropbox app. Provide your app's App Secret or create a new app at https://www.dropbox.com/developers if you don't have an app yet.") unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :keychain,
+                                       env_name: 'DROPBOX_TOKEN',
+                                       description: "Provide your app's App Token or create a new app at https://www.dropbox.com/developers if you don't have an app yet.",
+                                       type: String,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("App Token not specified for Dropbox app. Provide your app's App Key or create a new app at https://www.dropbox.com/developers if you don't have an app yet.") unless File.exist?(value),
+          FastlaneCore::ConfigItem.new(key: :keychain,
+                                       env_name: 'DROPBOX_KEYCHAIN',
+                                       description: 'Path to keychain where the access token would be stored. Will use default keychain if no value is provided',
+                                       type: String,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find keychain at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :keychain_password,
+                                       env_name: 'DROPBOX_KEYCHAIN_PASSWORD',
+                                       description: 'Password to unlock keychain. If not provided, the plugin would ask for password',
+                                       type: String,
+                                       optional: true)
+        ]
+      end
+
+      def self.example_code
+        [
+          'dropbox(
+            file_path: "./path/to/file.txt",
+            dropbox_path: "/My Dropbox Folder/Text files",
+            write_mode: "add/overwrite/update",
+            update_rev: "a1c10ce0dd78",
+            app_key: "dropbox-app-key",
+            app_secret: "dropbox-app-secret",
+            app_token: "dropbox-app-token"
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/publish_dropbox/helper/publish_dropbox_helper.rb

@@ -0,0 +1,16 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class PublishDropboxHelper
+      # class methods that you define here become available in your action
+      # as `Helper::PublishDropboxHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the publish_dropbox plugin helper!")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module PublishDropbox
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-publish_dropbox
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tommyvanvliet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dropbox_api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: rspec_junit_formatter
+  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.49.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  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: simplecov
+  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.104.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.104.0
+description: 
+email: tommy@twcapps.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/publish_dropbox.rb
+- lib/fastlane/plugin/publish_dropbox/actions/publish_dropbox_action.rb
+- lib/fastlane/plugin/publish_dropbox/helper/publish_dropbox_helper.rb
+- lib/fastlane/plugin/publish_dropbox/version.rb
+homepage: https://github.com/tommy071/fastlane-plugin-publish_dropbox
+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.5.1
+signing_key: 
+specification_version: 4
+summary: This plugin  publishes artifacts over to Dropbox via a generated api token
+  from Dropbox Developer API.
+test_files: []
+has_rdoc: