fastlane-plugin-xcconfig_actions 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1de54217087690915ba20ee2e6cb210e198d0663696dcb59314aab235391142b
-  data.tar.gz: 4cce95907529eb88ffff000abadbe3bcbf7a0cc119418fd8ac09996a8809b571
+  metadata.gz: 1ff5347f5b29ae989604b428568e7a6f6f76a782699a2d6f0afdb1696f9d41ce
+  data.tar.gz: ccabe7e926c527995f7d648916ff5113d510cb9099ea9d312fd49a8db3c08573
 SHA512:
-  metadata.gz: 4ca5c56e3317e7407d37f2175ec367bf392ad010377191fe56b65c6c07a28302f87ec1253021182fa88449220c8e6fdd3ba6baaf60e45336d7298e0400e0d5e1
-  data.tar.gz: c5e29e943f531cb921c7a1f11ea542293ab4296e757379510cce3d4759f19bd195f6b5c62cca971c9f022e2372767b778780285248197db1511346b38d7e77e5
+  metadata.gz: a5cf33cdd535fe366170caafe3b6d9a46262dcf9273f14b4c3fa3cebdefd84989d60f59ee59e5e189f394186b5d98666def29db384f753f1e8c62919060dfd66
+  data.tar.gz: 510bed17f4306c2d6aaac5c48992554846ecb19d724574a701a0244fdf32c1fd0d13c3a0baf79bb714459683ee9a643c7f1309ce51353b031185c7c40df75dc9

data/README.md

@@ -34,6 +34,41 @@ Things **not supported** at the moment:
 - Use of `<DEVELOPER_DIR>` in include paths
 - Use of curly braces in variable references, e.g. `${VAR}`
 
