From 81373fe07e0afe94e4d63a37c51a80c10132aeac Mon Sep 17 00:00:00 2001 From: GitLab Bot Date: Sat, 12 Jun 2021 00:10:00 +0000 Subject: Add latest changes from gitlab-org/gitlab@master --- rubocop/code_reuse_helpers.rb | 48 +---- rubocop/cop/gitlab/mark_used_feature_flags.rb | 264 -------------------------- 2 files changed, 10 insertions(+), 302 deletions(-) delete mode 100644 rubocop/cop/gitlab/mark_used_feature_flags.rb (limited to 'rubocop') diff --git a/rubocop/code_reuse_helpers.rb b/rubocop/code_reuse_helpers.rb index 283c43de227..63019c43943 100644 --- a/rubocop/code_reuse_helpers.rb +++ b/rubocop/code_reuse_helpers.rb @@ -32,79 +32,59 @@ module RuboCop # Returns true if the given node resides in app/finders or ee/app/finders. def in_finder?(node) - in_app_directory?(node, 'finders') + in_directory?(node, 'finders') end # Returns true if the given node resides in app/models or ee/app/models. def in_model?(node) - in_app_directory?(node, 'models') + in_directory?(node, 'models') end # Returns true if the given node resides in app/services or ee/app/services. def in_service_class?(node) - in_app_directory?(node, 'services') + in_directory?(node, 'services') end # Returns true if the given node resides in app/presenters or # ee/app/presenters. def in_presenter?(node) - in_app_directory?(node, 'presenters') + in_directory?(node, 'presenters') end # Returns true if the given node resides in app/serializers or # ee/app/serializers. def in_serializer?(node) - in_app_directory?(node, 'serializers') + in_directory?(node, 'serializers') end # Returns true if the given node resides in app/workers or ee/app/workers. def in_worker?(node) - in_app_directory?(node, 'workers') + in_directory?(node, 'workers') end # Returns true if the given node resides in app/controllers or # ee/app/controllers. def in_controller?(node) - in_app_directory?(node, 'controllers') - end - - # Returns true if the given node resides in app/graphql/types, - # ee/app/graphql/types, or ee/app/graphql/ee/types. - def in_graphql_types?(node) - in_app_directory?(node, 'graphql/types') || in_app_directory?(node, 'graphql/ee/types') + in_directory?(node, 'controllers') end # Returns true if the given node resides in lib/api or ee/lib/api. def in_api?(node) - in_lib_directory?(node, 'api') - end - - # Returns true if the given node resides in spec or ee/spec. - def in_spec?(node) file_path_for_node(node).start_with?( - ce_spec_directory, - ee_spec_directory + File.join(ce_lib_directory, 'api'), + File.join(ee_lib_directory, 'api') ) end # Returns `true` if the given AST node resides in the given directory, # relative to app and/or ee/app. - def in_app_directory?(node, directory) + def in_directory?(node, directory) file_path_for_node(node).start_with?( File.join(ce_app_directory, directory), File.join(ee_app_directory, directory) ) end - # Returns `true` if the given AST node resides in the given directory, - # relative to lib and/or ee/lib. - def in_lib_directory?(node, directory) - file_path_for_node(node).start_with?( - File.join(ce_lib_directory, directory), - File.join(ee_lib_directory, directory) - ) - end - # Returns the receiver name of a send node. # # For the AST node `(send (const nil? :Foo) ...)` this would return @@ -169,14 +149,6 @@ module RuboCop File.join(rails_root, 'ee', 'lib') end - def ce_spec_directory - File.join(rails_root, 'spec') - end - - def ee_spec_directory - File.join(rails_root, 'ee', 'spec') - end - def rails_root File.expand_path('..', __dir__) end diff --git a/rubocop/cop/gitlab/mark_used_feature_flags.rb b/rubocop/cop/gitlab/mark_used_feature_flags.rb deleted file mode 100644 index 3fa9b1a5bce..00000000000 --- a/rubocop/cop/gitlab/mark_used_feature_flags.rb +++ /dev/null @@ -1,264 +0,0 @@ -# frozen_string_literal: true - -require_relative '../../code_reuse_helpers' - -module RuboCop - module Cop - module Gitlab - # This cop tracks the usage of feature flags among the codebase. - # - # The files set in `tmp/feature_flags/*.used` can then be used for verification purpose. - # - class MarkUsedFeatureFlags < RuboCop::Cop::Cop - include RuboCop::CodeReuseHelpers - - FEATURE_METHODS = %i[enabled? disabled?].freeze - EXPERIMENTATION_METHODS = %i[active?].freeze - EXPERIMENT_METHODS = %i[ - experiment - experiment_enabled? - push_frontend_experiment - ].freeze - RUGGED_METHODS = %i[ - use_rugged? - ].freeze - WORKER_METHODS = %i[ - data_consistency - ].freeze - GRAPHQL_METHODS = %i[ - field - ].freeze - SELF_METHODS = %i[ - push_frontend_feature_flag - limit_feature_flag= - ].freeze + EXPERIMENT_METHODS + RUGGED_METHODS + WORKER_METHODS - - RESTRICT_ON_SEND = FEATURE_METHODS + EXPERIMENTATION_METHODS + GRAPHQL_METHODS + SELF_METHODS - - USAGE_DATA_COUNTERS_EVENTS_YAML_GLOBS = [ - File.expand_path("../../../config/metrics/aggregates/*.yml", __dir__), - File.expand_path("../../../lib/gitlab/usage_data_counters/known_events/*.yml", __dir__) - ].freeze - - DYNAMIC_FEATURE_FLAGS = [ - :usage_data_static_site_editor_commits, # https://gitlab.com/gitlab-org/gitlab/-/issues/284082 - :usage_data_static_site_editor_merge_requests # https://gitlab.com/gitlab-org/gitlab/-/issues/284083 - ].freeze - - # Called before all on_... have been called - # When refining this method, always call `super` - def on_new_investigation - super - track_dynamic_feature_flags! - track_usage_data_counters_known_events! - end - - def on_casgn(node) - _, lhs_name, rhs = *node - - save_used_feature_flag(rhs.value) if lhs_name == :FEATURE_FLAG - end - - def on_send(node) - return if in_spec?(node) - return unless trackable_flag?(node) - - flag_arg = flag_arg(node) - flag_value = flag_value(node) - return unless flag_value - - if flag_arg_is_str_or_sym?(node) - if caller_is_feature_gitaly?(node) - save_used_feature_flag("gitaly_#{flag_value}") - else - save_used_feature_flag(flag_value) - end - - if experiment_method?(node) || experimentation_method?(node) - # Additionally, mark experiment-related feature flag as used as well - matching_feature_flags = defined_feature_flags.select { |flag| flag == "#{flag_value}_experiment_percentage" } - matching_feature_flags.each do |matching_feature_flag| - puts_if_ci(node, "The '#{matching_feature_flag}' feature flag tracks the #{flag_value} experiment, which is still in use, so we'll mark it as used.") - save_used_feature_flag(matching_feature_flag) - end - end - elsif flag_arg_is_send_type?(node) - puts_if_ci(node, "Feature flag is dynamic: '#{flag_value}.") - elsif flag_arg_is_dstr_or_dsym?(node) - str_prefix = flag_arg.children[0] - rest_children = flag_arg.children[1..] - - if rest_children.none? { |child| child.str_type? } - matching_feature_flags = defined_feature_flags.select { |flag| flag.start_with?(str_prefix.value) } - matching_feature_flags.each do |matching_feature_flag| - puts_if_ci(node, "The '#{matching_feature_flag}' feature flag starts with '#{str_prefix.value}', so we'll optimistically mark it as used.") - save_used_feature_flag(matching_feature_flag) - end - else - puts_if_ci(node, "Interpolated feature flag name has multiple static string parts, we won't track it.") - end - else - puts_if_ci(node, "Feature flag has an unknown type: #{flag_arg.type}.") - end - end - - private - - def puts_if_ci(node, text) - puts "#{text} (call: `#{node.source}`, source: #{node.location.expression.source_buffer.name})" if ENV['CI'] - end - - def save_used_feature_flag(feature_flag_name) - used_feature_flag_file = File.expand_path("../../../tmp/feature_flags/#{feature_flag_name}.used", __dir__) - return if File.exist?(used_feature_flag_file) - - FileUtils.touch(used_feature_flag_file) - end - - def class_caller(node) - node.children[0]&.const_name.to_s - end - - def method_name(node) - node.children[1] - end - - def flag_arg(node) - if worker_method?(node) - return unless node.children.size > 3 - - node.children[3].each_pair.find do |pair| - pair.key.value == :feature_flag - end&.value - elsif graphql_method?(node) - return unless node.children.size > 3 - - opts_index = node.children[3].hash_type? ? 3 : 4 - return unless node.children[opts_index] - - node.children[opts_index].each_pair.find do |pair| - pair.key.value == :feature_flag - end&.value - else - arg_index = rugged_method?(node) ? 3 : 2 - - node.children[arg_index] - end - end - - def flag_value(node) - flag_arg = flag_arg(node) - return unless flag_arg - - if flag_arg.respond_to?(:value) - flag_arg.value - else - flag_arg - end.to_s.tr("\n/", ' _') - end - - def flag_arg_is_str_or_sym?(node) - flag_arg = flag_arg(node) - flag_arg.str_type? || flag_arg.sym_type? - end - - def flag_arg_is_send_type?(node) - flag_arg(node).send_type? - end - - def flag_arg_is_dstr_or_dsym?(node) - flag = flag_arg(node) - (flag.dstr_type? || flag.dsym_type?) && flag.children[0].str_type? - end - - def caller_is_feature?(node) - class_caller(node) == "Feature" - end - - def caller_is_feature_gitaly?(node) - class_caller(node) == "Feature::Gitaly" - end - - def caller_is_experimentation?(node) - class_caller(node) == "Gitlab::Experimentation" - end - - def experiment_method?(node) - EXPERIMENT_METHODS.include?(method_name(node)) - end - - def rugged_method?(node) - RUGGED_METHODS.include?(method_name(node)) - end - - def feature_method?(node) - FEATURE_METHODS.include?(method_name(node)) && (caller_is_feature?(node) || caller_is_feature_gitaly?(node)) - end - - def experimentation_method?(node) - EXPERIMENTATION_METHODS.include?(method_name(node)) && caller_is_experimentation?(node) - end - - def worker_method?(node) - WORKER_METHODS.include?(method_name(node)) - end - - def graphql_method?(node) - GRAPHQL_METHODS.include?(method_name(node)) && in_graphql_types?(node) - end - - def self_method?(node) - SELF_METHODS.include?(method_name(node)) && class_caller(node).empty? - end - - def trackable_flag?(node) - feature_method?(node) || experimentation_method?(node) || graphql_method?(node) || self_method?(node) - end - - # Marking all event's feature flags as used as Gitlab::UsageDataCounters::HLLRedisCounter.track_event{,context} - # is mostly used with dynamic event name. - def track_dynamic_feature_flags! - DYNAMIC_FEATURE_FLAGS.each(&method(:save_used_feature_flag)) - end - - # Marking all event's feature flags as used as Gitlab::UsageDataCounters::HLLRedisCounter.track_event{,context} - # is mostly used with dynamic event name. - def track_usage_data_counters_known_events! - usage_data_counters_known_event_feature_flags.each(&method(:save_used_feature_flag)) - end - - def usage_data_counters_known_event_feature_flags - USAGE_DATA_COUNTERS_EVENTS_YAML_GLOBS.each_with_object(Set.new) do |glob, memo| - Dir.glob(glob).each do |path| - YAML.safe_load(File.read(path))&.each do |hash| - memo << hash['feature_flag'] if hash['feature_flag'] - end - end - end - end - - def defined_feature_flags - @defined_feature_flags ||= begin - flags_paths = [ - 'config/feature_flags/**/*.yml' - ] - - # For EE additionally process `ee/` feature flags - if File.exist?(File.expand_path('../../../ee/app/models/license.rb', __dir__)) && !%w[true 1].include?(ENV['FOSS_ONLY'].to_s) - flags_paths << 'ee/config/feature_flags/**/*.yml' - end - - flags_paths.each_with_object([]) do |flags_path, memo| - flags_path = File.expand_path("../../../#{flags_path}", __dir__) - Dir.glob(flags_path).each do |path| - feature_flag_name = File.basename(path, '.yml') - - memo << feature_flag_name - end - end - end - end - end - end - end -end -- cgit v1.2.3