rspec_api_blueprint_matchers 0.1.2 → 0.1.3

data/config/rubocop/.metrics_rubocop.yml

@@ -0,0 +1,94 @@
+# Metrics::AbcSize
+# (Assignment Branch Condition)
+#
+# Checks that the ABC size of methods is not higher thatn the configured maximum
+
+Metrics/AbcSize:
+  Max: 15
+
+# Metrics::BlockLength
+#
+# Checks if the length of a block exceeds some maximum value.
+# Comment lines are ignored
+
+Metrics/BlockLength:
+  CountComments: false
+  Max: 25
+  Exclude:
+    - 'Rakefile'
+    - '**/*.rake'
+    - 'spec/**/*.rb'
+
+# Metrics::BlockNesting
+#
+# Checks for excessive nesting of conditional and looping constructs
+
+Metrics/BlockNesting:
+  Max: 3
+
+# Metrics::ClassLength
+#
+# Checks if the length of a class exceeds some maximum value.
+# This can be used to ensure 'one responsibility per class" rule.
+
+Metrics/ClassLength:
+  CountComments: false
+  Max: 100
+
+# Metrics::CyclomaticComplexity
+#
+# Checks that the cyclomatic complexity of methods is not higher than the configured maximum.
+# (Cyclomatic complexity is the number of linearly independent paths through a method)
+
+Metrics/CyclomaticComplexity:
+  Max: 6
+
+# Metrics::LineLength
+#
+# Checks the length of lines in the source code.
+
+Metrics/LineLength:
+  Max: 160
+  AllowHereDoc: true
+  AllowURI: true
+  URISchemes:
+    -http
+    -https
+  Exclude:
+  - "spec/**/*"
+  - "views/**/*"
+  - "public/**/*"
+
+# Metrics::MethodLength
+#
+# Checks if the length of the method exceeds some maximum value.
+
+Metrics/MethodLength:
+  CountComments: false
+  Max: 10
+
+# Metrics::ModuleLength
+#
+# Checks if the length of a module exceeds some maximum value.
+
+Metrics/ModuleLength:
+  CountComments: false
+  Max: 100
+
+# Metrics::ParameterLists
+#
+# Checks for methods with too many parameters.
+
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true
+
+
+# Metrics::PerceivedComplexity
+#
+# Tries to product a complexity score that's a measure of the complexity
+# the reader experiences when looking at a method.
+
+Metrics/PerceivedComplexity:
+  Max: 7
+

data/config/rubocop/.performance_rubocop.yml

