kolekti_cc_phpmd 5.0.0

data/COPYING.lesser

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/Gemfile

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

data/README.md

@@ -0,0 +1,37 @@
+# KolektiCCPHPMD
+
+[![Code Climate](https://codeclimate.com/github/mezuro/kolekti_cc_phpmd.png)](https://codeclimate.com/github/mezuro/kolekti_cc_phpmd)
+
+Generic parser for Analizo static code metrics collector.
+
+## Contributing
+
+Please, have a look the wiki pages about development workflow and code standards:
+
+* https://github.com/mezuro/mezuro/wiki/Development-workflow
+* https://github.com/mezuro/mezuro/wiki/Standards
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kolekti_cc_phpmd'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kolekti_cc_phpmd
+
+## Usage
+
+Just register it into Kolekti with
+
+```ruby
+require 'kolekti'
+require 'kolekti_cc_phpmd'
+
+Kolekti.register_collector(Kolekti::CcPhpMd::Collector.new)
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+# Copied from https://github.com/cucumber/cucumber-ruby/blob/master/Rakefile#L6
+$:.unshift(File.dirname(__FILE__) + '/lib')
+Dir['gem_tasks/**/*.rake'].each { |rake| load rake }
+
+task :default => [:spec, :cucumber]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "kolekti_cc_phpmd"
+
+# 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

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/circle.yml

@@ -0,0 +1,11 @@
+machine:
+  services:
+    - docker
+
+dependencies:
+  pre:
+    # Workaround: replace docker command with one that ignores the --rm and --cap-drop options
+    - sudo cp scripts/docker-circle-ci /usr/local/bin/docker
+    - sudo chmod 755 /usr/local/bin/docker
+    - docker pull codeclimate/codeclimate-phpmd:latest
+    - gem install bundler

data/gem_tasks/cucumber.rake

@@ -0,0 +1,27 @@
+# Copied from https://github.com/cucumber/cucumber-ruby/blob/master/gem_tasks/cucumber.rake
+
+require 'cucumber/rake/task'
+require 'cucumber/platform'
+
+class Cucumber::Rake::Task
+  def set_profile_for_current_ruby
+    self.profile = if Cucumber::JRUBY
+      Cucumber::WINDOWS ? 'jruby_win' : 'jruby'
+    elsif Cucumber::WINDOWS_MRI
+      'windows_mri'
+    elsif Cucumber::RUBY_1_9
+      'ruby_1_9'
+    elsif Cucumber::RUBY_2_0
+      'ruby_2_0'
+    elsif Cucumber::RUBY_2_1
+      'ruby_2_1'
+    end
+  end
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.fork = true
+  t.set_profile_for_current_ruby
+end
+
+task :cucumber => :features

data/kolekti_cc_phpmd.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+version = File.read(File.expand_path("../../VERSION", __dir__)).strip
+
+Gem::Specification.new do |spec|
+  spec.name          = "kolekti_cc_phpmd"
+  spec.version       = version
+  spec.authors       = ["Daniel Miranda",
+                        "Diego Araújo",
+                        "Eduardo Araújo",
+                        "Rafael Reggiani Manzo"]
+  spec.email         = ["danielkza2@gmail.com",
+                        "diegoamc90@gmail.com",
+                        "duduktamg@hotmail.com",
+                        "rr.manzo@protonmail.com"]
+
+  spec.summary       = %q{Metric collecting support for PHP that servers Kolekti.}
+  spec.homepage      = "https://gitlab.com/mezuro/mezuro/tree/master/kalibro/kolekti_cc_phpmd"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  unless spec.respond_to?(:metadata)
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "codeclimate", "~>0.35.0"
+  spec.add_dependency "kolekti", "~> 1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "cucumber", "~> 2.1.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "factory_girl", "~> 4.5.0"
+  spec.add_development_dependency "codeclimate-test-reporter", '< 1.0.0'
+  spec.add_development_dependency "byebug"
+end

data/lib/kolekti/cc_phpmd.rb

@@ -0,0 +1,6 @@
+require "kolekti/cc_phpmd/version"
+require "kolekti/cc_phpmd/collector"
+
+module KolektiCcPhpmd
+  # Your code goes here...
+end

data/lib/kolekti/cc_phpmd/collector.rb

@@ -0,0 +1,65 @@
+require 'kolekti/cc_phpmd/parser'
+require 'kolekti/collector'
+require 'cc/cli'
+require 'cc/analyzer'
+require 'fileutils'
+
+module Kolekti
+  module CcPhpMd
+    class Collector < Kolekti::Collector
+      def self.create_cc_dir
+        old_umask = File.umask
+        begin
+          File.umask(022)
+          FileUtils.mkdir_p('/tmp/cc', mode: 0755)
+        ensure
+          File.umask(old_umask)
+        end
+      end
+
+      def self.available?
+        # Make sure the CodeClimate temporary directory is created world-readable,
+        # otherwise it may be possible for the container not to be able to properly
+        # access it.
+
+        # It has to be done before any CC invocation or Docker will create the directory
+        # owned by root (that behavior is fortunately deprecated starting with Docker 1.9)
+        create_cc_dir
+
+        system('docker inspect codeclimate/codeclimate-phpmd', [:out, :err] => '/dev/null') ? true : false
+      end
+
+      def initialize
+        supported_metrics = parse_supported_metrics(
+          File.expand_path("../metrics.yml", __FILE__),
+          'CodeClimate PHPMD', [:PHP])
+        super('CodeClimate PHPMD', 'PHP Mess Detector', supported_metrics)
+
+        self.class.create_cc_dir
+      end
+
+      def collect_metrics(code_directory, wanted_metric_configurations, persistence_strategy)
+        FileUtils.chmod_R "a+rX", code_directory
+        engine_registry = CC::Analyzer::EngineRegistry.new
+        parser = Kolekti::CcPhpMd::Parser.new(self, wanted_metric_configurations, persistence_strategy)
+
+        Dir.chdir(code_directory) do
+          runner = CC::Analyzer::EnginesRunner.new(engine_registry, parser, code_directory, @@config, [])
+          runner.run
+        end
+      end
+
+      def clean(code_directory, wanted_metric_configurations); end
+
+      private
+
+      def self.config
+        config = CC::Yaml::Nodes::Root.new
+        config["engines"] = CC::Yaml::Nodes::EngineList.new(config).with_value({})
+        config.engines["phpmd"] = CC::Yaml::Nodes::Engine.new(config.engines).with_value("enabled" => true)
+        config
+      end
+      @@config = self.config
+    end
+  end
+end

data/lib/kolekti/cc_phpmd/metrics.yml

@@ -0,0 +1,141 @@
+:metrics:
+  :baf:
+    :name: CleanCode/BooleanArgumentFlag
+    :type: HotspotMetricSnapshot
+    :description: A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.
+  :ee:
+    :name: CleanCode/ElseExpression
+    :type: HotspotMetricSnapshot
+    :description: An if expression with an else branch is never necessary. You can rewrite the conditions in a way that the else is not necessary and the code becomes simpler to read. To achieve this use early return statements. To achieve this you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
+  :sa:
+    :name: CleanCode/StaticAccess
+    :type: HotspotMetricSnapshot
+    :description: Static acccess causes inexchangable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.
+  :cccn:
+    :name: Controversial/CamelCaseClassName
+    :type: HotspotMetricSnapshot
+    :description:  It is considered best practice to use the CamelCase notation to name classes.
+  :ccm:
+    :name: Controversial/CamelCaseMethodName
+    :type: HotspotMetricSnapshot
+    :description:  It is considered best practice to use the camelCase notation to name methods.
+  :ccpan:
+    :name: Controversial/CamelCaseParameterName
+    :type: HotspotMetricSnapshot
+    :description:  It is considered best practice to use the camelCase notation to name parameters.
+  :ccprn:
+    :name: Controversial/CamelCasePropertyName
+    :type: HotspotMetricSnapshot
+    :description:  It is considered best practice to use the camelCase notation to name attributes.
+  :ccvn:
+    :name: Controversial/CamelCaseVariableName
+    :type: HotspotMetricSnapshot
+    :description:  It is considered best practice to use the camelCase notation to name variables.
+  :sg:
+    :name: Controversial/Superglobals
+    :type: HotspotMetricSnapshot
+    :description:  Accessing a super-global variable directly is considered a bad practice. These variables should be encapsulated in objects that are provided by a framework, for instance.
+  :cc:
+    :name: CyclomaticComplexity
+    :type: HotspotMetricSnapshot
+    :description:  Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.
+  :cbo:
+    :name: Design/CouplingBetweenObjects
+    :type: HotspotMetricSnapshot
+    :description:  A class with too many dependencies has negative impacts on several quality aspects of a class. This includes quality criteria like stability, maintainability and understandability
+  :doi:
+    :name: Design/DepthOfInheritance
+    :type: HotspotMetricSnapshot
+    :description:  A class with many parents is an indicator for an unbalanced and wrong class hierarchy. You should consider to refactor this class hierarchy.
+  :eex:
+    :name: Design/EvalExpression
+    :type: HotspotMetricSnapshot
+    :description:  An eval-expression is untestable, a security risk and bad practice. Therefore it should be avoided. Consider to replace the eval-expression with regular code.
+  :exe:
+    :name: Design/ExitExpression
+    :type: HotspotMetricSnapshot
+    :description:  An exit-expression within regular code is untestable and therefore it should be avoided. Consider to move the exit-expression into some kind of startup script where an error/exception code is returned to the calling environment.
+  :gs:
+    :name: Design/GotoStatement
+    :type: HotspotMetricSnapshot
+    :description:  Goto makes code harder to read and it is nearly impossible to understand the control flow of an application that uses this language construct. Therefore it should be avoided. Consider to replace Goto with regular control structures and separate methods/function, which are easier to read.
+  :lc:
+    :name: Design/LongClass
+    :type: HotspotMetricSnapshot
+    :description:  Long Class files are indications that the class may be trying to do too much. Try to break it down, and reduce the size to something manageable.
+  :lm:
+    :name: Design/LongMethod
+    :type: HotspotMetricSnapshot
+    :description:  Violations of this rule usually indicate that the method is doing too much. Try to reduce the method size by creating helper methods and removing any copy/pasted code.
+  :lpl:
+    :name: Design/LongParameterList
+    :type: HotspotMetricSnapshot
+    :description:  Long parameter lists can indicate that a new object should be created to wrap the numerous parameters. Basically, try to group the parameters together.
+  :npath:
+    :name: Design/NpathComplexity
+    :type: HotspotMetricSnapshot
+    :description:  The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.
+  :noc:
+    :name: Design/NumberOfChildren
+    :type: HotspotMetricSnapshot
+    :description:  A class with an excessive number of children is an indicator for an unbalanced class hierarchy. You should consider to refactor this class hierarchy.
+  :tmf:
+    :name: Design/TooManyFields
+    :type: HotspotMetricSnapshot
+    :description:  Classes that have too many fields could be redesigned to have fewer fields, possibly through some nested object grouping of some of the information. For example, a class with city/state/zip fields could instead have one Address field.
+  :tmm:
+    :name: Design/TooManyMethods
+    :type: HotspotMetricSnapshot
+    :description:  A class with too many methods is probably a good suspect for refactoring, in order to reduce its complexity and find a way to have more fine grained objects.
+  :tmpm:
+    :name: Design/TooManyPublicMethods
+    :type: HotspotMetricSnapshot
+    :description:  A large number of public methods and attributes declared in a class can indicate the class may need to be broken up as increased effort will be required to thoroughly test it.
+  :wmc:
+    :name: Design/WeightedMethodCount
+    :type: HotspotMetricSnapshot
+    :description:  The Weighted Method Count (WMC) of a class is a good indicator of how much time and effort is required to modify and maintain this class. The WMC metric is defined as the sum of complexities of all methods declared in a class. A large number of methods also means that this class has a greater potential impact on derived classes.
+  :epc:
+    :name: ExcessivePublicCount
+    :type: HotspotMetricSnapshot
+    :description:  A large number of public methods and attributes declared in a class can indicate the class may need to be broken up as increased effort will be required to thoroughly test it.
+  :bgmn:
+    :name: Naming/BooleanGetMethodName
+    :type: HotspotMetricSnapshot
+    :description:  Looks for methods named 'getX()' with 'boolean' as the return type. The convention is to name these methods 'isX()' or 'hasX()'.
+  :cnc:
+    :name: Naming/ConstantNamingConventions
+    :type: HotspotMetricSnapshot
+    :description:  Class/Interface constant nanmes should always be defined in uppercase.
+  :cwnaec:
+    :name: Naming/ConstructorWithNameAsEnclosingClass
+    :type: HotspotMetricSnapshot
+    :description:  A constructor method should not have the same name as the enclosing class, consider to use the PHP 5 __construct method.
+  :lv:
+    :name: Naming/LongVariable
+    :type: HotspotMetricSnapshot
+    :description:  Detects when a field, formal or local variable is declared with a long name.
+  :smn:
+    :name: Naming/ShortMethodName
+    :type: HotspotMetricSnapshot
+    :description:  Detects when very short method names are used.
+  :sv:
+    :name: Naming/ShortVariable
+    :type: HotspotMetricSnapshot
+    :description:  Detects when a field, local, or parameter has a very short name.
+  :ufp:
+    :name: UnusedFormalParameter
+    :type: HotspotMetricSnapshot
+    :description:  Avoid passing parameters to methods or constructors and then not using those parameters.
+  :ulv:
+    :name: UnusedLocalVariable
+    :type: HotspotMetricSnapshot
+    :description:  Detects when a local variable is declared and/or assigned, but not used.
+  :upf:
+    :name: UnusedPrivateField
+    :type: HotspotMetricSnapshot
+    :description:  Detects when a private field is declared and/or assigned a value, but not used.
+  :upm:
+    :name: UnusedPrivateMethod
+    :type: HotspotMetricSnapshot
+    :description:  Unused Private Method detects when a private method is declared but is unused.