Sign upLogin

3scale/porta

View on GitHub
Star

Showing 5,269 of 5,606 total issues

CmsBlog#self.up calls 't.integer :version' 8 times
Open

        t.integer :version
        t.integer :lock_version, :default => 0
        t.boolean :published, :default => false
        t.boolean :deleted, :default => false
        t.boolean :archived, :default => false
Severity: Minor
Found in db/migrate/20100216080646_cms_blog.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.

CmsNews#self.up calls 't.integer :attachment_version' 2 times
Open

      t.integer :attachment_version
      t.text :summary
      t.text :body, :size => (64.kilobytes + 1)
      t.integer :version
      t.integer :lock_version, :default => 0
Severity: Minor
Found in db/migrate/20100216080656_cms_news.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.

CmsNews#self.up calls 't.integer :version' 2 times
Open

      t.integer :version
      t.integer :lock_version, :default => 0
      t.boolean :published, :default => false
      t.boolean :deleted, :default => false
      t.boolean :archived, :default => false
Severity: Minor
Found in db/migrate/20100216080656_cms_news.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.

CmsNews#self.up calls 't.string :name' 2 times
Open

      t.string :name
      t.string :slug
      t.datetime :release_date
      t.belongs_to :category
      t.belongs_to :attachment
Severity: Minor
Found in db/migrate/20100216080656_cms_news.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.

CmsNews#self.up calls 't.string :slug' 2 times
Open

      t.string :slug
      t.datetime :release_date
      t.belongs_to :category
      t.belongs_to :attachment
      t.integer :attachment_version
Severity: Minor
Found in db/migrate/20100216080656_cms_news.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.

CmsStreams#self.up calls 't.belongs_to :tag' 2 times
Open

      t.belongs_to :tag
      t.integer :version
      t.integer :lock_version, :default => 0
      t.boolean :published, :default => false
      t.boolean :deleted, :default => false
Severity: Minor
Found in db/migrate/20100216120713_cms_streams.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.

CmsStreams#self.up calls 't.string :slug' 2 times
Open

      t.string :slug
      t.belongs_to :attachment
      t.integer :attachment_version
      t.text :body, :size => (64.kilobytes + 1)
      t.belongs_to :category
Severity: Minor
Found in db/migrate/20100216120713_cms_streams.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.

InjectEssentialAssetsToLiquidLayouts#self.up calls 'body =~ essential_assets_re' 2 times
Open

      unless body =~ essential_assets_re
        body.sub!(/<meta\s+http\-equiv\s*=\s*"Content-Type".*>/i, "\\0\n\n  {{ essential_assets }}")
        body.sub!(/<head.*>/, "\\0\n\n  {{ essential_assets }}") unless body =~ essential_assets_re
Severity: Minor
Found in db/migrate/20100929103536_inject_essential_assets_to_liquid_layouts.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.

FirstPublishedAccountAndServicePlansGoDefault#self.up calls 'p.services' 3 times
Open

      service_plan = p.services.first.service_plans.default_or_nil || p.services.first.service_plans.first
      account_plan = p.account_plans.default_or_nil  || p.account_plans.first
      p.services.first.service_plans.default!(service_plan)
Severity: Minor
Found in db/migrate/20110412120607_first_published_account_and_service_plans_go_default.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.

RemovingTheNewsPortlets#self.down calls 't.integer "attachment_version"' 2 times
Open

      t.integer  "attachment_version"
      t.text     "summary"
      t.text     "body"
      t.boolean  "published",          :default => false
      t.boolean  "deleted",            :default => false
Severity: Minor
Found in db/migrate/20120109110445_removing_the_news_portlets.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.

SystemNameUniqueIndex#self.up calls 'r.system_name' 2 times
Open

          new = "#{r.system_name}_#{SecureRandom.hex(2)}"
          puts "Changing #{model.to_s} #{r.system_name} to #{new}"
Severity: Minor
Found in db/migrate/20120130115941_system_name_unique_index.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.

RemovingBcmsTables#self.down calls 't.boolean "deleted", :default => false' 21 times
Open

      t.boolean  "deleted",                      :default => false
      t.boolean  "archived",                     :default => false
      t.string   "version_comment"
      t.integer  "created_by_id",   :limit => 8
      t.integer  "updated_by_id",   :limit => 8
Severity: Minor
Found in db/migrate/20121018100514_removing_bcms_tables.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.

RemovingBcmsTables#self.down calls 't.integer "author_id", :limit => 8' 2 times
Open

      t.integer  "author_id",           :limit => 8
      t.integer  "category_id",         :limit => 8
      t.string   "name"
      t.string   "slug"
      t.text     "summary"
Severity: Minor
Found in db/migrate/20121018100514_removing_bcms_tables.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.

RemovingBcmsTables#self.down calls 't.integer "page_id", :limit => 8' 3 times
Open

      t.integer  "page_id",             :limit => 8
      t.integer  "page_version"
      t.integer  "connectable_id",      :limit => 8
      t.string   "connectable_type",    :limit => 50
      t.integer  "connectable_version"
Severity: Minor
Found in db/migrate/20121018100514_removing_bcms_tables.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.

RemovingBcmsTables#self.down calls 't.string "file_location"' 2 times
Open

      t.string   "file_location"
      t.string   "file_extension"
      t.string   "file_type"
      t.integer  "file_size"
      t.datetime "created_at"
Severity: Minor
Found in db/migrate/20121018100514_removing_bcms_tables.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.

ChangeMetricsAssociations#self.down calls 't.remove_belongs_to :contract' 2 times
Open

      t.remove_belongs_to :contract
    end

    change_table :usage_limits do |t|
      t.remove_belongs_to :contract
Severity: Minor
Found in db/migrate/20080716113318_change_metrics_associations.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.

TablesForBeast#self.up calls 't.integer "posts_count", :default => 0' 3 times
Open

    t.integer "posts_count",      :default => 0
    t.integer "position",         :default => 0
    t.text    "description_html"
    t.string  "state",            :default => "public"
    t.string  "permalink"
Severity: Minor
Found in db/migrate/20081112151449_tables_for_beast.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.

BrowserCmsTables#self.up calls 't.boolean "archived", :default => false' 13 times
Open

      t.boolean  "archived",        :default => false
      t.string   "version_comment"
      t.integer  "created_by_id"
      t.integer  "updated_by_id"
    end
Severity: Minor
Found in db/migrate/20100125103539_browser_cms_tables.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.

BrowserCmsTables#self.up calls 't.boolean "new_window", :default => false' 2 times
Open

      t.boolean  "new_window",      :default => false
      t.datetime "created_at"
      t.datetime "updated_at"
      t.boolean  "published",       :default => false
      t.boolean  "deleted",         :default => false
Severity: Minor
Found in db/migrate/20100125103539_browser_cms_tables.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.

Severity
Category
Status
Source
Language