rubocop-schema-gen 0.1.0 → 0.1.5

data/lib/rubocop/schema/cop_info_merger.rb

@@ -0,0 +1,54 @@
+module RuboCop
+  module Schema
+    class CopInfoMerger
+      # @param [CopInfo] old
+      # @param [CopInfo] new
+      # @return [CopInfo]
+      def self.merge(old, new)
+        new(old, new).merged
+      end
+
+      # @return [CopInfo]
+      attr_reader :merged
+
+      def initialize(old, new)
+        @merged = old.dup
+        @new = new
+        merge
+      end
+
+      private
+
+      def merge
+        @merged.supports_autocorrect = @new.supports_autocorrect if @merged.supports_autocorrect.nil?
+        @merged.enabled_by_default   = @new.enabled_by_default if @merged.enabled_by_default.nil?
+        @merged.attributes           = merge_attribute_sets(@merged.attributes, @new.attributes)
+        @merged.description          ||= @new.description
+      end
+
+      # @param [Array<Attribute>] old
+      # @param [Array<Attribute>] new
+      # @return [Array<Attribute>]
+      def merge_attribute_sets(old, new)
+        return old || new unless old && new
+
+        merged = old.map { |attr| [attr.name, attr] }.to_h
+        new.each do |attr|
+          merged[attr.name] = merged.key?(attr.name) ? merge_attributes(merged[attr.name], attr) : attr
+        end
+
+        merged.values
+      end
+
+      # @param [Attribute] old
+      # @param [Attribute] new
+      # @return [Attribute]
+      def merge_attributes(old, new)
+        old.dup.tap do |merged|
+          merged.type    ||= new.type
+          merged.default ||= new.default
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/schema/cop_schema.rb

@@ -1,40 +1,83 @@
+require 'rubocop/schema/helpers'
+
 module RuboCop
   module Schema
     class CopSchema
-      # @return [Class<RuboCop::Cop::Base>]
-      attr_reader :cop
+      include Helpers
+
+      KNOWN_TYPES = {
+        'boolean' => 'boolean',
+        'integer' => 'integer',
+        'array'   => 'array',
+        'string'  => 'string',
+        'float'   => 'number'
+      }.freeze
 
-      # @param [Class<RuboCop::Cop::Base>] cop
       # @param [CopInfo] info
-      def initialize(cop, info)
-        raise ArgumentError unless cop.is_a?(Class) && cop < Cop::Base
+      def initialize(info)
+        @info = info.dup.freeze
+        @json = template('cop_schema')
+        generate
+      end
 
-        @cop  = cop
-        @info = info
+      def as_json
+        @json
       end
 
-      KNOWN_TYPES = Set.new(%w[boolean integer array string]).freeze
+      alias to_h as_json
 
-      def as_json
-        Schema.template('cop_schema').tap do |json|
-          json['$comment']   = cop.documentation_url
-          json['properties'] = props = json.fetch('properties').dup
-
-          # AutoCorrect
-          props['AutoCorrect'] = { 'type' => 'boolean' } if cop.support_autocorrect?
-
-          if @info
-            json['description'] = @info.description
-            @info.attributes.each do |attr|
-              next if attr.name.blank?
-
-              props[attr.name]    = prop = {}
-              prop['description'] = "Default: #{attr.default}" unless attr.default.blank?
-              prop['type']        = attr.type if KNOWN_TYPES.include? attr.type
-            end
-          end
+      def freeze
+        @json.freeze
+        super
+      end
+
+      private
+
+      # @return Hash
+      attr_reader :json
+
+      # @return CopInfo
+      attr_reader :info
+
+      def props
+        json['properties']
+      end
+
+      def generate
+        json['description'] = info.description unless info.description.nil?
+        assign_default_attributes
+        info.attributes&.each do |attr|
+          prop = props[attr.name] ||= {}
+          assign_attribute_type prop, attr
+          assign_attribute_description prop, attr
+        end
+      end
+
+      def assign_default_attributes
+        props['AutoCorrect']            = boolean if info.supports_autocorrect
+        props['Enabled']['description'] = "Default: #{info.enabled_by_default}" if info.enabled_by_default
+      end
+
+      # @param [Hash] prop
+      # @param [Attribute] attr
+      def assign_attribute_type(prop, attr)
+        if KNOWN_TYPES.key? attr.type&.downcase
+          prop['type'] ||= KNOWN_TYPES[attr.type.downcase] unless prop.key? '$ref'
+        elsif attr.type
+          prop['enum'] = attr.type.split(/\s*,\s*/)
         end
       end
+
+      # @param [Hash] prop
+      # @param [Attribute] attr
+      def assign_attribute_description(prop, attr)
+        prop['description'] = format_default(attr.default) unless attr.default.nil?
+      end
+
+      def format_default(default)
+        default = default.join(', ') if default.is_a? Array
+        "Default: #{default}"
+      end
     end
   end
 end

data/lib/rubocop/schema/defaults_ripper.rb

