gloss 0.0.2 → 0.1.0

data/lib/gloss/watcher.rb

@@ -1,31 +1,75 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
 
-require "listen"
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
+require "listen"
 module Gloss
   class Watcher
-    def initialize
-      @paths = %w[src/]
+    def initialize(paths)
+      @paths = paths
+      (if @paths.empty?
+        @paths = [File.join(Dir.pwd, Config.src_dir)]
+        @only = /(?:(\.gl|(?:(?<=\/)[^\.\/]+))\z|\A[^\.\/]+\z)/
+      else
+        file_names = Array.new
+        paths = Array.new
+        @paths.each() { |pa|
+          pn = Pathname.new(pa)
+          paths.<<(pn.parent
+.to_s)
+          file_names.<<((if pn.file?
+            pn.basename
+.to_s
+          else
+            pa
+          end))
+        }
+        @paths = paths.uniq
+        @only = /#{Regexp.union(file_names)}/
+      end)
     end
-
-    def watch
-      puts "=====> Now listening for changes in #{@paths.join(', ')}"
-      listener = Listen.to(*@paths, latency: 2) do |modified, added, removed|
-        (modified + added).each do |f|
+    def watch()
+      Gloss.logger
+.info("Now listening for changes in #{@paths.join(", ")}")
+      listener = Listen.to(*@paths, latency: 2, only: @only) { |modified, added, removed|
+        modified.+(added)
+.each() { |f|
+          Gloss.logger
+.info("Rewriting #{f}")
           content = File.read(f)
-          Writer.new(Builder.new(content).run, f).run
-        end
-        removed.each do |f|
+          err = catch(:"error") { ||
+            Writer.new(Visitor.new(Parser.new(content)
+.run)
+.run, f)
+.run
+nil          }
+          (if err
+            Gloss.logger
+.error(err)
+          else
+            Gloss.logger
+.info("Done")
+          end)
+        }
+        removed.each() { |f|
           out_path = Utils.src_path_to_output_path(f)
-          File.delete out_path if File.exist? out_path
-        end
-      end
-      listener.start
+          Gloss.logger
+.info("Removing #{out_path}")
+          (if File.exist?(out_path)
+            File.delete(out_path)
+          end)
+          Gloss.logger
+.info("Done")
+        }
+      }
       begin
-        loop { sleep 10 }
+        listener.start
+        sleep
       rescue Interrupt
-        puts "=====> Interrupt signal received, shutting down"
-        exit 0
+        Gloss.logger
+.info("Interrupt signal received, shutting down")
+        exit(0)
       end
     end
   end

data/lib/gloss/writer.rb

@@ -1,26 +1,43 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
 
-module Gloss
-  module Utils
-    module_function
-
-    def src_path_to_output_path(src_path)
-      src_path.sub(%r{\A(?:\./)?#{Config.src_dir}/?}, "")
-    end
-  end
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
 
+require "pathname"
+require "fileutils"
+module Gloss
   class Writer
-    include Utils
-
-    def initialize(content, src_path, output_path = nil)
-      @content, @src_path = content, src_path
-      @output_path = output_path || 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
-      File.open(@output_path, "wb") do |file|
-        file << @content
+    def run()
+      unless       @output_path.parent
+.exist?
+        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/gls.rbs

@@ -0,0 +1,3 @@
+module Gloss
+  def self.parse_buffer: (String) -> String
+end

data/sig/listen.rbs

@@ -19,6 +19,7 @@ module Listen
                 ?ignore: Regexp | Array[Regexp],
                 ?ignore!: Regexp,
                 ?only: Regexp?,
+                ?latency: (Integer | Float)?,
                 ?polling_fallback_message: String?) {
                   (Array[String] modified, Array[String] added, Array[String] removed) -> void
                 } -> Listener

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

@@ -0,0 +1,70 @@
+require "optparse"
+
+module Gloss
+  class CLI
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def run
+      # TODO: allow destructuring: command, *files = @argv
+      command = @argv.first
+      files = @argv[1..-1]
+      err_msg = catch :error do
+        case command
+        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
+
+      abort err_msg if err_msg
+    end
+  end
+end

data/src/lib/gloss/config.gl

@@ -0,0 +1,21 @@
+require "ostruct"
+require "yaml"
+
+module Gloss
+  CONFIG_PATH = ".gloss.yml"
+  Config = OpenStruct.new(
+    default_config: {
+      frozen_string_literals: true,
+      src_dir: "src",
+      entrypoint: nil,
+      strict_require: false
+    }
+  )
+
+  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/src/lib/gloss/errors.gl

@@ -0,0 +1,11 @@
+module Gloss
+  module Errors
+    abstract class BaseGlossError < StandardError; end
+
+    class TypeValidationError < BaseGlossError; end
+
+    class TypeError < BaseGlossError; end
+
+    class ParserError < BaseGlossError; end
+  end
+end

data/src/lib/gloss/initializer.gl

@@ -0,0 +1,20 @@
+require "yaml"
+
+module Gloss
+  class Initializer
+    def initialize(@force)
+    end
+
+    def run
+      if File.exist?(CONFIG_PATH) && !@force
+        throw :error, "#{CONFIG_PATH} file already exists - aborting. Use --force to override."
+      end
+
+      File.open(CONFIG_PATH, "wb") do |file|
+        file.puts Config.default_config.transform_keys(&:to_s).to_yaml
+      end
+
+      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

@@ -0,0 +1,31 @@
+module Gloss
+  class Parser
+    def initialize(@str : String)
+    end
+
+    def run : String
+      tree_json = Gloss.parse_buffer(@str)
+      begin
+        JSON.parse tree_json, symbolize_names: true
+      rescue JSON::ParserError
+        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
+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