@@ -0,0 +1,323 @@
+# Performance::CaseWhenSplat
+#
+# Place `when` conditions that use splat at the end of the list of `when` branches.
+#
+# bad:
+#
+#  case foo
+#  when *condition
+#    bar
+#  when baz
+#   foobar
+#  end
+#
+# good:
+#
+#  case foo
+#  when baz
+#    foobar
+#  when *condition
+#    bar
+#  end
+
+Performance/CaseWhenSplat:
+  Enabled: true
+
+# Performance::Casecmp
+#
+# Identifies places where a case-insensitive string comparison can better be implemented
+# using `casecmp`
+#
+# bad:  str.downcase == 'abc'
+#
+# good: str.casecmp('abc').zero?
+
+Performance/Casecmp:
+  Enabled: true
+
+# Performance::CompareWithBlock
+#
+# Identifies place where `sort{ |a, b| a.foo <=> b.foo }` can be replaced by `sort_by(&:foo)`.
+# This cop also checks `max` and `min` methods.
+#
+# bad:    array.sort { |a, b| a.foo <=> b.foo }
+#
+# good:   array.sort_by(&:foo)
+
+Performance/CompareWithBlock:
+  Enabled: true
+
+# Performance::Count
+#
+# Identifies usages of `count` on an `Enumerable` that follow calls to `select` or `reject`.
+# Querying logic can instead be passed to the `count` call.
+#
+# Example:
+#   Model.where(id: [1, 2, 3].select { |m| m.method == true }.size
+#   becomes ->
+#   Model.where(id: [1, 2, 3].to_a.count { |m| m.method == true }
+
+Performance/Count:
+  Enabled: true
+
+# Performance::Detect
+#
+# Identify usages of `select.first`, `select.last`, `find_all.first` and `find_all.last` and
+# change them to use `detect` instead
+# `ActiveRecord` compatibility: `ActiveRecord` does not implement a `detect` method and `find`
+# has its own meaning
+#
+# bad:
+#
+#   [].select { |item| true }.first
+#   [].find_all { |item| true ).last
+#
+# good:
+#
+#   [].detect { |item| true }
+#   [].reverse.detect { |item| true }
+
+Performance/Detect:
+  Enabled: true
+
+# Performance::DoubleStartEndWith
+#
+# Checks for double `#start_with?` or `#end_with?` calls separated by `||`.
+#
+# bad:  str.start_with?("a") || str.start_with?(Some::CONST)
+#
+# good: str.start_with?("a", Some::CONST)
+
+Performance/DoubleStartEndWith:
+  Enabled: true
+
+# Performance::EndWith
+#
+# Identifies unnecessary use of a regex where `String#end_with?` would suffice
+#
+# bad:
+#
+#  'abc' =~ /bc\Z/
+#  'abc'.match(/bc\Z/)
+#
+# good:
+#
+#  'abc' =~ /ab/
+#  'abc' =~ /\w*\Z/
+
+Performance::EndWith:
+  Enabled: true
+
+# Performance::FixedSize
+#
+# Do not compute the size of statically sized objects.
+
+Performance::FixedSize:
+  Enabled: true
+
+# Lint::FlatMap
+#
+# Used of identify usages of flatten with map and collect
+#
+# bad:
+#
+#  [1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
+#  [1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
+#
+# good:
+#
+#  [1, 2, 3, 4].flat_map { |e| [e, e] }
+#  [1, 2, 3, 4].map { |e| [e, e] }.flatten
+#  [1, 2, 3, 4].collect { |e| [e, e] }.flatten
+
+Performance/FlatMap:
+  Enabled: true
+
+# Performance::HashEachMethods
+#
+# Checks for uses of `each_key` and `each_value` Hash methods.
+#
+# bad:
+#
+#  hash.keys.each { |k| p k }
+#  hash.values.each { |v| p v }
+#
+# good:
+#
+#  hash.each_key { |k| p k }
+#  hash.each_value { |v| p v }
+
+Performance/HashEachMethods:
+  Enabled: true
+
+# Performance::LstripRstrip
+#
+# Identifies places where `lstrip.rstrip` can be replaced by `strip`
+#
+# bad:
+#
+#  'abc'.lstrip.rstrip
+#  'abc'.rstrip.lstrip
+#
+# good:
+#
+#   'abc'.strip
+
+Performance/LstripRstrip:
+  Enabled: true
+
+# Performance::RangeInclude
+#
+# Identifies uses of `Range#include?`, which iterates over each item in a `Range`
+# to see if a specified item is there. `Range#cover?` simply compares the target item
+# with the beginning and end points of the `Range`.
+#
+# Example: ('a'..'z').cover?('yellow')
+
+Performance/RangeInclude:
+  Enabled: true
+
+# Performance::RedundantBlockCall
+#
+# Identifies the use of a `&block` parameter and `block.call` where `yield` would do just as well.
+#
+# bad:
+#
+#  def method(&block)
+#    block.call
+#  end
+#
+# good:
+#
+#  def method
+#    yield
+#  end
+
+Performance/RedundantBlockCall:
+  Enabled: true
+
+# Performance::RedundantMatch
+#
+# Identifies use of `Regexp#match` or `String#match` in a context where the integral return
+# value of `=~` would do just well
+#
+# bad:
+#
+#  do_something if str.match(/regex/)
+#  while regex.match('str')
+#    do_something
+#  end
+#
+# good:
+#
+#  method(str.match(/regex/)
+#  return regex.match('str')
+
+Performance/RedundantMatch:
+  Enabled: true
+
+# Performance::RedundantMerge
+#
+# Identifies places where `Hash#merge!` can be replaced by `Hash#[]=`.
+#
+# Examples:
+#
+#  hash.merge!(a: 1)
+#  hash.merge!({key: 'value'})
+#  hash.merge1({ :a => 1, :b=> 2})
+
+Performance/RedundantMerge:
+  Enabled: false
+
+# Performance::RedundantSortBy
+#
+# Identifies places where `sort_by{ ... }` can be replaced by `sort`.
+#
+# bad:
+#
+#  array.sort_by { |x| x }
+#  array.sort_by do |var|
+#    var
+#  end
+#
+# good:
+#
+#  array.sort
+
+Performance/RedundantSortBy:
+  Enabled: true
+
+# Performance::ReverseEach
+#
+# Identify usages of `reverse.each` and change them to use `reverse_each` instead.
+#
+# bad:   [].reverse.each
+#
+# good:  [].reverse_each
+
+Performance/ReverseEach:
+  Enabled: true
+
+# Performance::Sample
+#
+# Identify usages of `shuffle.first`, `shuffle.last` and `shuffle[]` and change them to
+# use `sample` instead
+#
+# bad:   [1, 2, 3].shuffle.first
+#
+# good:  [1, 2, 3].sample
+
+Performance/Sample:
+  Enabled: true
+
+# Performance::Size
+#
+# Identify usages of `count` on an `Array` and `Hash` and change them to `size`.
+#
+# bad:    [1, 2, 3].count
+#
+# good:   [1, 2, 3].size
+
+Performance/Size:
+  Enabled: true
+
+# Performance::StartWith
+#
+# Identifies unnecessary use of a regex where `String#start_with?` would suffice
+#
+# bad:  'abc' =~ /\Aab/
+#
+# good: 'abc' =~ /ab/
+
+Performance/StartWith:
+  Enabled: true
+
+# Performance::StringReplacement
+#
+# Identifies places where `gsub` can be replaced by `tr` or `delete`
+#
+# bad:  'abc'.gsub('b', 'd')
+#
+# good: 'abc'.tr('b', 'd')
+
+Performance/StringReplacement:
+  Enabled: true
+
+# Performance::TimesMap
+#
+# Checks for .times.map calls. In most cases this can be replaced with an explicit array creation.
+#
+# bad:
+#
+#  9.times.map do |i|
+#    i.to_s
+#  end
+#
+# good:
+#
+#  Array.new(9) do |i|
+#    i.to_s
+#  end
+
+Performance/TimesMap:
+  Enabled: true

