gloss 0.0.5 → 0.1.3

data/sig/core.rbs

@@ -0,0 +1,2 @@
+class Any < Object
+end

data/sig/fast_blank.rbs

@@ -0,0 +1,4 @@
+class String
+  def blank?: () -> bool
+  def blank_as?: () -> bool
+end

data/sig/optparse.rbs

@@ -0,0 +1,6 @@
+# TODO: remove once stdlib gets types for this. Note - RBS
+# already provides some types for this from its `sig` directory - so
+# only adding #parse here
+class OptionParser
+  def parse: (Array[String] argv) -> untyped
+end

data/sig/rubygems.rbs

@@ -0,0 +1,9 @@
+module Gem
+  class ConsoleUI
+    attr_reader outs: StringIO
+  end
+
+  def self.ui: () -> Gem::ConsoleUI
+
+  def self.suffixes: () -> Array[String]
+end

data/sig/yaml.rbs

@@ -0,0 +1,3 @@
+class Yaml
+  def safe_load: (String) -> untyped
+end

data/src/exe/gloss

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gloss"
+
+begin
+  Gloss::CLI.new(ARGV).run
+rescue SystemExit
+  # raised by `abort` or `exit`; no op
+rescue => e
+  abort <<~MSG
+    Unexpected error: #{e.class.name}
+    Message: #{e.message}
+    Trace:
+      #{e.backtrace.join("\n")}
+
+    This is probably a bug and may warrant a bug report at https://github.com/johansenja/gloss/issues
+  MSG
+end

data/src/lib/gloss.gl

@@ -0,0 +1,25 @@
+require "rbs"
+require "json"
+require "steep"
+require "fast_blank"
+
+require "gloss/version"
+require "gloss/cli"
+require "gloss/watcher"
+require "gloss/type_checker"
+require "gloss/parser"
+require "gloss/initializer"
+require "gloss/config"
+require "gloss/writer"
+require "gloss/source"
+require "gloss/scope"
+require "gloss/visitor"
+require "gloss/errors"
+require "gloss/logger"
+require "gloss/prog_loader"
+require "gloss/utils"
+
+require "gls"
+
+EMPTY_ARRAY = Array.new.freeze
+EMPTY_HASH = {}.freeze

data/src/lib/gloss/cli.gl

@@ -12,26 +12,52 @@ module Gloss
       files = @argv[1..-1]
       err_msg = catch :error do
         case command
-        when "watch"
-          Watcher.new(files).watch
-        when "build"
-          (files.empty? ? Dir.glob("#{Config.src_dir}/**/*.gl") : files).each do |fp|
-            puts "=====> Building #{fp}"
-            content = File.read(fp)
-            tree_hash = Parser.new(content).run
-            type_checker = TypeChecker.new
-            rb_output = Builder.new(tree_hash, type_checker).run
-            type_checker.run(rb_output)
-
-            puts "=====> Writing #{fp}"
-            Writer.new(rb_output, fp).run
-          end
         when "init"
           force = false
           OptionParser.new do |opt|
             opt.on("--force", "-f") { force = true }
           end.parse(@argv)
           Initializer.new(force).run
+        when "version", "--version", "-v"
+          puts Gloss::VERSION
+        when "watch", "build"
+          type_checker = ProgLoader.new.run
+          if command == "watch"
+            files = files.map do |f|
+              path = Pathname.new(f).absolute? ? f : File.join(Dir.pwd, f)
+              if Pathname.new(path).exist?
+                path
+              else
+                throw :error, "Pathname #{f} does not exist"
+              end
+            end
+            Watcher.new(files).watch
+          elsif command == "build"
+            entry_tree = Parser.new(File.read(Config.entrypoint)).run
+            Visitor.new(entry_tree, type_checker).run
+            files = Dir.glob("#{Config.src_dir}/**/*.gl") if files.empty?
+            files.each do |fp|
+              fp = File.absolute_path(fp)
+              preloaded_output = OUTPUT_BY_PATH.fetch(fp) { nil }
+              if preloaded_output
+                rb_output = preloaded_output
+              else
+                Gloss.logger.info "Building #{fp}"
+                content = File.read(fp)
+                tree_hash = Parser.new(content).run
+                rb_output = Visitor.new(tree_hash, type_checker).run
+              end
+              Gloss.logger.info "Type checking #{fp}"
+              type_checker.run(fp, rb_output)
+            end
+            # ensure all files are type checked before anything is written
+            files.each do |fp|
+              fp = File.absolute_path(fp)
+              rb_output = OUTPUT_BY_PATH.fetch(fp)
+              Gloss.logger.info "Writing #{fp}"
+              Writer.new(rb_output, fp).run
+            end
+          end
         else
           throw :error, "Gloss doesn't know how to #{command}"
         end

