rubocop-pixelforce 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21571919cdfc1f3ec42641eb3d4d6c8f383773ee285e3c8222c7117e6259cfd7
+  data.tar.gz: 5c11a46f1f2a3e29ea0e4ac34ef192c95aedbca917be5b7780c57abe90546b11
+SHA512:
+  metadata.gz: b7185e91a5ee8b961caed63b085b9c9d29dc186f3f21eaa157f08c6031934f0b45dee421a8034ab2db2b9805566db7513f2b61fcd17364f4ee8018dc271b1845
+  data.tar.gz: ac13031680fb145c6e8e30da1746f19ba243f2c93d974011cd1970d5a604644c46a72aa7a385e452cb8a856d454d411ff757af8995bb0aa2e81d140fe6c410d8

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.4.7
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rubocop-pixelforce.gemspec
+gemspec

data/README.md

@@ -0,0 +1,69 @@
+# Rubocop::Pixelforce
+
+Custom Rubocop cop for PixlForce
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rubocop-pixelforce'
+```
+
+And then execute:
+
+    $ bundle
+
+and create .rubocop file like this
+
+```
+inherit_gem:
+  rubocop-pixelforce: default.yml
+```
+
+## Pixelforce/ClassStructure: Don't Use empty lines between same categories.
+
+```ruby
+# bad
+belongs_to :user
+
+belongs_to :category
+
+after_commit :update_geo_location
+
+# good
+belongs_to :user
+belongs_to :category
+
+after_commit :update_geo_location
+```
+
+## Pixelforce/ClassStructure: Use empty lines between categories.
+
+```ruby
+# bad
+enum status: { draft: 0, active: 1, approved: 2, declined: 3 }
+belongs_to :user
+belongs_to :category
+after_commit :update_geo_location
+
+# good
+enum status: { draft: 0, active: 1, approved: 2, declined: 3 }
+
+belongs_to :user
+belongs_to :category
+
+after_commit :update_geo_location
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rubocop-pixelforce.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rubocop/pixelforce"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/default.yml

@@ -0,0 +1,134 @@
+require: 
+  - rubocop-performance
+  - rubocop-rails
+  - rubocop-pixelforce
+
+AllCops:
+  Exclude:
+    - 'Gemfile'
+    - 'db/**/*'
+    - 'bin/*'
+
+Rails/UnknownEnv:
+  Environments:
+    - production
+    - development
+    - test
+    - staging
+
+Rails/FilePath:
+  Enabled: false
+
+Pixelforce/ClassStructure:
+  Enabled: true
+  ExpectedOrder:
+    - module_inclusion
+    - constants
+    - attr_macros
+    - association
+    - public_attribute_macros
+    - public_delegate
+    - macros
+    - callbacks
+    - public_class_methods
+    - initializer
+    - public_methods
+    - protected_attribute_macros
+    - protected_methods
+    - private_attribute_macros
+    - private_delegate
+    - private_methods
+  Categories:
+    attr_macros:
+      - attr_accessor
+      - enum
+    association:
+      - belongs_to
+      - has_many
+      - has_one
+    public_attribute_macros:
+      - accepts_nested_attributes_for
+    attribute_macros:
+      - attr_accessor
+      - attr_reader
+      - attr_writer
+    callbacks:
+      - before_create
+      - before_save
+      - before_update
+      - before_validation
+      - before_destroy
+      - before_commit
+      - after_create
+      - after_save
+      - after_update
+      - after_validation
+      - after_destroy
+      - after_commit
+    macros:
+      - validates
+      - validate
+    module_inclusion:
+      - include
+      - prepend
+      - extend
+
+Layout/AlignHash:
+  EnforcedColonStyle: table
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Style/NestedTernaryOperator:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Documentation:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/TernaryParentheses:
+  Enabled: false
+
+Style/GlobalVars:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false

data/lib/rubocop-pixelforce.rb

@@ -0,0 +1,3 @@
+require 'rubocop'
+
+require 'rubocop/cop/pixelforce/class_structure'

data/lib/rubocop/cop/pixelforce/class_structure.rb