data/config/rubocop/.rails_rubocop.yml

@@ -0,0 +1,256 @@
+Rails:
+  Enabled: true
+
+# Rails::ActionFilter
+#
+# Enforces the consistent use of action filter methods.
+# This is configurable and can enforce user of
+# older something_filter methods of newer something_action methods
+
+Rails/ActionFilter:
+  EnforcedStyle: action
+
+# Rails::Date
+#
+# Checks for the correct use of Date methods
+#
+# bad:
+#
+#  Date.today
+#  date.to_time
+
+Rails/Date:
+  EnforcedStyle: flexible
+
+# Rails::Delegate
+#
+# Looks for delegations, that could have been created automatically with delegate method
+#
+# bad:
+#
+#   def bar
+#     foo.bar
+#   end
+#
+# good:
+#
+#   delegate :bar, to: :foo
+#
+
+Rails/Delegate:
+  Enabled: true
+
+# Rails::DelegateAllowBlank
+#
+# Looks for delegations that pass :allow_blank as an option instead of :allow_nil.
+
+Rails/DelegateAllowBlank:
+  Enabled: true
+
+# Rails::DynamicFindBy
+#
+# Checks dynamic `find_by_*` methods. Use `find_by` instead of dynamic method.
+# (When retrieve a single record by some attributes, prefer `find_by`)
+#  For more info: https://github.com/bbatsov/rails-style-guide#find_by
+#
+# bad: User.find_by_name(name)
+#
+# good: User.find_by(name: name)
+#
+
+Rails/DynamicFindBy:
+  Whitelist:
+  - find_by_sql
+
+# Rails::EnumUniqueness
+#
+# Looks for duplicate values in enum decorations.
+#
+# bad:    enum status { active: 0, archived: 0 }
+#
+# good:   enum status { active: 0, archived: 1 }
+
+Rails/EnumUniqueness:
+  Enabled: true
+
+# Rails::Exit
+#
+# Enforces that 'exit' calls are not used withing a rails app.
+
+Rails/Exit:
+  Enabled: true
+
+# Rails::FindBy
+#
+# Used to identify usages of `where.first` and change them to use `find_by` instead
+#
+# bad: User.where(name: 'Prasanna').first
+#
+# good: User.find_by(name: 'Prasanna')
+
+Rails/FindBy:
+  Enabled: true
+
+# Rails::FindEach
+#
+# Used to identify usages of `all.each` and change them to use `all.find_each` instead.
+#
+# bad: User.all.each
+#
+# good: User.all.find_each
+
+Rails/FindEach:
+  Enabled: true
+
+# Rails::HasAndBelongsToMany
+#
+# Checks for the use of the has_and_belongs_to_many macro
+# Prefer 'has_many :through'
+
+Rails/HasAndBelongsToMany:
+  Enabled: true
+
+# Rails::HttpPositionalArguments
+#
+# Identifies usages of http methods like 'get', 'post', 'put', 'path' without the usage
+# of keyword arguments in tests and change them to keyword arguments.
+#
+# bad:    get :new, { user_id: 1 }
+#
+# good:   get :new, params: { user_id: 1 }
+
+Rails/HttpPositionalArugments:
+  Enabled: false
+
+# Rails::NotNullColumn
+#
+# Checks for add_column call with NOT NULL constraint in migration file.
+#
+# bad:    add_column :users, :name, :string, null: false
+#
+# good:   add_column :users, :name, :string, null: false, default: ''
+
+Rails/NotNullColumn:
+  Enabled: false
+
+# Rails::Output
+#
+# Checks for the use of output calls like print and puts
+
+Rails/Output:
+  Enabled: true
+
+# Rails::OutputSafety
+#
+# Checks for the use of output safety calls like html_safe and raw
+#
+# bad:    "<p>#{text}></p>".html_safe
+#
+# good:   content_tag(:p, text)
+
+Rails/OutputSafety:
+  Enabled: true
+
+# Rails::PluralizationGrammar
+#
+# Checks for correct grammar when using ActiveSupport`s core extensions to the numeric classes.
+#
+# bad:
+#
+#   3.day.ago
+#   1.months.ago
+#
+# good:
+#
+#   3.days.ago
+#   1.month.ago
+
+Rails/PluralizationGrammar:
+  Enabled: true
+
+# Rails::ReadWriteGrammar
+#
+# Checks for the use of the read_attribute or write_attribute methods.
+#
+# bad:
+#
+#  x = read_attribute(:attr)
+#  write_attribute(:attr, val)
+#
+# good:
+#
+#  x = self[:attr]
+#  self[:attr] = val
+
+Rails/ReadWriteGrammer:
+  Enabled: true
+
+# Rails::RequestReferrer
+#
+# Checks for consistent uses of request.referrer
+
+Rails/ReadWriteGrammer:
+  EnforcedStyle: referer
+
+# Rails::SafeNavigation
+#
+# Converts usages of `try!` to `&.`. It can also be configured to convert `try`.
+# It will convert code to use navigation if the target Ruby version is set to 2.3+
+
+Rails/SafeNavigation:
+   ConvertTry: false
+
+# Rails::SafeBang
+#
+# Identifies possible cases where Active Record save! or related should be used
+# instead of save because the model might have failed to save and an excpetion is better
+# then unhandled failure
+#
+# bad:   user.save
+#
+# good:  user.save!
+
+Rails/SafeBang:
+  Enabled: true
+
+# Rails::ScopeArgs
+#
+# Checks for scope class where it was passed a method (usually a scope) instead of a lambda/proc.
+#
+# bad:   scope :something, where(something: true)
+#
+# good:  scope :something, -> { where(something: true) }
+
+Rails/ScopeArgs:
+  Enabled: true
+
+# Rails::Timezone
+#
+# Checks for the use of Time methods without zone
+#
+# bad:
+#
+#   Time.now
+#   Time.parse('2015-03-02 19:05:37')
+
+Rails/Timezone:
+  EnforcedStyle: flexible
+
+# Rails::UniqBeforePluck
+#
+# Prefer the use of uniq (or distinct), before pluck instead of after.
+#
+# bad:   Model.pluck(:id).uniq
+#
+# good:  Model.uniq.pluck(:id)
+
+Rails/UniqBeforePluck:
+  EnforcedMode: conservative
+  AutoCorrect: true
+
+# Rails::Validation
+#
+# Checks for the use of old-style attribute validation macros.
+
+Rails/Validation:
+  Enabled: true