data/src/lib/gloss/config.gl

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "ostruct"
 require "yaml"
 
@@ -9,6 +7,8 @@ module Gloss
     default_config: {
       frozen_string_literals: true,
       src_dir: "src",
+      entrypoint: nil,
+      strict_require: false
     }
   )
 

data/src/lib/gloss/initializer.gl

@@ -14,7 +14,7 @@ module Gloss
         file.puts Config.default_config.transform_keys(&:to_s).to_yaml
       end
 
-      puts "Created #{CONFIG_PATH} with default preferences"
+      Gloss.logger.info "Created #{CONFIG_PATH} with default preferences"
     end
   end
 end

data/src/lib/gloss/logger.gl

@@ -0,0 +1,21 @@
+module Gloss
+  def self.logger
+    if @logger
+      @logger
+    else
+      env_log_level = ENV.fetch("LOG_LEVEL") { "INFO" }
+      real_log_level = {
+        "UNKNOWN" => Logger::UNKNOWN,
+        "FATAL" => Logger::FATAL,
+        "ERROR" => Logger::ERROR,
+        "WARN" => Logger::WARN,
+        "INFO" => Logger::INFO,
+        "DEBUG" => Logger::DEBUG,
+        "NIL" => nil,
+        nil => nil,
+        "" => nil
+      }.fetch env_log_level
+      @logger = Logger.new(real_log_level ? STDOUT : IO::NULL)
+    end
+  end
+end

data/src/lib/gloss/parser.gl

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Gloss
   class Parser
     def initialize(@str : String)
@@ -10,9 +8,23 @@ module Gloss
       begin
         JSON.parse tree_json, symbolize_names: true
       rescue JSON::ParserError
-        # if parsing fails then tree is invalid and most likely an error message from the parser in
-        # crystal
-        raise Errors::ParserError, tree_json
+        error_message = tree_json
+        error_message.match /.+\s:(\d+)$/
+        if $1
+          line_number = $1.to_i
+          # line numbers start at 1, but array index starts at 0; so this still gives one line
+          # either side of the offending line
+          context = @str.lines[(line_number - 2)..(line_number)].map.with_index { |line, index|
+            "#{index - 1 + line_number}|  #{line}"
+          }.join
+          error_message = <<~MSG
+          #{context.rstrip}
+
+          #{error_message}
+
+          MSG
+        end
+        throw :error, error_message
       end
     end
   end

data/src/lib/gloss/prog_loader.gl