@@ -0,0 +1,225 @@
+module RuboCop
+  module Cop
+    module Pixelforce
+      class ClassStructure < Cop
+        HUMANIZED_NODE_TYPE = {
+          casgn: :constants,
+          defs: :class_methods,
+          def: :public_methods,
+          sclass: :class_singleton
+        }.freeze
+
+        VISIBILITY_SCOPES = %i[private protected public].freeze
+        MSG = '`%<category>s` is supposed to appear before ' \
+              '`%<previous>s`.'
+
+        def_node_matcher :visibility_block?, <<~PATTERN
+          (send nil? { :private :protected :public })
+        PATTERN
+
+        # Validates code style on class declaration.
+        # Add offense when find a node out of expected order.
+        def on_class(class_node)
+          previous = -1
+          previous_category = nil
+          previous_node_end_line = -1
+          previous_method_name = nil
+          walk_over_nested_class_definition(class_node) do |node, category|
+            index = expected_order.index(category)
+            if index < previous
+              message = format(MSG, category: category,
+                                    previous: expected_order[previous])
+              add_offense(node, message: message)
+            end
+
+            if previous_category && category != previous_category && node.loc.first_line - previous_node_end_line < 2
+              add_offense(node, message: "Use empty lines between categories.")
+            end
+
+            if previous_method_name && previous_method_name == node.method_name && node.loc.first_line - previous_node_end_line > 1
+              add_offense(node, message: "Don't Use empty lines between same categories.")
+            end
+            previous = index
+            previous_category = category
+            previous_node_end_line = node.loc.last_line
+            previous_method_name = node.method_name
+          end
+        end
+
+        # Autocorrect by swapping between two nodes autocorrecting them
+        def autocorrect(node)
+          node_classification = classify(node)
+          previous = left_siblings_of(node).find do |sibling|
+            classification = classify(sibling)
+            !ignore?(classification) && node_classification != classification
+          end
+
+          current_range = source_range_with_comment(node)
+          previous_range = source_range_with_comment(previous)
+
+          lambda do |corrector|
+            corrector.insert_before(previous_range, current_range.source)
+            corrector.remove(current_range)
+          end
+        end
+
+        private
+
+        # Classifies a node to match with something in the {expected_order}
+        # @param node to be analysed
+        # @return String when the node type is a `:block` then
+        #   {classify} recursively with the first children
+        # @return String when the node type is a `:send` then {find_category}
+        #   by method name
+        # @return String otherwise trying to {humanize_node} of the current node
+        def classify(node)
+          return node.to_s unless node.respond_to?(:type)
+
+          case node.type
+          when :block
+            classify(node.send_node)
+          when :send
+            find_category(node)
+          else
+            humanize_node(node)
+          end.to_s
+        end
+
+        # Categorize a node according to the {expected_order}
+        # Try to match {categories} values against the node's method_name given
+        # also its visibility.
+        # @param node to be analysed.
+        # @return [String] with the key category or the `method_name` as string
+        def find_category(node)
+          name = node.method_name.to_s
+          category, = categories.find { |_, names| names.include?(name) }
+          key = category || name
+          visibility_key = "#{node_visibility(node)}_#{key}"
+          expected_order.include?(visibility_key) ? visibility_key : key
+        end
+
+        def walk_over_nested_class_definition(class_node)
+          class_elements(class_node).each do |node|
+            classification = classify(node)
+            next if ignore?(classification)
+
+            yield node, classification
+          end
+        end
+
+        def class_elements(class_node)
+          class_def = class_node.body
+
+          return [] unless class_def
+
+          if class_def.def_type? || class_def.send_type?
+            [class_def]
+          else
+            class_def.children.compact
+          end
+        end
+
+        def ignore?(classification)
+          classification.nil? ||
+            classification.to_s.end_with?('=') ||
+            expected_order.index(classification).nil?
+        end
+
+        def node_visibility(node)
+          scope = find_visibility_start(node)
+          scope&.method_name || :public
+        end
+
+        def find_visibility_start(node)
+          left_siblings_of(node)
+            .reverse
+            .find(&method(:visibility_block?))
+        end
+
+        # Navigate to find the last protected method
+        def find_visibility_end(node)
+          possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+          right = right_siblings_of(node)
+          right.find do |child_node|
+            possible_visibilities.include?(node_visibility(child_node))
+          end || right.last
+        end
+
+        def siblings_of(node)
+          node.parent.children
+        end
+
+        def right_siblings_of(node)
+          siblings_of(node)[node.sibling_index..-1]
+        end
+
+        def left_siblings_of(node)
+          siblings_of(node)[0, node.sibling_index]
+        end
+
+        def humanize_node(node)
+          if node.def_type?
+            return :initializer if node.method?(:initialize)
+
+            return "#{node_visibility(node)}_methods"
+          end
+          HUMANIZED_NODE_TYPE[node.type] || node.type
+        end
+
+        def source_range_with_comment(node)
+          begin_pos, end_pos =
+            if node.def_type?
+              start_node = find_visibility_start(node) || node
+              end_node = find_visibility_end(node) || node
+              [begin_pos_with_comment(start_node),
+               end_position_for(end_node) + 1]
+            else
+              [begin_pos_with_comment(node), end_position_for(node)]
+            end
+
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def end_position_for(node)
+          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          buffer.line_range(end_line).end_pos
+        end
+
+        def begin_pos_with_comment(node)
+          annotation_line = node.first_line - 1
+          first_comment = nil
+
+          processed_source.comments_before_line(annotation_line)
+                          .reverse_each do |comment|
+            if comment.location.line == annotation_line
+              first_comment = comment
+              annotation_line -= 1
+            end
+          end
+
+          start_line_position(first_comment || node)
+        end
+
+        def start_line_position(node)
+          buffer.line_range(node.loc.line).begin_pos - 1
+        end
+
+        def buffer
+          processed_source.buffer
+        end
+
+        # Load expected order from `ExpectedOrder` config.
+        # Define new terms in the expected order by adding new {categories}.
+        def expected_order
+          cop_config['ExpectedOrder']
+        end
+
+        # Setting categories hash allow you to group methods in group to match
+        # in the {expected_order}.
+        def categories
+          cop_config['Categories']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/pixelforce.rb

