sanger/sequencescape

View on GitHub
app/controllers/samples_controller.rb

Summary

Maintainability
A
2 hrs
Test Coverage
F
52%

Complex method SamplesController#taxon_lookup (49.2)
Open

  def taxon_lookup # rubocop:todo Metrics/AbcSize
    if params[:term]
      url = configatron.taxon_lookup_url + "/esearch.fcgi?db=taxonomy&term=#{params[:term].gsub(/\s/, '_')}"
    elsif params[:id]
      url = configatron.taxon_lookup_url + "/efetch.fcgi?db=taxonomy&mode=xml&id=#{params[:id]}"
Severity: Minor
Found in app/controllers/samples_controller.rb by flog

Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

You can read more about ABC metrics or the flog tool

Method default_permitted_metadata_fields has 54 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  def default_permitted_metadata_fields
    {
      sample_metadata_attributes: %i[
        consent_withdrawn
        organism
Severity: Major
Found in app/controllers/samples_controller.rb - About 2 hrs to fix

    Complex method SamplesController#accession (38.8)
    Open

      def accession # rubocop:todo Metrics/AbcSize
        @sample = Sample.find(params[:id])
        @sample.validate_ena_required_fields!
        @sample.accession_service.submit_sample_for_user(@sample, current_user)
    
    
    Severity: Minor
    Found in app/controllers/samples_controller.rb by flog

    Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

    You can read more about ABC metrics or the flog tool

    Complex method SamplesController#create (37.4)
    Open

      def create # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
        @sample = Sample.new(params[:sample])
    
        study_id = params[:study_id]
        if study_id
    Severity: Minor
    Found in app/controllers/samples_controller.rb by flog

    Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

    You can read more about ABC metrics or the flog tool

    Complex method SamplesController#update (29.1)
    Open

      def update # rubocop:todo Metrics/AbcSize
        @sample = Sample.find(params[:id])
        authorize! :update, @sample
    
        cleaned_params = params[:sample].permit(default_permitted_metadata_fields)
    Severity: Minor
    Found in app/controllers/samples_controller.rb by flog

    Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

    You can read more about ABC metrics or the flog tool

    SamplesController#accession has approx 17 statements
    Open

      def accession # rubocop:todo Metrics/AbcSize
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    SamplesController#taxon_lookup has approx 14 statements
    Open

      def taxon_lookup # rubocop:todo Metrics/AbcSize
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    SamplesController#release has approx 6 statements
    Open

      def release
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    SamplesController#show has approx 8 statements
    Open

      def show
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    SamplesController#update has approx 9 statements
    Open

      def update # rubocop:todo Metrics/AbcSize
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    SamplesController#add_to_study has approx 7 statements
    Open

      def add_to_study # rubocop:todo Metrics/AbcSize
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    SamplesController#edit has approx 11 statements
    Open

      def edit # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    SamplesController#index has approx 6 statements
    Open

      def index
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    SamplesController#create has approx 19 statements
    Open

      def create # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    A method with Too Many Statements is any method that has a large number of lines.

    Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

    So the following method would score +6 in Reek's statement-counting algorithm:

    def parse(arg, argv, &error)
      if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
        return nil, block, nil                                         # +1
      end
      opt = (val = parse_arg(val, &error))[1]                          # +2
      val = conv_arg(*val)                                             # +3
      if opt and !arg
        argv.shift                                                     # +4
      else
        val[0] = nil                                                   # +5
      end
      val                                                              # +6
    end

    (You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

    Complex method SamplesController#add_to_study (23.3)
    Open

      def add_to_study # rubocop:todo Metrics/AbcSize
        sample = Sample.find(params[:id])
        study = Study.find(params[:study][:id])
        study.samples << sample
        redirect_to sample_path(sample)
    Severity: Minor
    Found in app/controllers/samples_controller.rb by flog

    Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

    You can read more about ABC metrics or the flog tool

    SamplesController#add_to_study calls 'sample_path(sample)' 2 times
    Open

        redirect_to sample_path(sample)
      rescue ActiveRecord::RecordInvalid => e
        flash[:error] = e.record.errors.full_messages
        redirect_to sample_path(sample)
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#accession calls 'sample_path(@sample)' 4 times
    Open

        redirect_to(sample_path(@sample))
      rescue ActiveRecord::RecordInvalid => e
        flash[:error] = "Please fill in the required fields: #{@sample.errors.full_messages.join(', ')}"
        redirect_to(edit_sample_path(@sample))
      rescue AccessionService::NumberNotRequired => e
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#create calls 'format.xml' 2 times
    Open

            format.xml { render xml: @sample, status: :created, location: @sample }
            format.json { render json: @sample, status: :created, location: @sample }
          else
            flash[:error] = 'Problems creating your new sample'
            format.html { render action: :new }
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#create calls 'format.html' 2 times
    Open

            format.html { redirect_to sample_path(@sample) }
            format.xml { render xml: @sample, status: :created, location: @sample }
            format.json { render json: @sample, status: :created, location: @sample }
          else
            flash[:error] = 'Problems creating your new sample'
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#taxon_lookup calls 'params[:id]' 2 times
    Open

        elsif params[:id]
          url = configatron.taxon_lookup_url + "/efetch.fcgi?db=taxonomy&mode=xml&id=#{params[:id]}"
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#create calls 'format.json' 2 times
    Open

            format.json { render json: @sample, status: :created, location: @sample }
          else
            flash[:error] = 'Problems creating your new sample'
            format.html { render action: :new }
            format.xml { render xml: @sample.errors, status: :unprocessable_entity }
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#taxon_lookup calls 'render plain: body' 2 times
    Open

          format.js { render plain: body }
          format.xml { render plain: body }
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#remove_from_study calls 'params[:study_id]' 2 times
    Open

        study = Study.find(params[:study_id])
        sample = Sample.find(params[:id])
        StudySample.find_by(study_id: params[:study_id], sample_id: params[:id]).destroy
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#accession calls 'e.message' 3 times
    Open

        flash[:warning] = e.message || 'An accession number is not required for this study'
        redirect_to(sample_path(@sample))
      rescue AccessionService::NumberNotGenerated => e
        flash[:warning] = "No accession number was generated: #{e.message}"
        redirect_to(sample_path(@sample))
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#create calls '@sample.errors' 2 times
    Open

            format.xml { render xml: @sample.errors, status: :unprocessable_entity }
            format.json { render json: @sample.errors, status: :unprocessable_entity }
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#remove_from_study calls 'params[:id]' 2 times
    Open

        sample = Sample.find(params[:id])
        StudySample.find_by(study_id: params[:study_id], sample_id: params[:id]).destroy
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#add_to_study calls 'redirect_to sample_path(sample)' 2 times
    Open

        redirect_to sample_path(sample)
      rescue ActiveRecord::RecordInvalid => e
        flash[:error] = e.record.errors.full_messages
        redirect_to sample_path(sample)
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#release calls '@sample.name' 2 times
    Open

          flash[:notice] = "Sample '#{@sample.name}' already publically released"
        else
          @sample.release
          flash[:notice] = "Sample '#{@sample.name}' publically released"
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#taxon_lookup calls 'ENV['http_proxy']' 2 times
    Open

        elsif ENV['http_proxy'].present?
          RestClient.proxy = ENV['http_proxy']
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#accession calls 'redirect_to(sample_path(@sample))' 4 times
    Open

        redirect_to(sample_path(@sample))
      rescue ActiveRecord::RecordInvalid => e
        flash[:error] = "Please fill in the required fields: #{@sample.errors.full_messages.join(', ')}"
        redirect_to(edit_sample_path(@sample))
      rescue AccessionService::NumberNotRequired => e
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#taxon_lookup calls 'configatron.taxon_lookup_url' 2 times
    Open

          url = configatron.taxon_lookup_url + "/esearch.fcgi?db=taxonomy&term=#{params[:term].gsub(/\s/, '_')}"
        elsif params[:id]
          url = configatron.taxon_lookup_url + "/efetch.fcgi?db=taxonomy&mode=xml&id=#{params[:id]}"
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    SamplesController#taxon_lookup calls 'params[:term]' 2 times
    Open

        if params[:term]
          url = configatron.taxon_lookup_url + "/esearch.fcgi?db=taxonomy&term=#{params[:term].gsub(/\s/, '_')}"
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

    Reek implements a check for Duplicate Method Call.

    Example

    Here's a very much simplified and contrived example. The following method will report a warning:

    def double_thing()
      @other.thing + @other.thing
    end

    One quick approach to silence Reek would be to refactor the code thus:

    def double_thing()
      thing = @other.thing
      thing + thing
    end

    A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

    class Other
      def double_thing()
        thing + thing
      end
    end

    The approach you take will depend on balancing other factors in your code.

    Complex method SamplesController#edit (21.6)
    Open

      def edit # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
        @sample = Sample.find(params[:id])
        authorize! :update, @sample
    
        if @sample.released? && cannot?(:update_released, @sample)
    Severity: Minor
    Found in app/controllers/samples_controller.rb by flog

    Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

    You can read more about ABC metrics or the flog tool

    Complex method SamplesController#remove_from_study (21.0)
    Open

      def remove_from_study # rubocop:todo Metrics/AbcSize
        study = Study.find(params[:study_id])
        sample = Sample.find(params[:id])
        StudySample.find_by(study_id: params[:study_id], sample_id: params[:id]).destroy
        flash[:notice] = "Sample was removed from study #{study.name.humanize}"
    Severity: Minor
    Found in app/controllers/samples_controller.rb by flog

    Flog calculates the ABC score for methods. The ABC score is based on assignments, branches (method calls), and conditions.

    You can read more about ABC metrics or the flog tool

    Method taxon_lookup has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
    Open

      def taxon_lookup # rubocop:todo Metrics/AbcSize
        if params[:term]
          url = configatron.taxon_lookup_url + "/esearch.fcgi?db=taxonomy&term=#{params[:term].gsub(/\s/, '_')}"
        elsif params[:id]
          url = configatron.taxon_lookup_url + "/efetch.fcgi?db=taxonomy&mode=xml&id=#{params[:id]}"
    Severity: Minor
    Found in app/controllers/samples_controller.rb - About 25 mins to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    SamplesController#add_to_study has the variable name 'e'
    Open

      rescue ActiveRecord::RecordInvalid => e
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    An Uncommunicative Variable Name is a variable name that doesn't communicate its intent well enough.

    Poor names make it hard for the reader to build a mental picture of what's going on in the code. They can also be mis-interpreted; and they hurt the flow of reading, because the reader must slow down to interpret the names.

    SamplesController#accession has the variable name 'e'
    Open

      rescue ActiveRecord::RecordInvalid => e
        flash[:error] = "Please fill in the required fields: #{@sample.errors.full_messages.join(', ')}"
        redirect_to(edit_sample_path(@sample))
      rescue AccessionService::NumberNotRequired => e
        flash[:warning] = e.message || 'An accession number is not required for this study'
    Severity: Minor
    Found in app/controllers/samples_controller.rb by reek

    An Uncommunicative Variable Name is a variable name that doesn't communicate its intent well enough.

    Poor names make it hard for the reader to build a mental picture of what's going on in the code. They can also be mis-interpreted; and they hurt the flow of reading, because the reader must slow down to interpret the names.

    There are no issues that match your filters.

    Category
    Status