@@ -0,0 +1,48 @@
+require 'rubocop/schema/value_objects'
+
+module RuboCop
+  module Schema
+    class DefaultsRipper
+      EXCLUDE_ATTRIBUTES = Set.new(%w[Description VersionAdded VersionChanged StyleGuide]).freeze
+
+      TYPE_MAP = {
+        integer: [Integer],
+        number:  [Float],
+        boolean: [TrueClass, FalseClass],
+        string:  [String],
+        array:   [Array]
+      }.freeze
+
+      # @return [Array<CopInfo>]
+      attr_reader :cops
+
+      # @param [Hash] defaults
+      def initialize(defaults)
+        @cops = defaults.map do |cop_name, attributes|
+          next unless attributes.is_a? Hash
+
+          CopInfo.new(
+            name:               cop_name,
+            description:        attributes['Description'],
+            enabled_by_default: attributes['Enabled'] == true,
+            attributes:         transform_attributes(attributes)
+          )
+        end.compact
+      end
+
+      private
+
+      def transform_attributes(hash)
+        hash.map do |name, default|
+          next if EXCLUDE_ATTRIBUTES.include? name
+
+          Attribute.new(
+            name:    name,
+            type:    TYPE_MAP.find { |_, v| v.any? { |c| default.is_a? c } }&.first&.to_s,
+            default: default
+          )
+        end.compact
+      end
+    end
+  end
+end

data/lib/rubocop/schema/diff.rb