@@ -0,0 +1,133 @@
+require "rubygems/gem_runner"
+
+module Gloss
+  OUTPUT_BY_PATH = Hash.new
+
+  class ProgLoader
+    def initialize
+      entrypoint = Config.entrypoint
+      if entrypoint == nil || entrypoint == ""
+        throw :error, "Entrypoint is not yet set in .gloss.yml"
+      end
+      @files_to_process = [
+        Utils.absolute_path(Config.entrypoint),
+        # __dir__ is typed as String? - but it shouldn't be nil here
+        Utils.absolute_path(File.join((__dir__||""), "..", "..", "sig", "core.rbs"))
+      ]
+      @processed_files = Set.new
+      @type_checker = TypeChecker.new
+    end
+
+    def run
+      @files_to_process.each do |path_string|
+        # currently steep would give an `unexpected jump` if next was used
+        unless @processed_files.member?(path_string) || OUTPUT_BY_PATH.[](path_string)
+          Gloss.logger.debug "Loading #{path_string}"
+          path = Utils.absolute_path(path_string)
+          file_contents = File.open(path).read
+          contents_tree = Parser.new(file_contents).run
+          on_new_file_referenced = proc do |pa, relative|
+            if relative
+              handle_require_relative pa
+            else
+              handle_require pa
+            end
+          end
+          OUTPUT_BY_PATH.[](path_string) = Visitor.new(contents_tree, @type_checker, on_new_file_referenced).run
+          @processed_files.add path_string
+        end
+      end
+
+      @type_checker
+    end
+
+    STDLIB_TYPE_DEPENDENCIES = {
+      "yaml" => %w[pstore dbm],
+      "rbs" => %w[logger set tsort],
+      "logger" => %w[monitor],
+    }
+
+    private def handle_require(path)
+      if path.start_with? "."
+        base = File.join(Dir.pwd, path)
+        fp = base + ".gl"
+        if File.exist? fp
+          @files_to_process << fp
+        end
+        return
+      end
+
+      # look for .gl file if the "require" refers to the lib directory of current project dir
+      full = File.absolute_path("#{File.join(Config.src_dir, "lib", path)}.gl")
+      pathn = Pathname.new full
+      if pathn.file?
+        @files_to_process << pathn.to_s
+      else
+        # no .gl file available - .rbs file available?
+        # TODO: verify file is still actually requireable
+        pathn = Pathname.new("#{File.join(Dir.pwd, "sig", path)}.rbs")
+        gem_path = Utils.gem_path_for(path)
+        if gem_path
+          sig_files = Dir.glob(File.absolute_path(File.join(gem_path, "..", "..", "sig", "**", "*.rbs")))
+          if sig_files.length.positive?
+            sig_files.each do |fp|
+              @type_checker.load_sig_path fp
+            end
+            @processed_files.add path
+            rbs_type_deps = STDLIB_TYPE_DEPENDENCIES.fetch(path) { nil }
+            if rbs_type_deps
+            rbs_type_deps.each { |d| handle_require d }
+            end
+            return
+          end
+        end
+
+        if pathn.file?
+          @type_checker.load_sig_path(pathn.to_s)
+          @processed_files.add pathn.to_s
+        else
+          rbs_stdlib_dir = File.absolute_path(File.join(@type_checker.rbs_gem_dir, "..", "..", "stdlib", path))
+          if Pathname.new(rbs_stdlib_dir).exist?
+            load_rbs_from_require_path(path)
+            rbs_type_deps = STDLIB_TYPE_DEPENDENCIES.fetch(path) { nil }
+            if rbs_type_deps
+              rbs_type_deps.each { |d| load_rbs_from_require_path d }
+            end
+          elsif Config.strict_require
+            throw :error, "Cannot resolve require path for #{path}"
+          else
+            Gloss.logger.debug "No path found for #{path}"
+          end
+        end
+      end
+    end
+
+    private def handle_require_relative(path)
+      base = File.join(@filepath, "..", path)
+      pn : String? = nil
+      Gem.suffixes.each do |ext|
+        full = File.absolute_path(base + ext)
+        pn = full if File.exist?(full)
+      end
+
+      if pn
+        @files_to_process << pn unless @files_to_process.include? pn
+      elsif Config.strict_require
+        throw :error, "Cannot resolve require path for #{pn}"
+      else
+        Gloss.logger.debug "No path found for #{path}"
+      end
+    end
+
+    private def rbs_stdlib_path_for(libr)
+      File.absolute_path(File.join(@type_checker.rbs_gem_dir, "..", "..", "stdlib", libr))
+    end
+
+    private def load_rbs_from_require_path(path)
+      Dir.glob(File.join(rbs_stdlib_path_for(path), "**", "*.rbs")).each do |fp|
+        @type_checker.load_sig_path(fp)
+        @processed_files.add fp
+      end
+    end
+  end
+end

data/src/lib/gloss/scope.gl

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Gloss
   class Scope < Hash[String, String]
     def [](k)

data/src/lib/gloss/type_checker.gl

@@ -1,10 +1,10 @@
-# frozen_string_literal: true
+require "set"
 
 module Gloss
   class TypeChecker
     Project = Struct.new :targets
 
-    attr_reader :steep_target, :top_level_decls
+    attr_reader :steep_target, :top_level_decls, :env, :rbs_gem_dir
 
     def initialize
       @steep_target = Steep::Project::Target.new(
@@ -12,62 +12,108 @@ module Gloss
         options: Steep::Project::Options.new.tap do |o|
           o.allow_unknown_constant_assignment = true
         end,
-        source_patterns: ["gloss.rb"],
+        source_patterns: ["**/*.rb"],
         ignore_patterns: Array.new,
         signature_patterns: ["sig"]
       )
-      @top_level_decls = {}
+      @top_level_decls = Set.new
+      @rbs_gem_dir = Utils.gem_path_for("rbs")
+      env_loader = RBS::EnvironmentLoader.new
+      @env = RBS::Environment.from_loader(env_loader)
+      project = Steep::Project.new(steepfile_path: Pathname.new(Config.src_dir).realpath)
+      project.targets << @steep_target
+      loader = Steep::Project::FileLoader.new(project: project)
+      #loader.load_signatures
     end
 
