rubocop-schema-gen 0.1.0 → 0.1.1

data/lib/rubocop/schema/{cache.rb → cached_http_client.rb}

@@ -4,19 +4,14 @@ require 'net/http'
 
 module RuboCop
   module Schema
-    class Cache
-      # @return [URI]
-      attr_reader :base_url
-
-      def initialize(cache_dir, base_url: nil, &event_handler)
+    class CachedHTTPClient
+      def initialize(cache_dir, &event_handler)
         @cache_dir     = Pathname(cache_dir)
-        @base_url      = validate_url(base_url)
         @event_handler = event_handler
       end
 
       def get(url)
         url = URI(url)
-        url = @base_url + url if @base_url && url.relative?
         validate_url url
 
         path = path_for_url(url)
@@ -24,7 +19,10 @@ module RuboCop
 
         path.parent.mkpath
         @event_handler&.call Event.new(type: :request)
-        Net::HTTP.get(url).force_encoding(Encoding::UTF_8).tap(&path.method(:write))
+
+        res = Net::HTTP.get_response(url)
+        res.body = '' unless res.is_a? Net::HTTPOK
+        res.body.force_encoding(Encoding::UTF_8).tap(&path.method(:write))
       end
 
       private
@@ -34,13 +32,11 @@ module RuboCop
 
         raise ArgumentError, 'Expected an absolute URL' unless url.absolute?
         raise ArgumentError, 'Expected an HTTP URL' unless url.is_a? URI::HTTP
-
-        url
       end
 
       # @param [URI::HTTP] url
       def path_for_url(url)
-        @cache_dir + url.scheme + url.hostname + url.path[1..]
+        @cache_dir + url.scheme + url.hostname + url.path[1..-1]
       end
     end
   end

data/lib/rubocop/schema/cli.rb

@@ -1,67 +1,97 @@
 require 'pathname'
 require 'json'
 
+require 'rubocop/schema/document_loader'
+require 'rubocop/schema/cached_http_client'
+require 'rubocop/schema/generator'
+require 'rubocop/schema/extension_spec'
+
 module RuboCop
   module Schema
     class CLI
       # @param [Pathname] working_dir
       # @param [Hash] env
       # @param [Array<String>] args
-      def initialize(working_dir, env, args)
+      # @param [String] home
+      # @param [IO] out_file
+      # @param [IO] log_file
+      def initialize(working_dir: Dir.pwd, env: ENV, args: ARGV, home: Dir.home, out_file: nil, log_file: $stderr)
         @working_dir = Pathname(working_dir)
+        @home_dir    = Pathname(home)
         @env         = env
         @args        = args
+        @out_file    = out_file
+        @log_file    = log_file
+        @out_path    = args.first
+
+        raise ArgumentError, 'Cannot accept an out_file and an argument' if @out_file && @out_path
       end
 
       def run
+        lockfile_path = @working_dir + 'Gemfile.lock'
         fail "Cannot read #{lockfile_path}" unless lockfile_path.readable?
-        fail 'RuboCop is not part of this project' unless lockfile.specs.any?
 
-        schema = report_duration { Scraper.new(lockfile, cache).schema }
-        puts JSON.pretty_generate schema
+        spec = ExtensionSpec.from_lockfile(lockfile_path)
+        fail 'RuboCop is not part of this project' if spec.empty?
+
+        assign_outfile(spec)
+        print "Generating #{@out_path} … " if @out_path
+
+        schema = report_duration(lowercase: @out_path) { Generator.new(spec.specs, document_loader).schema }
+        @out_file.puts JSON.pretty_generate schema
       end
 
       private
 
-      def report_duration
-        started  = Time.now
+      def assign_outfile(spec)
+        return if @out_file
+
+        case @out_path
+        when '-'
+          @out_file = $stdout
+          @out_path = nil
+        when nil
+          @out_path = "#{spec}-config-schema.json"
+        end
+
+        @out_file ||= File.open(@out_path, 'w') # rubocop:disable Naming/MemoizedInstanceVariableName
+      end
+
+      def report_duration(lowercase: false)
+        started = Time.now
         yield
       ensure
         finished = Time.now
-        handle_event Event.new(message: "Complete in #{(finished - started).round 1}s")
+        message  = "Complete in #{(finished - started).round 1}s"
+        message.downcase! if lowercase
+        handle_event Event.new(message: message)
       end
 
       def handle_event(event)
         case event.type
         when :request
-          $stderr << '.'
+          @log_file << '.'
           @line_dirty = true
         else
-          $stderr.puts '' if @line_dirty
+          @log_file.puts '' if @line_dirty
           @line_dirty = false
-          $stderr.puts event.message.to_s
+          @log_file.puts event.message.to_s
         end
       end
 
       def fail(msg)
-        $stderr.puts msg.to_s
+        @log_file.puts msg.to_s
         exit 1
       end
 
-      def lockfile
-        @lockfile ||= LockfileInspector.new(lockfile_path)
-      end
-
-      def lockfile_path
-        @lockfile_path ||= @working_dir + 'Gemfile.lock'
-      end
-
-      def cache
-        @cache ||= Cache.new(cache_dir, &method(:handle_event))
-      end
-
-      def cache_dir
-        @cache_dir ||= Pathname(Dir.home) + '.rubocop-schema-cache'
+      def document_loader
+        @document_loader ||=
+          DocumentLoader.new(
+            CachedHTTPClient.new(
+              @home_dir + '.rubocop-schema-cache',
+              &method(:handle_event)
+            )
+          )
       end
     end
   end

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,46 @@
+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|
+          CopInfo.new(
+            name:               cop_name,
+            description:        attributes['Description'],
+            enabled_by_default: attributes['Enabled'] == true,
+            attributes:         transform_attributes(attributes)
+          )
+        end
+      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/document_loader.rb

@@ -0,0 +1,41 @@
+module RuboCop
+  module Schema
+    class DocumentLoader
+      DOCS_URL_TEMPLATE =
+        -'https://raw.githubusercontent.com/rubocop/%s/v%s/docs/modules/ROOT/pages/cops%s.adoc'
+      DEFAULTS_URL_TEMPLATE =
+        -'https://raw.githubusercontent.com/rubocop/%s/v%s/config/default.yml'
+
+      # @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, spec.version, department && "_#{department.to_s.downcase}"
+      end
+
+      def url_for_defaults(spec)
+        format DEFAULTS_URL_TEMPLATE, spec.name, spec.version
+      end
+    end
+  end
+end

data/lib/rubocop/schema/extension_spec.rb

@@ -0,0 +1,59 @@
+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
+
+      def self.from_lockfile(lockfile)
+        new(Bundler::LockfileParser.new(lockfile.to_s).sources.flat_map do |source|
+          source.specs.map do |stub|
+            next unless KNOWN_GEMS.include? stub.name
+
+            Spec.new(
+              name:    stub.name,
+              version: stub.version.to_s
+            )
+          end.compact
+        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