fastlane-plugin-xcconfig_actions 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ca1c026cc23d89211ae095590c38efdaf2f7a20
+  data.tar.gz: 65412a70fe01ce3a8e38874f422f918258688996
+SHA512:
+  metadata.gz: 66d4512ca2e311265a018bbddc8fffd029d03e5d3bbcbf0871fce8432ea0adc927cd88c9611830554dcc5052472ff61a892f43f141f50adf67e59dc8eeff23b1
+  data.tar.gz: 1d7be32a98c6782cc670b3a5417494d7bb9f44d77f8da868d1baa531f4660286acc4fedac21388fb0e73458eb58dc4e7b8529a6f0563d896442fb909a9782d20

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Maksym Grebenets <maksym.grebenets@cba.com.au>
+
+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,130 @@
+# xcconfig_actions plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-xcconfig_actions)
+[![version](https://badge.fury.io/gh/mgrebenets%2Ffastlane-plugin-xcconfig_actions.svg)](https://badge.fury.io/gh/mgrebenets%2Ffastlane-plugin-xcconfig_actions)
+[![CircleCI](https://circleci.com/gh/mgrebenets/fastlane-plugin-xcconfig_actions.svg?style=svg)](https://circleci.com/gh/mgrebenets/fastlane-plugin-xcconfig_actions)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-xcconfig_actions`, add it to your project by running:
+
+```bash
+fastlane add_plugin xcconfig_actions
+```
+
+## About xcconfig_actions
+
+Adds actions to fastlane to work with xcconfig files.
+
+### read_xcconfig
+
+The `read_xcconfig` action reads contents of xcconfig file the same way Xcode would do, meaning
+
+- Support for resolving variable references like `$(VAR)`
+- Support for nested variable references like `$(VAR1_$(VAR2))`
+- Support for `#include "other.xcconfig"` statements
+- Support for project/target level inheritance mechanism
+
+See [this xcconfig guide](https://pewpewthespells.com/blog/xcconfig_guide.html) for detailed explanation.
+
+Things **not supported** at the moment:
+
+- Conditional variable assignment, such as `FOO[sdk=macosx*] = 1`
+- Use of `<DEVELOPER_DIR>` in include paths
+- Use of curly braces in variable references, e.g. `${VAR}`
+
+### validate_xcconfig
+
+Validate xcconfig using set of very opinionated rules:
+
+- All included files must exist
+- Include flow is unidirectional, i.e. top-down only:
+
+```c
+#include "../level_up.xcconfig" // File is in parent directory.
+```
+
+- Files do not include other files on the same level:
+
+```c
+#include "same_level.xcconfig" // Included file is on the same level.
+```
+
+- Files do not include other files more than 1 level down
+
+```c
+#include "level1/level2/level2.xcconfig" // 2 levels down: level1/level2.
+```
+
+- Duplicated includes are not allowed
+
+```c
+#include "other.xcconfig"
+#include "other.xcconfig" // Duplicated include.
+```
+
+- Circular includes are not allowed
+
+```c
+// example.xcconfig file
+#include "example.xcconfig" // Include self creates circular include.
+```
+
+Things **not supported** at the moment:
+
+- Use of `<DEVELOPER_DIR>` in include paths
+
+#### Rules Explanation
+
+Xcconfigs are too easy to get out of hand.
+Ability to use arbitrary include paths complicates usage of xcconfigs in quite a few ways:
+
+- Hard to track where the variables are declared and the overwritten
+- Xcode does not always report an error when a file is missing
+
+These rules introduce convention to organizing xcconfigs.
+The end goal is to make config files more manageable.
+
+This helps greatly when configs are used in Xcode combined with project-level and target-level inheritance.
+
+## 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
+
+```shell
+# Read xcconfig example.
+bundle exec fastlane read
+
+# Validate xcconfig example.
+bundle exec fastlane validate
+```
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```shell
+rake
+```
+
+To automatically fix many of the styling issues, use
+
+```shell
+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/xcconfig_actions/actions/read_xcconfig_action.rb

@@ -0,0 +1,190 @@
+require 'fastlane/action'
+require 'json'
+require_relative '../helper/xcconfig_actions_helper'
+
+module Fastlane
+  module Actions
+    class ReadXcconfigAction < Action
+      def self.run(params)
+        path = params[:path]
+        parent = params[:parent]
+        srcroot = params[:srcroot] || Dir.pwd
+        target_name = params[:target_name]
+
+        config = read_config(path)
+
+        if params[:no_resolve]
+          json = config.to_json
+        else
+          parent_config = read_config(parent)
+
+          parent_config["SRCROOT"] = srcroot
+          parent_config["TARGET_NAME"] = target_name if target_name
+
+          resolved_parent_config = resolve_config(parent_config)
+          resolved_config = resolve_config(config, parent: resolved_parent_config)
+
+          json = resolved_parent_config.merge(resolved_config).to_json
+        end
+
+        if params[:output_path]
+          File.open(params[:output_path], "w") { |f| f.puts(json) }
+        else
+          return json
+        end
+      end
+
+      ###
+      # @!group Implementation
+      ###
+
+      # Read xcconfig value as a hash.
+      #
+      # @param [String] filename Xcconfig path.
+      # @return [Hash<String,String>] Dictionary of xcconfig values.
+      def self.read_config(filename)
+        # TODO: If filename starts with <DEVELOPER_DIR>, then need to resolve it first.
+        return {} if filename.nil? || !File.exist?(filename)
+
+        # Used to use Xcodeproj::Config.new(filename) here, but it just doesn't do the job,
+        # e.g. it resolves $(inherited) incorrectly, allowing it to work within the scope of one file
+        # without any parent config.
+
+        xcconfig = Helper::XcconfigActionsHelper.read_xcconfig(filename)
+        config = xcconfig[:config]
+        includes = xcconfig[:includes]
+
+        # Xcodeproj does not resolve overrides from included files, so do it manually.
+        resolved_includes_config = includes.reduce({}) do |resolved_config, include_path|
+          resolved_path = resolve_path(include_path, relative_to: filename)
+          resolved_config.merge(read_config(resolved_path))
+        end
+
+        config.merge(resolved_includes_config)
+      end
+
+      # Expand given path in relation to another path.
+      #
+      # Used to resolved '#include "relative/path.xcconfig"' includes.
+      #
+      # @param [String] path Path to expand.
+      # @param [String] relative_to Parent path to expand in relation to.
+      #
+      # @return [String] Expanded path.
+      def self.resolve_path(path, relative_to:)
+        # Absolute or special SDK paths need no resolving.
+        return path if path.start_with?("/", "<")
+
+        File.expand_path(File.join(File.dirname(relative_to), path))
+      end
+
+      # Resolve xcconfig value, i.e. expand any of the $() variable references.
+      #
+      # @param [String] value String value to resolve.
+      # @param [String] key Key under which this value is defined in xcconfig. This key will be used to pick up values from parent xcconfig.
+      # @param [Hash<String,String>] resolved Dictionary of already resolved values.
+      # @param [Hash<String,String>] parent Dictionary of parent xcconfig values.
+      #
+      # @return [String] Resolved value.
+      def self.resolve_value(value, key:, resolved: {}, parent: {})
+        matches = value.scan(/(\$\([^$\)]*\))/)
+
+        matches.each do |group|
+          group.each do |match|
+            var_name = match.delete("$()")
+            # If inherited, use value from parent config.
+            var_value = if var_name == "inherited"
+                          parent[key]
+                        else
+                          resolved[var_name] || parent[var_name]
+                        end
+            value.gsub!(match, var_value || "")
+            resolved[key] = value
+          end
+        end
+
+        # If there are still variables, keep resolving then.
+        value.include?("$(") ? resolve_value(value, key: key, resolved: resolved, parent: parent) : value
+      end
+
+      # Resolve xcconfig values using parent config.
+      #
+      # @param [Hash<String,String>] config Current dictionary of values.
+      # @param [Hash<String,String>] parent Resolved parent xcconfig values.
+      #
+      # @return [Hash<String,String>] Resolved xcconfig values.
+      def self.resolve_config(config, parent: {})
+        config.each do |k, v|
+          resolve_value(v, key: k, resolved: config, parent: parent)
+        end
+        config
+      end
+
+      ###
+      # @!group Info and Options
+      ###
+
+      def self.description
+        "Read and resolve contents of xcconfig file and return as JSON"
+      end
+
+      def self.authors
+        ["Maksym Grebenets"]
+      end
+
+      def self.return_value
+        "Parse and resolved build settings from xcconfig represented as JSON"
+      end
+
+      def self.details
+        ""
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                  env_name: "XCCONFIG_ACTIONS_READ_PATH",
+                               description: "Path to xcconfig to read",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                              UI.user_error!("Couldn't find xcconfig at path: '#{value}'") unless File.exist?(value)
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :parent,
+                                  env_name: "XCCONFIG_ACTIONS_READ_PARENT",
+                               description: "Parent xcconfig file to inherit build settings from.\nThis is the xcconfig you'd set on the project level in Xcode",
+                                  optional: true,
+                                      type: String,
+                              verify_block: proc do |value|
+                                              UI.user_error!("Couldn't find parent xcconfig at path: '#{value}'") if value && !File.exist?(value)
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :no_resolve,
+                                  env_name: "XCCONFIG_ACTIONS_READ_NO_RESOLVE",
+                               description: "Do not resolve variables in xcconfigs and read 'as is'",
+                             default_value: false,
+                                  optional: true,
+                                      type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :srcroot,
+                                  env_name: "XCCONFIG_ACTIONS_READ_SRCROOT",
+                               description: "Value for SRCROOT build setting, default is current working directory",
+                                  optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :target_name,
+                                  env_name: "XCCONFIG_ACTIONS_READ_TARGET_NAME",
+                               description: "Value for TARGET_NAME build setting",
+                                  optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :output_path,
+                                  env_name: "XCCONFIG_ACTIONS_READ_OUTPUT_PATH",
+                               description: "Output path",
+                                  optional: true,
+                                      type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xcconfig_actions/actions/validate_xcconfig_action.rb

@@ -0,0 +1,120 @@
+require 'fastlane/action'
+require_relative '../helper/xcconfig_actions_helper'
+
+module Fastlane
+  module Actions
+    class ValidateXcconfigAction < Action
+      def self.run(params)
+        path = params[:path]
+        root_path = params[:root_path]
+
+        # Validate configs recursively.
+        validate_xcconfig(path, root_path: root_path, included_paths: [path], level: 0)
+      end
+
+      ###
+      # @!group Implementation
+      ###
+
+      # Validate xcconfig file.
+      # @param [String] xcconfig path to xcconfig.
+      # @param [String] root_path root path for all xcconfigs validated in this method.
+      # @param [Array<String>] list of files included so far, used to detect circular includes.
+      # @return [Array<String>] list of issues.
+      def self.validate_xcconfig(xcconfig, root_path:, included_paths: [], level: 0)
+        require "pathname"
+
+        relative_path = Pathname.new(xcconfig).relative_path_from(Pathname.new(root_path))
+        return ["File does not exist or is a directory: #{xcconfig}"] unless File.exist?(xcconfig) && File.file?(xcconfig)
+
+        config = Helper::XcconfigActionsHelper.read_xcconfig(xcconfig)
+        includes = config[:includes]
+
+        issues = includes.flat_map { |include_path| validate_include_path(include_path, xcconfig: relative_path) }
+        dupes = includes.select { |e| includes.count(e) > 1 }.uniq
+        issues << " #{relative_path}: Duplicate includes detected: #{dupes.join('\n')}" unless dupes.nil? || dupes.empty?
+        full_paths = includes.map { |path| Pathname.new(File.join(File.dirname(xcconfig), path)).cleanpath }
+        common_paths = included_paths & full_paths
+        unless common_paths.empty?
+          common_paths_string = common_paths.map { |p| "  - #{p}" }.join("\n")
+          issues << "#{relative_path}: Circular includes detected, check the following files:\n#{common_paths_string}"
+        end
+
+        result = issues.empty? ? "✅" : "❌"
+        offset = " " * 4 * level + " └──"
+        UI.message("#{offset} #{result} #{relative_path}")
+
+        # If circular includes detected stop the recursion.
+        return issues unless common_paths.empty?
+
+        # Recursively validate the rest.
+        issues + full_paths.flat_map { |path| validate_xcconfig(path, root_path: root_path, included_paths: included_paths + full_paths, level: level + 1) }
+      end
+
+      # Validate xcconfig include path.
+      #
+      # @param [String] path include path to validate.
+      # @param [String] xcconfig path to xcconfig being validated.
+      # @return [Array<String>] list of issues.
+      def self.validate_include_path(path, xcconfig:)
+        issues = []
+        issues << "#{xcconfig}: Invalid bottom-up include flow, i.e. use of '..' in include path: #{path}" if path.include?("..")
+        issues << "#{xcconfig}: Including another xcconfig 2 or more levels down: #{path}" if path.count("/") > 1
+        issues << "#{xcconfig}: Including another xcconfig on the same level: #{path}" if path.count("/") < 1
+        issues
+      end
+
+      ###
+      # @!group Info and Options
+      ###
+
+      def self.description
+        "Validate xcconfig file"
+      end
+
+      def self.authors
+        ["Maksym Grebenets"]
+      end
+
+      def self.return_value
+        "List of validation issues"
+      end
+
+      def self.details
+        [
+          "Validation rules:",
+          "- All included files exist",
+          "- Include flow is unidirectional, i.e. top-down only",
+          "- Files do not include other files on the same level",
+          "- Files do not include other files more than 1 level down",
+          "- Files do not contain duplicate includes"
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                  env_name: "XCCONFIG_ACTIONS_VALIDATE_PATH",
+                               description: "Path to xcconfig to validate",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                              UI.user_error!("Couldn't find xcconfig at path: '#{value}'") unless File.exist?(value)
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :root_path,
+                                  env_name: "XCCONFIG_ACTIONS_VALIDATE_ROOT_PATH",
+                               description: "Root path for all xcconfigs validated with this action",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                              UI.user_error!("Couldn't find root xcconfig directory: '#{value}'") unless File.exist?(value)
+                                            end)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xcconfig_actions/helper/xcconfig_actions_helper.rb

@@ -0,0 +1,42 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class XcconfigActionsHelper
+      # class methods that you define here become available in your action
+      # as `Helper::XcconfigActionsHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the xcconfig_actions plugin helper!")
+      end
+
+      # Read xcconfig and return hash with 'config' and 'includes' entries.
+      # 'config' containing the hash-map of resolved variables,
+      # 'includes' containing an array of include paths.
+      # The config values are not resolved.
+      def self.read_xcconfig(path)
+        # Get rid of comments and blank lines.
+        contents = File.read(path).gsub(%r{\s*//.*$}, "").gsub(/^$\n/, "")
+        # Collect all include statements.
+        includes_regex = /^\s*#include\s*"(.*)"$/
+        includes = contents.scan(includes_regex).flatten
+        # Get rid of include statements (makes it easier).
+        contents = contents.gsub(includes_regex, "")
+        # Collect all variable assignments.
+        config = contents.scan(/^\s*([^=]*)=(.*)$/).reduce({}) do |acc, e|
+          k = e[0].strip
+          v = e[1].strip
+          acc.merge({ k => v })
+        end
+
+        # Return.
+        {
+          config: config,
+          includes: includes
+        }
+      end
+    end
+  end
+end

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

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

data/lib/fastlane/plugin/xcconfig_actions.rb

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

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-xcconfig_actions
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Maksym Grebenets
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-22 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: 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.56.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.56.0
+- !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.116.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.116.1
+description: 
+email: maksym.grebenets@cba.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/xcconfig_actions.rb
+- lib/fastlane/plugin/xcconfig_actions/actions/read_xcconfig_action.rb
+- lib/fastlane/plugin/xcconfig_actions/actions/validate_xcconfig_action.rb
+- lib/fastlane/plugin/xcconfig_actions/helper/xcconfig_actions_helper.rb
+- lib/fastlane/plugin/xcconfig_actions/version.rb
+homepage: https://github.com/mgrebenets/fastlane-plugin-xcconfig_actions
+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.6.14
+signing_key: 
+specification_version: 4
+summary: Adds actions to fastlane to work with xcconfig files
+test_files: []