-    def run(rb_str)
-      unless check_types(rb_str)
-        raise Errors::TypeError,
-              @steep_target.errors.map { |e|
-                case e
-                when Steep::Errors::NoMethod
-                  "Unknown method :#{e.method}, location: #{e.type.location.inspect}"
-                when Steep::Errors::MethodBodyTypeMismatch
-                  "Invalid method body type - expected: #{e.expected}, actual: #{e.actual}"
-                when Steep::Errors::IncompatibleArguments
-                  <<-ERR
-                    Invalid argmuents - method type: #{e.method_type}
-                                        method name: #{e.method_type.method_decls.first.method_name}
-                  ERR
-                when Steep::Errors::ReturnTypeMismatch
-                  "Invalid return type - expected: #{e.expected}, actual: #{e.actual}"
-                when Steep::Errors::IncompatibleAssignment
-                  "Invalid assignment - cannot assign #{e.rhs_type} to type #{e.lhs_type}"
-                else
-                  e.inspect
-                end
-              }.join("\n")
+    def run(filepath, rb_str)
+      begin
+        valid_types = check_types filepath, rb_str
+      rescue ParseError => e
+        throw :error, ""
+      rescue => e
+        throw :error, "Type checking Error: #{e.message} (#{e.class})"
+      end
+
+      unless valid_types
+        errors = @steep_target.errors.map { |e|
+          case e
+            when Steep::Diagnostic::Ruby::NoMethod
+              "Unknown method :#{e.method}, location: #{e.type.location.inspect}"
+            when Steep::Diagnostic::Ruby::MethodBodyTypeMismatch
+              "Invalid method body type - expected: #{e.expected}, actual: #{e.actual}"
+            when Steep::Diagnostic::Ruby::IncompatibleArguments
+              <<-ERR
+              Invalid argmuents - method type: #{e.method_types.first}
+              method name: #{e.method_name}
+              ERR
+            when Steep::Diagnostic::Ruby::ReturnTypeMismatch
+              "Invalid return type - expected: #{e.expected}, actual: #{e.actual}"
+            when Steep::Diagnostic::Ruby::IncompatibleAssignment
+              "Invalid assignment - cannot assign #{e.rhs_type} to type #{e.lhs_type}"
+            when Steep::Diagnostic::Ruby::UnexpectedBlockGiven
+              "Unexpected block given"
+            else
+              "#{e.header_line}\n#{e.inspect}"
+            end
+        }.join("\n")
+        throw :error, errors
       end
 
       true
     end
 
-    def check_types(rb_str)
-      env_loader = RBS::EnvironmentLoader.new
-      env = RBS::Environment.from_loader(env_loader)
-      project = Steep::Project.new(steepfile_path: Pathname.new(Config.src_dir).realpath)
-      project.targets << @steep_target
-      loader = Steep::Project::FileLoader.new(project: project)
-      loader.load_signatures
+    def ready_for_checking!
+      @top_level_decls.each do |decl|
+        @env << decl
+      end
+      @env = @env.resolve_type_names
 
-      @steep_target.add_source("gloss.rb", rb_str)
+      @steep_target.instance_variable_set("@environment", @env)
+    end
 
-      @top_level_decls.each do |_, decl|
-        env << decl
-      end
-      env = env.resolve_type_names
+    def check_types(filepath, rb_str)
+      @steep_target.add_source(filepath, rb_str)
 
-      @steep_target.instance_variable_set("@environment", env)
+      ready_for_checking!
 
       @steep_target.type_check
 
+      if @steep_target.status.is_a? Steep::Project::Target::SignatureErrorStatus
+        throw :error, @steep_target.status.errors.map { |e|
+          msg = case e
+                when Steep::Diagnostic::Signature::UnknownTypeName
+                  "Unknown type name: #{e.name.name} (#{e.location.source[/^.*$/]})"
+                when Steep::Diagnostic::Signature::InvalidTypeApplication
+                  "Invalid type application: #{e.header_line}"
+                when Steep::Diagnostic::Signature::DuplicatedMethodDefinition
+                  "Duplicated method: #{e.header_line}"
+                else
+                  e.header_line
+                end
+          <<~MSG
+            SignatureSyntaxError:
+              Location: #{e.location}
+              Message: "#{msg}"
+          MSG
+        }.join("\n")
+      end
+
+      @steep_target.source_files.each do |path, f|
+        if f.status.is_a? Steep::Project::SourceFile::ParseErrorStatus
+          e = f.status.error
+          throw :error, "#{e.class}: #{e.message}"
+        end
+      end
+
       @steep_target.status.is_a?(Steep::Project::Target::TypeCheckStatus) &&
         @steep_target.no_error? &&
         @steep_target.errors.empty?
     end
+
+    def load_sig_path(path : String)
+      Gloss.logger.debug "Loading signature file for #{path}"
+      @steep_target.add_signature path, File.open(path).read
+    end
   end
 end