sorbet-cfg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 48c8482457e5a75f4cc1ecffb77c1fbeb9c84b7d6ca875321ebcea98d4ef93d1
+  data.tar.gz: 56a087dffb2f6007debd11e60b03492344a866ce1b9af55d2a8f1da4164cda16
+SHA512:
+  metadata.gz: 199335bf741fe283f281fda0c79d6299b82207f0098814c32321883e721fed2df24926108c62568049380d4fb2635627d1b6eaacc2383d591a25ec8867f3a827
+  data.tar.gz: 44eeff0c0185f951cbea1133e9aba24c839c81294a82223a5160fb5974a92d05ae6b706831134c68dad1dd0110cc71682130c9a45417882ed9081b4354e2009a

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in sorbet-cfg.gemspec
+gemspec
+
+gem "parslet", "~> 1.8"
+
+gem "rspec", "~> 3.9"
+
+gem "sorbet-runtime", "~> 0.4.5005"

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    sorbet-cfg (0.1.0)
+      sorbet
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    parslet (1.8.2)
+    rake (10.5.0)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.0)
+      rspec-support (~> 3.9.0)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.0)
+    sorbet (0.4.4997)
+      sorbet-static (= 0.4.4997)
+    sorbet-runtime (0.4.5005)
+    sorbet-static (0.4.4997-universal-darwin-14)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  parslet (~> 1.8)
+  rake (~> 10.0)
+  rspec (~> 3.9)
+  sorbet-cfg!
+  sorbet-runtime (~> 0.4.5005)
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Aaron Christiansen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Sorbet::Cfg
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sorbet/cfg`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sorbet-cfg'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sorbet-cfg
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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/AaronC81/sorbet-cfg.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/lib/sorbet-cfg/loader.rb

@@ -0,0 +1,132 @@
+# typed: true
+
+require 'pathname'
+require 'open3'
+require 'json'
+
+module SorbetCFG
+  module Loader
+    extend T::Sig
+
+    sig { returns(T::Hash[T.any(Module, Class), T::Hash[String, Tree::CFG]]) }
+    def self.index
+      @index ||= {}
+    end
+
+    sig { params(a: Integer, b: Integer).returns(Integer) }
+    def self.foo(a, b)
+      a + b
+    end
+
+    sig { params(path: String).returns(T.nilable(String)) }
+    ##
+    # Given an ABSOLUTE path to somewhere within a Sorbet-enabled Ruby project, 
+    # finds the root of the project by looking for a Gemfile or .bundle, as well 
+    # as a sorbet directory.
+    def self.project_root(path)
+      # TODO: Sorbet is currently Unix-only, so this code is too
+
+      raise 'path does not appear to be absolute' unless path.start_with?('/')
+
+      possible_paths = []
+      Pathname.new(path).each_filename do |part|
+        possible_paths << (possible_paths.empty? \
+          ? "/#{part}"
+          : File.join(possible_paths.last, part))
+      end
+
+      possible_paths.reverse.each do |possible_path|
+        has_bundler = File.exist?(File.join(possible_path, 'Gemfile')) ||
+          File.exist?(File.join(possible_path, '.bundle'))
+
+        has_sorbet = File.exist?(File.join(possible_path, 'sorbet'))
+
+        return possible_path if has_bundler && has_sorbet
+      end
+
+      nil
+    end
+
+    sig { params(target: T.any(Module, Class)).returns(String) }
+    ##
+    # Given a module or class, returns the contents of an RBI file which, when
+    # loaded, makes that module or class extend T::CFGExport so that Sorbet's
+    # "-p cfg-json" option will print JSON for its CFG.
+    def self.generate_cfg_export_rbi(target)
+      result_lines = []
+
+      # Start from the top
+      current_object = T.let(Kernel, T.untyped)
+
+      total_nesting = 0
+      target.to_s.split('::').each.with_index do |part_name, i|
+        current_object = current_object.const_get(part_name)
+
+        if current_object.is_a?(Class)
+          kind = "class"
+        elsif current_object.is_a?(Module)
+          kind = "module"
+        else
+          raise "#{current_object} is neither a class nor a module"
+        end
+
+        result_lines << "#{'  ' * i}#{kind} #{part_name}"
+        total_nesting = i
+      end
+
+      result_lines << "#{'  ' * (total_nesting + 1)}extend T::CFGExport"
+
+      (total_nesting + 1).times do |i|
+        this_level = total_nesting - i
+        result_lines << "#{'  ' * this_level}end"
+      end
+
+      result_lines.join("\n") + "\n"
+    end 
+
+    sig { params(obj: Module).void }
+    def self.index_module(obj)
+      rbi_contents = generate_cfg_export_rbi(obj)
+      rbi_path = '/tmp/sorbet-cfg-export.rbi'
+      File.write(rbi_path, rbi_contents)
+
+      result = T.let(nil, T.nilable(Tree::MultiCFG))
+
+      all_methods = obj.methods + obj.instance_methods
+      raise "can\'t get the source location of #{obj} because it contains no methods" if all_methods.empty?
+
+      # Just pick the first one, it's easiest
+      # TODO: might be best to pick all unique, though?
+      target = obj.method(T.must(all_methods[0]))
+      project = project_root(Utilities.true_source_location(target)[0])
+      
+      raise 'unable to locate project root' unless project
+
+      Open3.popen3('srb', 'tc', rbi_path, '-p', 'cfg-json', chdir: project) do |i, o, e, t|
+        json_docs = o.read
+
+        # TODO: VERY BAD
+        # Just all of this is terrible
+        # There's a stub element at the end because trailing commas aren't valid JSON
+        cursed_json_doc = "[#{json_docs.gsub(/^\}/, '},')} null]"
+        parsed_json = JSON.parse(cursed_json_doc)[0...-1]
+        result = Tree::MultiCFG.new(cfg: parsed_json.map { |x| Tree::CFG.from_hash(x) })
+      end
+
+      raise "indexing failed for #{obj}" unless result
+      index[obj] = {}
+      result.cfg.each do |cfg|
+        if cfg.definition_full_name.include?('.')
+          prefix_char = '.'
+        elsif cfg.definition_full_name.include?('#')
+          prefix_char = '#'
+        else
+          raise "unable to determine type of #{cfg}"
+        end
+
+        def_name = "#{prefix_char}#{cfg.definition_full_name.split(prefix_char).last}"
+        T.must(index[obj])[def_name] = cfg
+      end
+    end
+  end
+end

data/lib/sorbet-cfg/raw_parser.rb

@@ -0,0 +1,37 @@
+# typed: ignore
+require 'parslet'
+
+module SorbetCFG
+  class RawParser < Parslet::Parser
+    # As far as I can tell, it's OK to just shotgun most operators, but < and >
+    # need special care because they delimit #sorbet_name
+    # There's probably some absolutely horrendous stuff that this accepts, but
+    # if that sort of stuff occurs in a CFG, we have bigger problems
+    rule(:name)         { match('[A-Za-z_0-9=\-|&.!~?]').repeat(1) |
+                          (str('<') >> name >> str('>') | # Matches <=> too!
+                          str('>') | str('<') | str('<=') | str('>=')) }
+    
+    rule(:space)        { match('\s').repeat(1) }
+    rule(:space?)       { space.maybe }
+
+    rule(:langle)       { space? >> match('<') >> space? }
+    rule(:rangle)       { space? >> match('>') >> space? }
+
+    rule(:lbrace)       { space? >> match('{') >> space? }
+    rule(:rbrace)       { space? >> match('}') >> space? }
+
+    rule(:sorbet_name)  { langle >>
+                          match('[A-Z]').repeat(1).as(:kind) >>
+                          space? >>
+                          name.as(:value) >>
+                          rangle }
+
+    rule(:local_var)    { sorbet_name.as(:name) >>
+                          str('$') >>
+                          match('[0-9]').repeat(1).as(:unique) >>
+                          space? }
+
+    rule(:node)         { identifier.as(:type) >> lbrace >> rbrace }
+    root(:node)
+  end
+end

data/lib/sorbet-cfg/tree/cfg.rb

@@ -0,0 +1,97 @@
+# typed: true
+require_relative 'loc'
+require_relative 'type'
+
+module SorbetCFG
+  module Tree
+    module Instruction; end
+
+    class LocalVariable < T::Struct
+      prop :unique_name, String
+      prop :type, Type
+    end
+
+    class Block < T::Struct
+      class BlockExit < T::Struct
+        prop :cond, T.nilable(LocalVariable)
+        prop :then_block, Integer
+        prop :else_block, Integer
+        prop :location, Loc
+      end
+
+      prop :id, T.nilable(Integer)
+      prop :bindings, T::Array[Binding], factory: ->{ [] }
+      prop :block_exit, BlockExit
+    end
+
+    class UnknownInstruction < T::Struct
+      extend Instruction
+    end
+
+    class IdentInstruction < T::Struct
+      extend Instruction
+      prop :ident, LocalVariable
+    end
+
+    class AliasInstruction < T::Struct
+      extend Instruction
+      prop :alias_full_name, String
+    end
+
+    class SendInstruction < T::Struct
+      extend Instruction
+      prop :receiver, LocalVariable
+      prop :method_name, String
+      prop :arguments, T::Array[LocalVariable]
+      prop :block, Block
+    end
+
+    class ReturnInstruction < T::Struct
+      extend Instruction
+      prop :return, LocalVariable
+    end
+
+    class LiteralInstruction < T::Struct
+      extend Instruction
+      prop :literal, Type
+    end
+
+    class UnanalyzableType < T::Struct
+      extend Instruction
+    end
+
+    class LoadArgType < T::Struct
+      extend Instruction
+      prop :load_arg_name, String
+    end
+
+    class CastInstruction < T::Struct
+      extend Instruction
+      prop :value, LocalVariable
+      prop :type, Type
+    end
+
+    class Binding < T::Struct
+      prop :bind, LocalVariable
+      prop :value, Instruction
+      prop :location, Loc
+    end
+
+    class CFG < T::Struct
+      class Argument < T::Struct
+        prop :name, String
+        prop :type, T.nilable(Type)
+      end 
+
+      prop :definition_full_name, String
+      prop :location, Loc
+      prop :return_type, T.nilable(Type)
+      prop :arguments, T::Array[Argument]
+      prop :blocks, T::Array[Block]
+    end
+
+    class MultiCFG < T::Struct
+      prop :cfg, T::Array[CFG]
+    end
+  end
+end

data/lib/sorbet-cfg/tree/loc.rb

@@ -0,0 +1,20 @@
+# typed: true
+
+module SorbetCFG
+  module Tree
+    class Loc < T::Struct      
+      class Position < T::Struct
+        class LC < T::Struct
+          prop :line, T.nilable(Integer)
+          prop :column, T.nilable(Integer)
+        end
+        
+        prop :start, LC
+        prop :end, LC
+      end
+
+      prop :path, String
+      prop :position, Position
+    end
+  end
+end

data/lib/sorbet-cfg/tree/type.rb

@@ -0,0 +1,52 @@
+# typed: true
+
+module SorbetCFG
+  module Tree
+    module Type; end
+
+    class UnknownType < T::Struct
+      extend Type
+    end
+
+    class ClassType < T::Struct
+      extend Type
+      prop :class_full_name, String
+    end
+
+    class CompositeType < T::Struct
+      class Operator < T::Enum
+        enums do
+          OR = new
+          AND = new
+        end
+      end
+      
+      extend Type
+      prop :left, Type
+      prop :right, Type
+      prop :operator, Operator
+    end
+
+    class AppliedType < T::Struct
+      extend Type
+      prop :symbol_full_name, String
+      prop :type_args, T::Array[Type]
+    end
+
+    class ShapeType < T::Struct
+      extend Type
+      prop :keys, T::Array[Type]
+      prop :values, T::Array[Type]
+    end
+
+    class LiteralType < T::Struct
+      extend Type
+      prop :value, T.any(Integer, String, Symbol, T::Boolean, Float)
+    end
+
+    class TupleType < T::Struct
+      extend Type
+      prop :elems, T::Array[Type]
+    end
+  end
+end

data/lib/sorbet-cfg/utilities.rb

@@ -0,0 +1,28 @@
+# typed: true
+
+module SorbetCFG
+  module Utilities
+    extend T::Sig
+
+    sig { params(meth: Method).returns([String, Integer]) }
+    def self.true_source_location(meth)
+      loc = meth.source_location
+
+      file_path, line = loc
+      return loc unless file_path && File.exists?(file_path)
+
+      first_source_line = IO.readlines(file_path)[line - 1]
+
+      # This is how Sorbet replaces methods.
+      # If Sorbet undergoes drastic refactorings, this may need to be updated!
+      initial_sorbet_line = "T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|"
+      replaced_sorbet_line = "mod.send(:define_method, method_sig.method_name) do |*args, &blk|"
+
+      if [initial_sorbet_line, replaced_sorbet_line].include?(T.must(first_source_line).strip)
+        T::Private::Methods.signature_for_method(meth).method.source_location
+      else
+        loc
+      end
+    end
+  end
+end

data/lib/sorbet-cfg.rb

@@ -0,0 +1,13 @@
+# typed: true
+
+require 'sorbet-runtime'
+
+require_relative 'sorbet-cfg/utilities'
+
+require_relative 'sorbet-cfg/tree/loc'
+require_relative 'sorbet-cfg/tree/type'
+require_relative 'sorbet-cfg/tree/cfg'
+
+require_relative 'sorbet-cfg/raw_parser'
+
+require_relative 'sorbet-cfg/loader'

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.