@@ -0,0 +1,67 @@
+require 'rubocop/schema/helpers'
+
+module RuboCop
+  module Schema
+    class Diff
+      include Helpers
+
+      class << self
+        def instance
+          @instance ||= new
+        end
+
+        def diff(old, new)
+          instance.diff old, new
+        end
+
+        def apply(old, diff)
+          instance.apply old, diff
+        end
+      end
+
+      def diff(old, new)
+        return diff_hashes old, new if old.is_a?(Hash) && new.is_a?(Hash)
+
+        new
+      end
+
+      def apply(old, diff)
+        return apply_hash(old, diff) if old.is_a?(Hash) && diff.is_a?(Hash)
+
+        diff
+      end
+
+      private
+
+      def diff_hashes(old, new)
+        (old.keys - new.keys).map { |k| [k, nil] }.to_h.tap do |result|
+          new.each do |k, v|
+            if old.key? k
+              result[k] = diff(old[k], v) unless old[k] == v
+            else
+              result[k] = v
+            end
+          end
+        end
+      end
+
+      def apply_hash(old, diff)
+        deep_dup(old).tap do |result|
+          diff.each do |k, v|
+            apply_hash_pair result, k, v
+          end
+        end
+      end
+
+      def apply_hash_pair(hash, key, value)
+        if value.nil?
+          hash.delete key
+        elsif hash.key? key
+          hash[key] = apply(hash[key], value)
+        else
+          hash[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/schema/document_loader.rb

@@ -0,0 +1,55 @@
+require 'asciidoctor'
+require 'yaml'
+
+module RuboCop
+  module Schema
+    class DocumentLoader
+      DOCS_URL_TEMPLATE =
+        -'https://raw.githubusercontent.com/rubocop/%s/%s/docs/modules/ROOT/pages/cops%s.adoc'
+      DEFAULTS_URL_TEMPLATE =
+        -'https://raw.githubusercontent.com/rubocop/%s/%s/config/default.yml'
+
+      CORRECTIONS = {
+        'rubocop' => {
+          # Fixes a typo that causes Asciidoctor to crash
+          '1.10.0' => '174bda389c2c23cffb17e9d6128f5e6bdbc0e8a0'
+        }
+      }.freeze
+
+      # @param [CachedHTTPClient] http_client
+      def initialize(http_client)
+        @http_client = http_client
+        @docs        = {}
+        @defaults    = {}
+      end
+
+      # @param [Spec] spec
+      def defaults(spec)
+        @defaults[spec] ||=
+          YAML.safe_load @http_client.get(url_for_defaults(spec)), [Regexp, Symbol]
+      end
+
+      # @param [Spec] spec
+      # @param [String] department
+      # @return [Asciidoctor::Document]
+      def doc(spec, department = nil)
+        @docs[[spec, department]] ||=
+          Asciidoctor.load @http_client.get url_for_doc(spec, department)
+      end
+
+      private
+
+      def url_for_doc(spec, department)
+        format DOCS_URL_TEMPLATE, spec.name, correct_version(spec), department && "_#{department.to_s.downcase}"
+      end
+
+      def url_for_defaults(spec)
+        format DEFAULTS_URL_TEMPLATE, spec.name, correct_version(spec)
+      end
+
+      def correct_version(spec)
+        CORRECTIONS.dig(spec.name, spec.version) || "v#{spec.version}"
+      end
+    end
+  end
+end

data/lib/rubocop/schema/extension_spec.rb

@@ -0,0 +1,67 @@
+require 'rubocop/schema/value_objects'
+
+module RuboCop
+  module Schema
+    class ExtensionSpec
+      KNOWN_CLASSES = Set.new(
+        %w[
+          RuboCop
+          RuboCop::Rake
+          RuboCop::RSpec
+          RuboCop::Minitest
+          RuboCop::Performance
+          RuboCop::Rails
+        ]
+      ).freeze
+
+      KNOWN_GEMS = Set.new(['rubocop', *KNOWN_CLASSES.map { |e| e.sub('::', '-').downcase }]).freeze
+
+      def self.internal
+        @internal ||= new(KNOWN_CLASSES.map do |klass_name|
+          next unless Object.const_defined? klass_name
+
+          klass = Object.const_get(klass_name)
+          Spec.new(
+            name:    klass.name.sub('::', '-').downcase,
+            version: (defined?(klass::VERSION) ? klass::VERSION : klass::Version::STRING)
+          )
+        end.compact)
+      end
+
+      # @param [Pathname] lockfile
+      def self.from_lockfile(lockfile)
+        new(lockfile.readlines.map do |line|
+          next unless line =~ /\A\s+(rubocop(?:-\w+)?) \((\d+(?:\.\d+)+)\)\s*\z/
+          next unless KNOWN_GEMS.include? $1
+
+          Spec.new(name: $1, version: $2)
+        end.compact)
+      end
+
+      def self.from_string(string)
+        new(string.split('-').each_slice(2).map do |(name, version)|
+          name = "rubocop-#{name}" unless name == 'rubocop'
+
+          raise ArgumentError, "Unknown gem '#{name}'" unless KNOWN_GEMS.include? name
+          raise ArgumentError, "Invalid version '#{version}'" unless version&.match? /\A\d+(?:\.\d+)+\z/
+
+          Spec.new(name: name, version: version)
+        end)
+      end
+
+      attr_reader :specs
+
+      def initialize(specs)
+        @specs = specs.dup.sort_by(&:name).freeze
+      end
+
+      def to_s
+        @specs.join '-'
+      end
+
+      def empty?
+        @specs.empty?
+      end
+    end
+  end
+end

data/lib/rubocop/schema/generator.rb

@@ -0,0 +1,91 @@
+require 'rubocop/schema/value_objects'
+require 'rubocop/schema/cop_schema'
+require 'rubocop/schema/helpers'
+require 'rubocop/schema/ascii_doc/index'
+require 'rubocop/schema/ascii_doc/department'
+require 'rubocop/schema/document_loader'
+require 'rubocop/schema/defaults_ripper'
+require 'rubocop/schema/cop_info_merger'
+
+module RuboCop
+  module Schema
+    class Generator
+      include Helpers
+
+      # @return Hash
+      attr_reader :schema
+
+      # @param [Array<Spec>] specs
+      # @param [DocumentLoader] document_loader
+      def initialize(specs, document_loader)
+        @specs  = specs
+        @loader = document_loader
+        @schema = template('schema')
+        @props  = @schema.fetch('properties')
+        generate
+      end
+
+      private
+
+      def generate
+        @specs.each &method(:generate_spec)
+        @props.delete 'AllCops' unless @specs.any? { |s| s.name == 'rubocop' }
+      end
+
+      def generate_spec(spec)
+        info_map = read_docs(spec)
+        read_defaults(spec).each do |name, cop_info|
+          info_map[name] = info_map.key?(name) ? CopInfoMerger.merge(info_map[name], cop_info) : cop_info
+        end
+        apply_cop_info info_map
+      end
+
+      def read_docs(spec)
+        {}.tap do |info_map|
+          AsciiDoc::Index.new(@loader.doc(spec)).department_names.each do |department|
+            info_map[department] = department_info(spec, department)
+
+            AsciiDoc::Department.new(@loader.doc(spec, department)).cops.each do |cop_info|
+              info_map[cop_info.name] = CopInfo.new(**cop_info.to_h)
+            end
+          end
+        end
+      end
+
+      def read_defaults(spec)
+        defaults = @loader.defaults(spec) or
+          return {}
+
+        DefaultsRipper.new(defaults).cops.map { |cop_info| [cop_info.name, cop_info] }.to_h
+      end
+
+      def apply_cop_info(info)
+        info.each do |cop_name, cop_info|
+          schema           = CopSchema.new(cop_info).as_json
+          @props[cop_name] = @props.key?(cop_name) ? merge_schemas(@props[cop_name], schema) : schema
+        end
+      end
+
+      # @param [Hash] old
+      # @param [Hash] new
+      def merge_schemas(old, new)
+        deep_merge(old, new) do |merged|
+          merged.delete 'type' if merged.key? '$ref'
+        end
+      end
+
+      # @param [Spec] spec
+      # @param [String] department
+      # @return [CopInfo]
+      def department_info(spec, department)
+        description = "'#{department}' department"
+        description << " (#{spec.short_name} extension)" if spec.short_name
+
+        CopInfo.new(
+          name:        department,
+          description: description
+        )
+      end
+    end
+  end
+end