gloss 0.0.6 → 0.1.0

data/lib/gloss/watcher.rb

@@ -10,7 +10,7 @@ module Gloss
       @paths = paths
       (if @paths.empty?
         @paths = [File.join(Dir.pwd, Config.src_dir)]
-        @only = /\.gl$/
+        @only = /(?:(\.gl|(?:(?<=\/)[^\.\/]+))\z|\A[^\.\/]+\z)/
       else
         file_names = Array.new
         paths = Array.new
@@ -39,7 +39,7 @@ module Gloss
 .info("Rewriting #{f}")
           content = File.read(f)
           err = catch(:"error") { ||
-            Writer.new(Builder.new(Parser.new(content)
+            Writer.new(Visitor.new(Parser.new(content)
 .run)
 .run, f)
 .run

data/lib/gloss/writer.rb

@@ -3,20 +3,13 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  require "pathname"
+require "pathname"
 require "fileutils"
 module Gloss
-  module Utils
-    module_function
-    def src_path_to_output_path(src_path)
-      src_path.sub("#{Config.src_dir}/", "")
-.sub(/\.gl$/, ".rb")
-    end
-  end
   class Writer
-    include Utils
-    def initialize(content, src_path, output_path = Pathname.new(src_path_to_output_path(src_path)))
+    def initialize(content, src_path, output_path = Pathname.new(Utils.src_path_to_output_path(src_path)))
       @content = content
+      @src_path = src_path
       @output_path = output_path
     end
     def run()
@@ -25,8 +18,26 @@ module Gloss
         FileUtils.mkdir_p(@output_path.parent)
       end
       File.open(@output_path, "wb") { |file|
+        sb = shebang
+        (if sb
+          file.puts(sb)
+        end)
         file.puts(@content)
       }
     end
+    private     def shebang()
+      (if @output_path.executable?
+        first_line = File.open(@src_path) { |f|
+          f.readline
+        }
+        (if first_line.start_with?("#!")
+          first_line
+        else
+          nil
+        end)
+      else
+        nil
+      end)
+    end
   end
 end

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,26 @@
+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"
+
+is_ci = ENV.fetch("CI") { false }
+require "gls" unless is_ci # a bit of a hack for now
+
+EMPTY_ARRAY = Array.new.freeze
+EMPTY_HASH = {}.freeze

data/src/lib/gloss/cli.gl

@@ -12,44 +12,59 @@ module Gloss
       files = @argv[1..-1]
       err_msg = catch :error do
         case command
-        when "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
-        when "build"
-          (files.empty? ? Dir.glob("#{Config.src_dir}/**/*.gl") : files).each do |fp|
-            Gloss.logger.info "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)
-
-            Gloss.logger.info "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
         nil
       end
 
-      if err_msg
-        Gloss.logger.fatal err_msg
-        exit 1
-      end
+      abort err_msg if err_msg
     end
   end
 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/logger.gl

@@ -15,12 +15,7 @@ module Gloss
         nil => nil,
         "" => nil
       }.fetch env_log_level
-      @logger = Logger.new(real_log_level ? STDOUT : nil)
-      formatter = Logger::Formatter.new
-      @logger.formatter = proc do |severity, datetime, progname, msg|
-        formatter.call(severity, datetime, progname, msg)
-      end
-      @logger
+      @logger = Logger.new(real_log_level ? STDOUT : IO::NULL)
     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,11 +1,10 @@
-# frozen_string_literal: true
-      require "pry-byebug"
+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(
@@ -13,16 +12,23 @@ 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)
+    def run(filepath, rb_str)
       begin
-        valid_types = check_types rb_str
+        valid_types = check_types filepath, rb_str
       rescue ParseError => e
         throw :error, ""
       rescue => e
@@ -38,8 +44,8 @@ module Gloss
               "Invalid method body type - expected: #{e.expected}, actual: #{e.actual}"
             when Steep::Diagnostic::Ruby::IncompatibleArguments
               <<-ERR
-              Invalid argmuents - method type: #{e.method_type}
-              method name: #{e.method_type.method_decls.first.method_name}
+              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}"
@@ -48,7 +54,7 @@ module Gloss
             when Steep::Diagnostic::Ruby::UnexpectedBlockGiven
               "Unexpected block given"
             else
-              e.inspect
+              "#{e.header_line}\n#{e.inspect}"
             end
         }.join("\n")
         throw :error, errors
@@ -57,31 +63,38 @@ module Gloss
       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: "#{e.exception.error_value.value}"
+              Message: "#{msg}"
           MSG
         }.join("\n")
       end
@@ -97,5 +110,10 @@ module Gloss
         @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