gloss 0.0.5 → 0.1.3

data/lib/gloss/config.rb

@@ -8,7 +8,9 @@ require "yaml"
 module Gloss
   CONFIG_PATH = ".gloss.yml"
   Config = OpenStruct.new(default_config: {:frozen_string_literals => true,
-:src_dir => "src"}.freeze)
+:src_dir => "src",
+:entrypoint => nil,
+:strict_require => false}.freeze)
   user_config = (if File.exist?(CONFIG_PATH)
     YAML.safe_load(File.read(CONFIG_PATH))
   else

data/lib/gloss/errors.rb

@@ -3,7 +3,7 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+module Gloss
   module Errors
     class BaseGlossError < StandardError
     end

data/lib/gloss/initializer.rb

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

data/lib/gloss/logger.rb

@@ -0,0 +1,29 @@
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
+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((if real_log_level
+        STDOUT
+      else
+        IO::NULL
+      end))
+    end)
+  end
+end

data/lib/gloss/parser.rb

@@ -3,7 +3,7 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+module Gloss
   class Parser
     def initialize(str)
       @str = str
@@ -13,7 +13,22 @@
       begin
         JSON.parse(tree_json, symbolize_names: true)
       rescue JSON::ParserError
-        raise(Errors::ParserError, tree_json)
+        error_message = tree_json
+        error_message.match(/.+\s:(\d+)$/)
+        (if $~.[](1)
+          line_number = $~.[](1)
+.to_i
+          context = @str.lines
+.[](((          line_number.-(2)
+)..(line_number)))
+.map
+.with_index() { |line, index|
+"#{index.-(1)
+.+(line_number)}|  #{line}"          }
+.join
+          error_message = "#{context.rstrip}\n\n#{error_message}\n"
+        end)
+        throw(:"error", error_message)
       end
     end
   end

data/lib/gloss/prog_loader.rb

@@ -0,0 +1,141 @@
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
+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), Utils.absolute_path(File.join(__dir__ || "", "..", "..", "sig", "core.rbs"))]
+      @processed_files = Set.new
+      @type_checker = TypeChecker.new
+    end
+    def run()
+      @files_to_process.each() { |path_string|
+        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() { |pa, relative|
+            (if relative
+              handle_require_relative(pa)
+            else
+              handle_require(pa)
+            end)
+          }
+          OUTPUT_BY_PATH.[]=(path_string, Visitor.new(contents_tree, @type_checker, on_new_file_referenced)
+.run)
+          @processed_files.add(path_string)
+        end
+      }
+@type_checker
+    end
+    STDLIB_TYPE_DEPENDENCIES = {"yaml" => ["pstore", "dbm"],
+"rbs" => ["logger", "set", "tsort"],
+"logger" => ["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)
+      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
+        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() { |fp|
+              @type_checker.load_sig_path(fp)
+            }
+            @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)
+          else
+            (if Config.strict_require
+              throw(:"error", "Cannot resolve require path for #{path}")
+            else
+              Gloss.logger
+.debug("No path found for #{path}")
+            end)
+          end)
+        end)
+      end)
+    end
+    private     def handle_require_relative(path)
+      base = File.join(@filepath, "..", path)
+      # @type var pn: String?
+      pn = nil
+      Gem.suffixes
+.each() { |ext|
+        full = File.absolute_path(base.+(ext))
+        (if File.exist?(full)
+          pn = full
+        end)
+      }
+      (if pn
+        unless         @files_to_process.include?(pn)
+          @files_to_process.<<(pn)
+        end
+      else
+        (if Config.strict_require
+          throw(:"error", "Cannot resolve require path for #{pn}")
+        else
+          Gloss.logger
+.debug("No path found for #{path}")
+        end)
+      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() { |fp|
+        @type_checker.load_sig_path(fp)
+        @processed_files.add(fp)
+      }
+    end
+  end
+end

data/lib/gloss/scope.rb

@@ -3,7 +3,7 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+module Gloss
   class Scope < Hash
     def [](k)
       fetch(k) { ||

data/lib/gloss/source.rb

@@ -3,7 +3,7 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+module Gloss
   class Source < String
     def initialize(indent_level)
       @indent_level = indent_level

data/lib/gloss/type_checker.rb

@@ -3,64 +3,112 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+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(name: "gloss", options:       Steep::Project::Options.new
 .tap() { |o|
         o.allow_unknown_constant_assignment=(true)
-      }, source_patterns: ["gloss.rb"], ignore_patterns:       Array.new, signature_patterns: ["sig"])
-      @top_level_decls = {}
+      }, source_patterns: ["**/*.rb"], ignore_patterns:       Array.new, signature_patterns: ["sig"])
+      @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)
     end