@@ -0,0 +1,6 @@
+require "rubocop/pixelforce/version"
+
+module Rubocop
+  module Pixelforce
+  end
+end

data/lib/rubocop/pixelforce/version.rb

@@ -0,0 +1,5 @@
+module Rubocop
+  module Pixelforce
+    VERSION = "0.1.0"
+  end
+end

data/rubocop-pixelforce.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rubocop/pixelforce/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubocop-pixelforce"
+  spec.version       = Rubocop::Pixelforce::VERSION
+  spec.authors       = ["Ben Zhang"]
+  spec.email         = ["bzbnhang@gmail.com"]
+
+  spec.summary       = %q{Custom Rubocop cop for PixelForce.}
+  spec.description   = %q{Use empty lines between categories and Don't Use empty lines between same categories.}
+  spec.homepage      = "https://github.com/BenZhang/rubocop-pixelforce"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/BenZhang/rubocop-pixelforce"
+  spec.metadata["changelog_uri"] = "https://github.com/BenZhang/rubocop-pixelforce"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_runtime_dependency "rubocop", "~> 0.76"
+  spec.add_runtime_dependency "rubocop-performance"
+  spec.add_runtime_dependency "rubocop-rails"
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-pixelforce
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ben Zhang
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.76'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.76'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use empty lines between categories and Don't Use empty lines between
+  same categories.
+email:
+- bzbnhang@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- default.yml
+- lib/rubocop-pixelforce.rb
+- lib/rubocop/cop/pixelforce/class_structure.rb
+- lib/rubocop/pixelforce.rb
+- lib/rubocop/pixelforce/version.rb
+- rubocop-pixelforce.gemspec
+homepage: https://github.com/BenZhang/rubocop-pixelforce
+licenses: []
+metadata:
+  homepage_uri: https://github.com/BenZhang/rubocop-pixelforce
+  source_code_uri: https://github.com/BenZhang/rubocop-pixelforce
+  changelog_uri: https://github.com/BenZhang/rubocop-pixelforce
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.10
+signing_key: 
+specification_version: 4
+summary: Custom Rubocop cop for PixelForce.
+test_files: []