Method each_entry has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def each_entry(&block)
      state.clear if state[:done]
      if decompress_content?
        begin
          Zip::InputStream.open(StringIO.new(data.read)) do |zis|

Method post_digest_pull_import has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def post_digest_pull_import(request, options = {})
      readable =
        if request.content_type.downcase == 'multipart/form-data'
          request.params[:data] || request.params[:file] || fail('Missing data (or file) part')
        else

Consider simplifying this complex logical expression.

Open

          if element.max_occurs == :unbounded || element.max_occurs > 1 || element.min_occurs > 1
            plural_title = (element_schema['title'] || element.name || element.try(:nice_name) || element.tag_name).to_title.pluralize
            p = (element.name || element_schema['title'] || element.try(:nice_name) || element.tag_name).pluralize.to_method_name(properties)
            properties[p] = { 'title' => "List of #{plural_title}",
                              'type' => 'array',

Consider simplifying this complex logical expression.

Open

              if scheduler || publish_at || async_message
                if (token = message[:token])
                  TaskToken.where(token: token).delete_all
                end
                message[:task_id] = task.id.to_s

Method mongo_value has 41 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def mongo_value(value, field, schema = nil, &success_block)
      field = '_id' if field.to_s == 'id'
      types =
        if !caching? || schema
          mongo_type_for(field, schema)

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

Open

    def run(message)
      message = message.with_indifferent_access
      data_types =
        case source = message[:source]
        when nil # All data types

Method new_user has 40 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def new_user
      data = (JSON.parse(@webhook_body) rescue {}).keep_if { |key, _| %w(email password password_confirmation token code).include?(key) }
      data = data.with_indifferent_access
      data.reverse_merge!(email: params[:email], password: pwd = params[:password], password_confirmation: params[:password_confirmation] || pwd)
      status = :not_acceptable

Method valuate has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def valuate(cond_v, klass)
      return if cond_v.nil?
      return cond_v if cond_v.is_a?(klass)
      cond_v = [cond_v] unless (is_array = cond_v.is_a?(Array))
      to_obj_class = CONVERSION_METHOD[klass]

• Read up
  Read up

Method validates_configuration has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def validates_configuration
      unless requires :data_type, :observers, :transformation
        mismatch_observers = observers.select { |observer| observer.data_type_id != data_type_id }
        unless mismatch_observers.empty?
          errors.add(:observers, "data type mismatch: #{observers.map(&:custom_title).to_sentence}")

• Read up
  Read up

Method cross_origins has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

      def cross_origins
        if @origins
          @origins.collect do |origin|
            if origin.respond_to?(:call)
              origin.call

• Read up
  Read up

Method store has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def store(source, opts)
      uploader = opts.is_a?(CarrierWave::Uploader) ? opts : opts[:on]
      fail "Invalid options argument #{opts}, an uploader expected :on" unless uploader.is_a?(CarrierWave::Uploader::Base)
      field = uploader.mounted_as
      if source.is_a?(CarrierWave::Uploader::Base)

• Read up
  Read up

Method start_migration has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def start_migration
      if persisted? && (changed_attributes.key?('file_store') || changed_attributes.key?('public_read'))
        if Setup::FileStoreMigration.cannot_migrate?(data_type)
          errors.add(:file_store, 'can not be updated')
        else

• Read up
  Read up

Method validates_configuration has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def validates_configuration
      [:before_save_callbacks, :after_save_callbacks].each do |association|
        invalid_algorithms = []
        self.send(association).each { |algorithm| invalid_algorithms << algorithm unless algorithm.parameters.size == 1 }
        if invalid_algorithms.present?

• Read up
  Read up

Method match? has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def match?(path)
      @request_path = path
      @path_params = {}
      tokens = self.path.split('/').from(1)
      path_tokens = path.split('/')

• Read up
  Read up

Method validates_pull_parameters has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def validates_pull_parameters
      with_errors = false
      data =
        if installed
          if new_record?

• Read up
  Read up

Method validate_data has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def validate_data(data)
      unless data.is_a?(Nokogiri::XML::Document)
        unless data.is_a?(String)
          data =
            if data.respond_to?(:to_xml)

• Read up
  Read up

Method update has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def update
      parser_options = self.parser_options.dup
      parser_options[:add_only] = true
      async = klass.is_a?(Class) && klass < Setup::AsynchronousPersistence::Model
      if async

• Read up
  Read up

Method get_digest_origins has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def get_digest_origins(_request, _options = {})
      model = records_model
      origins =
        if (model.is_a?(Class) && model < CrossOrigin::Document) || model == Collection
          origins = model.origins

• Read up
  Read up

Method handle_delete_digest has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def handle_delete_digest(controller)
      query = where(controller.query_selector)
      response =
        if query.count == 1
          item = query.first

• Read up
  Read up

Method can? has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

  def can?(action, subject, *extra_args)
    return true if action == :digest
    if action == :json_edit
      subject.is_a?(Mongoff::Record) && !subject.is_a?(Mongoff::GridFs::File)
    elsif (action == :simple_cross && crossing_models.exclude?(subject.is_a?(Class) ? subject : subject.class)) ||

• Read up
  Read up