+The build settings are also saved as a dictionary under `SharedValues::XCCONFIG_ACTIONS_BUILD_SETTINGS` key in current `lane_context`.
+
+### build_settings_to_flags
+
+Map build settings to Clang Cxx/Objective-C compiler, Swift compiler and Linker flags.
+
+This action is useful when you plan to reuse xcconfigs with other tools, such as [Buck](https://buckbuild.com/), and you want to translate xcconfigs into the compiler/linker flags.
+
+Build flags can be printed to standard output or saved to file.
+The flags are also available via lane context as `lane_context[SharedValues::XCCONFIG_ACTIONS_BUILD_FLAGS]`.
+
+The result is a dictionary with following keys:
+
+- `compiler_flags` for Clang CXX/Objective-C compiler.
+- `swift_compiler_flags` for Swift compiler.
+- `linker_flags` for Clang linker.
+
+<!-- TODO: Add info on how it works. -->
+
+References:
+
+- [Xcode Build Settings](https://help.apple.com/xcode/mac/10.2/#/itcaec37c2a6)
+- [LLVM Clang Command Line Options](https://clang.llvm.org/docs/ClangCommandLineReference.html)
+- [LLVM Clang Diagnostics](https://clang.llvm.org/docs/DiagnosticsReference.html)
+- [GCC Warning Options](https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html)
+- https://gist.github.com/fabiopelosin/4560417
+- https://pewpewthespells.com/blog/xcode_build_system.html
+
+#### Known Issues
+
+Flags like `-sdk iphoneos` and `-isysroot iphoneos` may not be suitable for all uses, so may have to remove them from all flags.
+
+The flag like `-std=gnu++14` is added to `compiler_flags` but it's not applicable for Objective-C code.
+Most tools have differentiation between C flags (C and Objective-C) and Cxx flags (C++/Objective-C++).
+
 ### validate_xcconfig
 
 Validate xcconfig using set of very opinionated rules:
@@ -96,6 +131,9 @@ Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plu
 # Read xcconfig example.
 bundle exec fastlane read
 
+# Map build settings to build flags.
+bundle exec fastlane build_flags
+
 # Validate xcconfig example.
 bundle exec fastlane validate
 ```

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

@@ -0,0 +1,122 @@
+require 'fastlane/action'
+require_relative '../helper/xcconfig_actions_helper'
+require_relative '../helper/xcspec'
+
+module Fastlane
+  module Actions
+    ActionHelper = Fastlane::Helper::XcconfigActionsHelper
+    Xcspec = Fastlane::Helper::Xcspec
+
+    module SharedValues
+      XCCONFIG_ACTIONS_BUILD_FLAGS = :XCCONFIG_ACTIONS_BUILD_FLAGS
+    end
+
+    class BuildSettingsToFlagsAction < Action
+      def self.run(params)
+        build_settings = params[:build_settings] || Actions.lane_context[SharedValues::XCCONFIG_ACTIONS_BUILD_SETTINGS]
+        UI.user_error!("Missing build settings input") unless build_settings
+        xcode = params[:xcode]
+
+        clang_spec = load_tool_spec("Clang*", xcode: xcode)
+        swift_spec = load_tool_spec("Swift*", xcode: xcode)
+        linker_spec = load_tool_spec("Ld*", xcode: xcode)
+
+        clang_mapping = clang_spec.map_build_settings(build_settings)
+        swift_mapping = swift_spec.map_build_settings(build_settings)
+        linker_mapping = linker_spec.map_build_settings(build_settings)
+
+        flags = {
+          "compiler_flags" => clang_mapping.flags,
+          "swift_compiler_flags" => swift_mapping.flags,
+          "linker_flags" => [
+            linker_mapping.flags,
+            linker_mapping.linker_flags,
+            clang_mapping.linker_flags,
+            swift_mapping.linker_flags
+          ].reject(&:empty?).join(" ")
+        }
+
+        Actions.lane_context[SharedValues::XCCONFIG_ACTIONS_BUILD_FLAGS] = flags
+
+        if params[:output_path]
+          File.open(params[:output_path], "w") { |f| f.puts(flags.to_json) }
+        else
+          return flags
+        end
+      end
+
+      ###
+      # @!group Xcspecs
+      ###
+
+      def self.load_tool_spec(tool, xcode:)
+        core_spec_path = ActionHelper.find_xcspec("CoreBuildSystem*", xcode: xcode)
+        standard_spec = Xcspec.new(core_spec_path, id: "com.apple.buildsettings.standard")
+        core_spec = Xcspec.new(core_spec_path, id: "com.apple.build-system.core")
+
+        Xcspec.new(
+          ActionHelper.find_xcspec(tool, xcode: xcode),
+          standard_spec: standard_spec,
+          core_spec: core_spec
+        )
+      end
+
+      ###
+      # @!group Info and Options
+      ###
+
+      def self.description
+        "Map xcconfig build settings to compiler and linker build flags"
+      end
+
+      def self.authors
+        ["Maksym Grebenets"]
+      end
+
+      def self.return_value
+        "Build flags dictionary"
+      end
+
+      def self.details
+        [
+          "Build flags keys:",
+          "- compiler_flags: CXX compiler flags for clang compiler",
+          "- swift_compiler_flags: Compiler flags for Swift compiler",
+          "- linker_flags: Linker flags for clang linker (Cxx and Swift)"
+        ].join("\n")
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :build_settings,
+                                  env_name: "XCCONFIG_ACTIONS_BUILD_FLAGS_BUILD_SETTINGS",
+                               description: "Build settings to convert to build flags",
+                                  optional: true,
+                                      type: Hash,
+                              verify_block: proc do |value|
+                                              UI.user_error!("Missing build settings") if value.nil?
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :xcode,
+                                  env_name: "XCCONFIG_ACTIONS_BUILD_FLAGS_XCODE",
+                               description: "Xcode version of path to Xcode.app",
+                                  optional: true,
+                             default_value: "10.2",
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :output_path,
+                                  env_name: "XCCONFIG_ACTIONS_BUILD_FLAGS_OUTPUT_PATH",
+                               description: "Output path to save build settings JSON",
+                                  optional: true,
+                                      type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

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

@@ -4,6 +4,10 @@ require_relative '../helper/xcconfig_actions_helper'
 
 module Fastlane
   module Actions
+    module SharedValues
+      XCCONFIG_ACTIONS_BUILD_SETTINGS = :XCCONFIG_ACTIONS_BUILD_SETTINGS
+    end
+
     class ReadXcconfigAction < Action
       def self.run(params)
         path = params[:path]
@@ -13,9 +17,7 @@ module Fastlane
 
         config = read_config(path)
 
-        if params[:no_resolve]
-          json = config.to_json
-        else
+        unless params[:no_resolve]
           parent_config = read_config(parent)
 
           parent_config["SRCROOT"] = srcroot
@@ -24,20 +26,22 @@ module Fastlane
           if Helper::XcconfigActionsHelper.command_exist?("xcodebuild")
             # Set value of XCODE_VERSION_MAJOR not available when reading xcconfigs directly.
             xcode_version = `xcodebuild -version | head -n1 | cut -d' ' -f2 | xargs`.strip
-            xcode_version_majon_padded = xcode_version.split(".").first.rjust(2, "0") + "00"
-            parent_config["XCODE_VERSION_MAJOR"] = xcode_version_majon_padded
+            xcode_version_major_padded = xcode_version.split(".").first.rjust(2, "0") + "00"
+            parent_config["XCODE_VERSION_MAJOR"] = xcode_version_major_padded
           end
 
           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
+          config = resolved_parent_config.merge(resolved_config)
         end
 
+        Actions.lane_context[SharedValues::XCCONFIG_ACTIONS_BUILD_SETTINGS] = config
+
         if params[:output_path]
-          File.open(params[:output_path], "w") { |f| f.puts(json) }
+          File.open(params[:output_path], "w") { |f| f.puts(config.to_json) }
         else
-          return json
+          return config
         end
       end
 
@@ -96,6 +100,7 @@ module Fastlane
       def self.resolve_value(value, key:, resolved: {}, parent: {})
         matches = value.scan(/(\$\([^$\)]*\))/)
 
+        mutable_value = value.dup # Prevent unwanted side-effect of input modification.
         matches.each do |group|
           group.each do |match|
             var_name = match.delete("$()")
@@ -105,13 +110,13 @@ module Fastlane
                         else
                           resolved[var_name] || parent[var_name]
                         end
-            value.gsub!(match, var_value || "")
-            resolved[key] = value
+            mutable_value.gsub!(match, var_value || "")
+            resolved[key] = mutable_value
           end
         end
 
         # If there are still variables, keep resolving then.
-        value.include?("$(") ? resolve_value(value, key: key, resolved: resolved, parent: parent) : value
+        mutable_value.include?("$(") ? resolve_value(mutable_value, key: key, resolved: resolved, parent: parent) : mutable_value
       end
 
       # Resolve xcconfig values using parent config.
@@ -147,6 +152,10 @@ module Fastlane
         ""
       end
 
+      def self.category
+        :building
+      end
+
       def self.available_options
         [
           FastlaneCore::ConfigItem.new(key: :path,
@@ -190,7 +199,7 @@ module Fastlane
       end
 
       def self.is_supported?(platform)
-        true
+        [:ios, :mac].include?(platform)
       end
     end
   end

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

@@ -91,6 +91,10 @@ module Fastlane
         ].join("\n")
       end
 
+      def self.category
+        :linting
+      end
+
       def self.available_options
         [
           FastlaneCore::ConfigItem.new(key: :path,
@@ -113,7 +117,7 @@ module Fastlane
       end
 
       def self.is_supported?(platform)
-        true
+        [:ios, :mac].include?(platform)
       end
     end
   end

data/lib/fastlane/plugin/xcconfig_actions/helper/scripts/parse.py

@@ -0,0 +1,18 @@
+from bs4 import BeautifulSoup
+import re
+
+soup = BeautifulSoup(open("page.html"), "html.parser")
+
+entries = soup.find_all("div", id=re.compile("dev.*"))
+
+title_re = re.compile(".*\((.*)\)")
+settings = []
+for e in entries:
+    text = e.find("h2", class_="Name").text
+    m = title_re.match(text)
+    if m == None:
+        settings.append(text)
+    else:
+        settings.append(m.group(1))
+
+print settings

data/lib/fastlane/plugin/xcconfig_actions/helper/scripts/scrape.py

@@ -0,0 +1,23 @@
+# https://stackoverflow.com/questions/8049520/web-scraping-javascript-page-with-python
+from selenium import webdriver
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions
+from selenium.webdriver.common.by import By
+
+options = webdriver.FirefoxOptions()
+options.headless = True
+driver = webdriver.Firefox(firefox_options=options)
+
+id = "itcaec37c2a6"
+url = "https://help.apple.com/xcode/mac/10.2/#/{}".format(id)
+driver.get(url)
+
+# https://stackoverflow.com/questions/26566799/wait-until-page-is-loaded-with-selenium-webdriver-for-python
+WebDriverWait(driver, 10).until(
+    expected_conditions.text_to_be_present_in_element(
+        (By.ID, id),
+        'Build settings reference'
+    )
+)
+
+print driver.page_source.encode('utf-8').strip()

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

@@ -42,6 +42,16 @@ module Fastlane
           includes: includes
         }
       end
+
+      def self.find_xcspec(name, xcode:)
+        search_path = File.exist?(xcode) ? File.join(xcode, "Contents/Plugins") : File.join(File.dirname(__FILE__), "xcspecs", xcode)
+        UI.user_error!("Can't find app path of xcspecs folder for xcode: #{xcode}") unless File.exist?(search_path)
+
+        query = File.join(search_path, "**", name + ".xcspec")
+        xcspec = Dir[query].first
+        UI.user_error!("Can't find xcspec with name: #{name}") unless File.exist?(xcspec)
+        xcspec
+      end
     end
   end
 end

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

@@ -0,0 +1,259 @@
+require "plist"
+require "nokogiri-plist"
+
+module Fastlane
+  UI = UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    # Xcspec helper class.
+    class Xcspec
+      ###
+      # @!group Mapping
+      ###
+      class Mapping
+        attr_reader :flags, :linker_flags
+
+        def initialize(flags = "", linker_flags = "")
+          @flags = flags
+          @linker_flags = linker_flags
+        end
+
+        # Join with other mapping and return new mapping.
+        def join(other)
+          return self if other.nil?
+
+          joined_flags = [flags, other.flags].reject(&:empty?).join(" ")
+          joined_linker_flags = [linker_flags, other.linker_flags].reject(&:empty?).join(" ")
+
+          Mapping.new(joined_flags, joined_linker_flags)
+        end
+      end
+
+      ###
+      # @!group Initialization
+      ###
+
+      attr_reader :tool
+
+      def initialize(path, id: nil, standard_spec: nil, core_spec: nil)
+        UI.user_error!("No such file: #{path}") unless path && File.exist?(path)
+
+        @plist = Xcspec.load_plist(path)
+        @tool = find_tool(id)
+
+        all_tools = [@tool]
+        all_tools << standard_spec.tool if standard_spec
+        all_tools << core_spec.tool if core_spec
+
+        @all_options = all_tools.flat_map { |t| t["Options"] }
+      end
+
+      def self.load_plist(path)
+        file_type = `file -b --mime-type #{path.shellescape}`.chomp
+        if file_type == "text/xml" || file_type == "application/xml"
+          xml_plist = path
+        else
+          if FastlaneCore::Helper.mac?
+            xml_plist = Tempfile.new("xcspec.plist").path
+            result = system("plutil -convert xml1 -o #{xml_plist.shellescape} #{path.shellescape}")
+            UI.user_error!("Couldn't convert #{path} xcspec to XML plist") unless result
+          else
+            # There is plist-utils library, but it can only convert binary to XML, can't handle ASCII.
+            UI.user_error!("Can't convert ASCII plists to XML on Linux or Windows platform")
+          end
+        end
+
+        Nokogiri::PList(File.open(xml_plist))
+      end
+
+      def find_tool(id)
+        return @plist unless @plist.kind_of?(Array)
+        id ? @plist.find { |t| t["Identifier"] == id } : @plist.first
+      end
+
+      ###
+      # @!group Mapping
+      ###
+
+      def map_build_settings(build_settings)
+        # Build settings provided for mapping will not include all possible build settings.
+        # Add default values for missing build settings.
+        missing_build_settings = @all_options.reduce({}) do |memo, opt|
+          name = opt["Name"]
+          build_settings.key?(name) ? memo : memo.merge({ name => opt["DefaultValue"] })
+        end
+        complete_build_settings = build_settings.merge(missing_build_settings)
+
+        mappings = build_settings.flat_map do |setting, value|
+          map_build_setting_value(setting, value, complete_build_settings)
+        end.compact
+
+        mappings.reduce(Mapping.new) { |memo, m| memo.join(m) }
+      end
+
+      def map_build_setting_value(name, value, build_settings)
+        option = @tool["Options"].find { |o| o["Name"] == name }
+        return nil unless option
+
+        map_option(option, value, build_settings)
+      end
+
+      def map_option(option, value, build_settings)
+        # Evaluate and check the 'Condition'.
+        return nil unless check_condition(option, build_settings)
+
+        # If type of the value is one of List types (StringList, PathList),
+        # then split it into value list, else just use scalar value itself.
+        scalar_values = option["Type"].downcase.end_with?("list") ? value.split : [value]
+        scalar_values.flat_map { |v| map_option_scalar_value(option, v, build_settings) }.compact
+      end
+
+      def map_option_scalar_value(option, value, build_settings)
+        # At this point we deal with scalar value.
+
+        # Type = StringList
+        #   - CommandLineFlag and CommandLinePrefixFlag - map each string in the list.
+        #   - CommandLineArgs - map each string in the list.
+        #   - Finally there are entries with only Category = CustomFlags.
+        #     Those end up in compiler flags for sure, so looks like if category is CustomFlags,
+        #     then should use them as is.
+        #     There's only 3 of them: OTHER_CFLAGS, OTHER_CPLUSPLUSFLAGS and WARNING_CFLAGS.
+        # PathList, that for all intents and purposes can be handed as StringList.
+
+        # - CommandLineArgs
+        #   - If input is StringList, then map each entry from string list according to CommandLineArgs value
+        #     The value of CommandLineArgs can be an array, use flat map
+        #     Can have a switch, e.g.
+        #       CommandLineArgs = {
+        #         "" = ();
+        #         "<<otherwise>>" = (
+        #            "-$(DEPLOYMENT_TARGET_CLANG_FLAG_NAME)=$(value)",
+        #        );
+        #       };
+        #     All these switches, however, map to nothing for empty string and to something for non-empty string.
+        #     The vey same switch is used for enums. Switching for enums vs string is no different,
+        #     since switching happens on string values.
+        #     <<otherwise>> is for other values
+        # - AdditionalLinkerArgs
+        #   Few build settings have them, collected separately, work just like CommandLineArgs for parsing.
+        # - CommandLineFlag and CommandLinePrefixFlag
+        #   - If input is StringList then applied to each entry in the list, to each entry applied as to a scalar value:
+        #   - If input is scalar String value, then applied just once as -<flag> $(value)
+        #   - If input is boolean, then just the flag is used, e.g. -<flag>, no Prefix option supported for boolean.
+        #   - While for prefix it appears there's no space and it is -<prefix>$(value)
+        #   - An exception(!) is MACH_O_TYPE, where no value is appended but just the flag is used.
+        #     It is also the only enum where list of values has command line flag for each value.
+
+        # Type = Enumeration
+        #   Most of them have CommandLineArgs with a switch.
+        #   Some also come with AdditionalLinkerArgs, which is mapped in similar way.
+        #   Then there's MACH_O_TYPE, which has CommandLineFlag under Values...
+        #   But only when used for linker flags:
+        #     Value = "mh_dylib";
+        #     CommandLineFlag = "-dynamiclib";
+        #   -dynamiclib is a flag that doesn't take input, so only specified as is.
+
+        flags = ""
+        if (cli_args = option["CommandLineArgs"])
+          flags = map_args(option, cli_args, value, build_settings)
+        elsif (cli_flag = option["CommandLineFlag"])
+          # If Boolean and YES, then use CommandLineFlag value.
+          if option["Type"] == "Boolean"
+            flags = cli_flag if value == "YES"
+          else
+            flags = [cli_flag, value].join(" ")
+          end
+        elsif (cli_prefix_flag = option["CommandLinePrefixFlag"])
+          flags = [cli_prefix_flag, value].join # Join with no space in between.
+        elsif option["Category"] == "CustomFlags"
+          flags = value
+        else
+          # Nothing to map to, except for when it's MACH_O_TYPE, when it has list of dictionaries:
+          # Values = ( { Value = "v", CommandLineFlag = "f", ... } )
+          match = (option["Values"] || []).find { |v| v["Value"] == value } || {}
+          flags = match["CommandLineFlag"] || ""
+        end
+
+        linker_flags = ""
+        if (linker_args = option["AdditionalLinkerArgs"])
+          linker_flags = map_args(option, linker_args, value, build_settings)
+        end
+
+        Mapping.new(flags, linker_flags)
+      end
+
+      def map_args(option, args, value, build_settings)
+        return "" unless args
+
+        if args.kind_of?(Hash)
+          map_args(option, args[value] || args["<<otherwise>>"], value, build_settings)
+        else
+          # Args should be an array here, but can be just single string.
+
+          resolved_args = args.kind_of?(Array) ? args.dup : [args]
+          # Replacing $(value) is just one part, need to resolve any build settings present too.
+          resolved_args = resolved_args.map { |a| a.gsub("$(value)", value) }.join(" ")
+          Fastlane::Actions::ReadXcconfigAction.resolve_value(
+            resolved_args,
+            key: "resolved_args",
+            resolved: {},
+            parent: build_settings
+          )
+        end
+      end
+
+      # Constants for condition evaluation.
+      NO = false
+      YES = true
+
+      # Evaluate and check the condition.
+      # Conditions come in form like this:
+      # "$(COMPILER_INDEX_STORE_ENABLE) == YES  ||  ( $(COMPILER_INDEX_STORE_ENABLE) == Default  &&  $(GCC_OPTIMIZATION_LEVEL) == 0 )"
+      # Return true if there's no condition to evaluate.
+      def check_condition(option, build_settings)
+        condition = option["Condition"]
+        return true unless condition
+
+        # Need to resolve all $(VAR) references using build settings.
+        # At this point using complete build settings,
+        # which include default values for all known build settings.
+
+        # Handy that read_xcconfig action already has a helper to resolve a value.
+        # Just pass current build settings as parent config.
+        resolved_condition = Fastlane::Actions::ReadXcconfigAction.resolve_value(
+          condition,
+          key: "condition",
+          resolved: {},
+          parent: build_settings
+        )
+
+        # Resolved condition is now a C-like expression, which also can be evaluated as Ruby code.
+        # With small changes though.
+        # All literals in condition can be treated as strings, except for YES/NO boolean literals,
+        # which are replaced with `true` and `false`.
+        # However, xcspecs are very inconsistent when it comes to strings.
+        # Some values are used unquoted in the conditions, such as:
+        # Defatult, mh_object, bitcode.
+        # There's also use of '' and \"\" for empty string, the latter may cause issues.
+        # Then "same-as-input" that may have to be resolved - do not handle for now.
+        # Finally, $(variant) == profile - just leave it for now.
+
+        # Ways to fix.
+        # 1. Scan for all enums in xcspecs and define module vars for each enum value,
+        # so when evaluated, is replaced with variable.
+        # 2. Process resolved condition by wrapping all unwrapped entries in quotes.
+        # Using approach 2 for now with insane regex.
+
+        # In all cases replace \"\" with ''.
+        resolved_condition.gsub!('"', "'")
+
+        # Quote everything except YES and NO.
+        resolved_condition = (" " + resolved_condition + " ").gsub(/\s((\w|\d|-|\+|\.)+?)\s/, " '\\1' ").gsub(/'(YES|NO)'/, '\\1')
+
+        # rubocop:disable Security/Eval
+        eval(resolved_condition)
+        # rubocop:enable Security/Eval
+      end
+    end
+  end
+end