-    def run(rb_str)
-      unless       check_types(rb_str)
-        raise(Errors::TypeError, @steep_target.errors
+    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::Errors::NoMethod
+            when Steep::Diagnostic::Ruby::NoMethod
               "Unknown method :#{e.method}, location: #{e.type
 .location
 .inspect}"
-            when Steep::Errors::MethodBodyTypeMismatch
+            when Steep::Diagnostic::Ruby::MethodBodyTypeMismatch
               "Invalid method body type - expected: #{e.expected}, actual: #{e.actual}"
-            when Steep::Errors::IncompatibleArguments
-              "  Invalid argmuents - method type: #{e.method_type}\n                      method name: #{e.method_type
-.method_decls
-.first
-.method_name}"
-            when Steep::Errors::ReturnTypeMismatch
+            when Steep::Diagnostic::Ruby::IncompatibleArguments
+              "Invalid argmuents - method type: #{e.method_types
+.first}\nmethod name: #{e.method_name}"
+            when Steep::Diagnostic::Ruby::ReturnTypeMismatch
               "Invalid return type - expected: #{e.expected}, actual: #{e.actual}"
-            when Steep::Errors::IncompatibleAssignment
+            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.inspect
+              "#{e.header_line}\n#{e.inspect}"
           end
         }
-.join("\n"))
+.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
-      @steep_target.add_source("gloss.rb", rb_str)
-      @top_level_decls.each() { |_, decl|
-        env.<<(decl)
+    def ready_for_checking!()
+      @top_level_decls.each() { |decl|
+        @env.<<(decl)
       }
-      env = env.resolve_type_names
-      @steep_target.instance_variable_set("@environment", env)
+      @env = @env.resolve_type_names
+      @steep_target.instance_variable_set("@environment", @env)
+    end
+    def check_types(filepath, rb_str)
+      @steep_target.add_source(filepath, rb_str)
+      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
+"  SignatureSyntaxError:\n    Location: #{e.location}\n    Message: \"#{msg}\""        }
+.join("\n"))
+      end)
+      @steep_target.source_files
+.each() { |path, f|
+        (if f.status
+.is_a?(Steep::Project::SourceFile::ParseErrorStatus)
+          e = f.status
+.error
+          throw(:"error", "#{e.class}: #{e.message}")
+        end)
+      }
 @steep_target.status
 .is_a?(Steep::Project::Target::TypeCheckStatus) && @steep_target.no_error? && @steep_target.errors
 .empty?
     end
+    def load_sig_path(path)
+      Gloss.logger
+.debug("Loading signature file for #{path}")
+      @steep_target.add_signature(path, File.open(path)
+.read)
+    end
   end
 end

data/lib/gloss/utils.rb

@@ -0,0 +1,44 @@
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
+require "rubygems"
+module Gloss
+  module Utils
+    module_function
+    def absolute_path(path)
+      pn = Pathname.new(path)
+      (if pn.absolute?
+        pn.to_s
+      else
+        ap = File.absolute_path(path)
+        (if File.exist?(ap)
+          ap
+        else
+          throw(:"error", "File path #{path} does not exist (also looked for #{ap})")
+        end)
+      end)
+    end
+    def gem_path_for(gem_name)
+      begin
+        Gem.ui
+.instance_variable_set(:"@outs", StringIO.new)
+        Gem::GemRunner.new
+.run(["which", gem_name])
+        Gem.ui
+.outs
+.string
+      rescue SystemExit => e
+        nil
+      end
+    end
+    def with_file_header(str)
+      "#{Visitor::FILE_HEADER}\n\n#{str}"
+    end
+    def src_path_to_output_path(src_path)
+      src_path.sub("#{Config.src_dir}/", "")
+.sub(/\.gl$/, ".rb")
+    end
+  end
+end