Consider simplifying this complex logical expression.

Open

          next if property_schema['virtual'] ||
                  ((property_schema['edi'] || {})['discard'] && !(included_anyway = options[:including_discards])) ||
                  options[:ignore].include?(name.to_sym) ||
                  (options[:only] && !options[:only].include?(name.to_sym) && !included_anyway)

Method run has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def run(message)
      algorithm_id = message[:algorithm_id]
      if (algorithm = agent_from_msg)
        result = algorithm.run(message[:input], self).capataz_slave
        klass = Setup::BuildInDataType::SCHEMA_TYPE_MAP.keys.detect do |type|

Method diff has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def diff(other_scope)
      other_scope = self.class.new(other_scope.to_s) unless other_scope.is_a?(self.class)
      diff = self.class.new
      if auth? && !other_scope.auth?
        diff.instance_variable_set(:@auth, true)

Method authorize has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def authorize
    if (tenant = Tenant.where(id: params[:tenant_id]).first)
      tenant.switch do
        errors = nil
        auth = @authorization = Setup::Authorization.where(id: params[:id]).first

Method initialize has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def initialize(user)
    @deferred_abilities = []

    deferred_abilities <<
      if (@user = user)

Method authorize_action has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def authorize_action(options = {})
      success = true
      if klass
        action_symbol =
          case @_action_name

Method new has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def new
      response =
        {
          success: success_report = {},
          errors: broken_report = {}

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                if (object_ids = options[:object_ids])
                  model.any_in(id: (limit ? object_ids[offset, limit] : object_ids.from(offset))).to_enum
                elsif (objects = options[:objects])
                  objects
                else

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                elsif (object_ids = options[:object_ids])
                  model.any_in(id: (limit ? object_ids[offset, limit] : object_ids.from(offset))).to_enum
                elsif (objects = options[:objects])
                  objects
                else

• Read up
  Read up

Method run has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def run(message)
    if (script = agent_from_msg)
      result = script.run(self)
      klass = Setup::BuildInDataType::SCHEMA_TYPE_MAP.keys.detect do |type|
        type && (result.class == type || result.class < type)

Method source_ids_from has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def source_ids_from(message)
      if (object_ids = message[:object_ids])
        object_ids
      elsif (id = message[:source_id])
        [id]

Method to_map_schema has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def to_map_schema(sch)
        if sch['type'] == 'object' && (properties = sch['properties']).is_a?(Hash)
          new_properties = {}
          id_optional = true
          properties.each do |property, property_schema|

Method digest has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def digest
      request.body.rewind
      options =
        begin
          JSON.parse(request.headers['X-Digest-Options'])

Method new has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def new
      parser_options = self.parser_options.dup
      if klass.is_a?(Class) && klass < FieldsInspection
        parser_options[:inspect_fields] = Account.current.nil? || !::User.super_access?
      end

Method bundled_ruby_code has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def bundled_ruby_code(algorithm)
        locals = %w(args)
        args_param = false
        i = -1
        params_initializer =

Method eql_content? has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def eql_content?(a, b, key = nil, &block)
        case a
          when Hash
            if b.is_a?(Hash)
              if a.size < b.size

Method init has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def init
        channel_mutex.lock
        if ENV['SKIP_RABBIT_MQ'].to_b
          puts 'RabbitMQ SKIPPED'
          false

Method request_token has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def request_token(params)
      http_client = create_http_client(token_url: token_endpoint, token_method: token_method.to_s.downcase.to_sym)
      token = http_client.get_token_with(:auth_code, params[:code]) do |parameters, headers|
        parameters.merge!(token_params(parameters, params)) if parameters
        headers.merge!(token_headers(headers, params)) if headers

• Read up
  Read up

Method run has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def run(message)
      collection_id = message[:collection_id]
      if (collection = Setup::Collection.where(id: collection_id).first)
        Setup::Collection::COLLECTING_PROPERTIES.each do |property|
          association = Setup::Collection.reflect_on_association(property)

• Read up
  Read up

Method process_ftp has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def process_ftp(opts)
      result = nil
      path = URI.decode(opts[:path])
      username, password = check(opts[:template_parameters], :username, :password)

• Read up
  Read up