gloss 0.0.2 → 0.1.0

data/lib/gloss.rb

@@ -1,10 +1,12 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
 require "rbs"
 require "json"
 require "steep"
 require "fast_blank"
-
 require "gloss/version"
 require "gloss/cli"
 require "gloss/watcher"
@@ -15,10 +17,16 @@ require "gloss/config"
 require "gloss/writer"
 require "gloss/source"
 require "gloss/scope"
-require "gloss/builder"
+require "gloss/visitor"
 require "gloss/errors"
-
-require "gls" unless ENV["CI"] # a bit of a hack for now
-
-EMPTY_ARRAY = [].freeze
+require "gloss/logger"
+require "gloss/prog_loader"
+require "gloss/utils"
+is_ci = ENV.fetch("CI") { ||
+false}
+unless is_ci
+  require "gls"
+end
+EMPTY_ARRAY = Array.new
+.freeze
 EMPTY_HASH = {}.freeze

data/lib/gloss/cli.rb

@@ -1,38 +1,96 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
 
-require "optparse"
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
+require "optparse"
 module Gloss
   class CLI
     def initialize(argv)
       @argv = argv
     end
-
-    def run
-      command, *files = @argv
-      case command
-      when "watch"
-        Watcher.new.watch
-      when "build"
-        (files.empty? ? Dir.glob("#{Config.src_dir}/**/*.rb") : 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)
-
-          puts "=====> Writing #{fp}"
-          Writer.new(rb_output, fp).run
+    def run()
+      command = @argv.first
+      files = @argv.[](((1)..(-1)))
+      err_msg = catch(:"error") { ||
+case command
+          when "init"
+            force = false
+            OptionParser.new() { |opt|
+              opt.on("--force", "-f") { ||
+                force = true
+              }
+            }
+.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() { |f|
+                path = (if Pathname.new(f)
+.absolute?
+                  f
+                else
+                  File.join(Dir.pwd, f)
+                end)
+                (if Pathname.new(path)
+.exist?
+                  path
+                else
+                  throw(:"error", "Pathname #{f} does not exist")
+                end)
+              }
+              Watcher.new(files)
+.watch
+            else
+              (if command.==("build")
+                entry_tree = Parser.new(File.read(Config.entrypoint))
+.run
+                Visitor.new(entry_tree, type_checker)
+.run
+                (if files.empty?
+                  files = Dir.glob("#{Config.src_dir}/**/*.gl")
+                end)
+                files.each() { |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)
+                }
+                files.each() { |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
-      when "init"
-        force = false
-        OptionParser.new do |opt|
-          opt.on("--force", "-f") { force = true }
-        end.parse(@argv)
-        Initializer.new(force).run
-      else
-        abort "Gloss doesn't know how to #{command}"
-      end
+nil      }
+      (if err_msg
+        abort(err_msg)
+      end)
     end
   end
 end

data/lib/gloss/config.rb

@@ -1,15 +1,23 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
 require "ostruct"
 require "yaml"
-
 module Gloss
-  user_config = YAML.safe_load(File.read(".gloss.yml"))
-  Config = OpenStruct.new(
-    default_config: {
-      frozen_string_literals: true,
-      src_dir: "src",
-    }.freeze
-  )
-  Config.default_config.each { |k, v| Config.send(:"#{k}=", user_config[k.to_s] || v) }
+  CONFIG_PATH = ".gloss.yml"
+  Config = OpenStruct.new(default_config: {:frozen_string_literals => true,
+:src_dir => "src",
+:entrypoint => nil,
+:strict_require => false}.freeze)
+  user_config = (if File.exist?(CONFIG_PATH)
+    YAML.safe_load(File.read(CONFIG_PATH))
+  else
+    Config.default_config
+  end)
+  Config.default_config
+.each() { |k, v|
+    Config.send(:"#{k}=", user_config.[](k.to_s) || v)
+  }
 end

data/lib/gloss/errors.rb

@@ -1,11 +1,17 @@
-module Gloss
-  module Errors
-    class BaseGlossError < StandardError; end
-
-    class TypeValidationError < BaseGlossError; end
+  # frozen_string_literal: true
 
-    class TypeError < BaseGlossError; end
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
-    class ParserError < BaseGlossError; end
+module Gloss
+  module Errors
+    class BaseGlossError < StandardError
+    end
+    class TypeValidationError < BaseGlossError
+    end
+    class TypeError < BaseGlossError
+    end
+    class ParserError < BaseGlossError
+    end
   end
 end

data/lib/gloss/initializer.rb

@@ -1,4 +1,8 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
 require "yaml"
 module Gloss
   class Initializer
@@ -6,15 +10,16 @@ module Gloss
       @force = force
     end
     def run()
-      (if File.exist?(".gloss.yml") && !@force
-        abort(".gloss.yml file already exists - aborting. Use --force to override.")
+      (if File.exist?(CONFIG_PATH) && !@force
+        throw(:"error", "#{CONFIG_PATH} file already exists - aborting. Use --force to override.")
       end)
-      File.open(".gloss.yml", "wb") { |file|
+      File.open(CONFIG_PATH, "wb") { |file|
         file.puts(Config.default_config
-.transform_keys(&:to_s)
+.transform_keys(&:"to_s")
 .to_yaml)
       }
-      puts("Created .gloss.yml 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

@@ -1,17 +1,34 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
 module Gloss
   class Parser
     def initialize(str)
       @str = str
     end
-
-    def run
+    def run()
       tree_json = Gloss.parse_buffer(@str)
       begin
-        JSON.parse tree_json, symbolize_names: true
+        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