Sign upLogin

3scale/porta

View on GitHub
Star
db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.rb

Summary

Maintainability
A
3 hrs
Test Coverage

Method down has 45 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  def self.down
    create_table :liquid_pages do |table|
      table.integer :account_id
      table.string  :title
      table.text    :content
Severity: Minor
Found in db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.rb - About 1 hr to fix

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

      def self.up
    execute('INSERT INTO dynamic_views (
               version,
               type,
               name,
    Severity: Minor
    Found in db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.rb - About 1 hr to fix

      MoveLiquidPagesOverToDynamicViews#self.down has approx 16 statements
      Open

        def self.down
      Severity: Minor
      Found in db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.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.)

      MoveLiquidPagesOverToDynamicViews#self.down calls 'table.integer :account_id' 2 times
      Open

            table.integer :account_id
      table.string  :title
      table.text    :content
      table.integer :version
      table.timestamps
      Severity: Minor
      Found in db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.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.

      MoveLiquidPagesOverToDynamicViews#self.down calls 'table.integer :version' 2 times
      Open

            table.integer :version
      table.timestamps
    end

    create_table :liquid_page_versions do |table|
      Severity: Minor
      Found in db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.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.

      MoveLiquidPagesOverToDynamicViews#self.down calls 'table.text :content' 2 times
      Open

            table.text    :content
      table.integer :version
      table.timestamps
    end
      Severity: Minor
      Found in db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.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.

      MoveLiquidPagesOverToDynamicViews#self.down calls 'table.string :title' 2 times
      Open

            table.string  :title
      table.text    :content
      table.integer :version
      table.timestamps
    end
      Severity: Minor
      Found in db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.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.

      MoveLiquidPagesOverToDynamicViews#self.down calls 'table.timestamps' 2 times
      Open

            table.timestamps
    end

    create_table :liquid_page_versions do |table|
      table.integer :liquid_page_id
      Severity: Minor
      Found in db/migrate/20101110130607_move_liquid_pages_over_to_dynamic_views.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.

      There are no issues that match your filters.

      Category
      Status