gloss 0.0.1 → 0.0.6

data/src/lib/gloss/cli.gl

@@ -0,0 +1,55 @@
+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 "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
+        else
+          throw :error, "Gloss doesn't know how to #{command}"
+        end
+        nil
+      end
+
+      if err_msg
+        Gloss.logger.fatal err_msg
+        exit 1
+      end
+    end
+  end
+end

data/src/lib/gloss/config.gl

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "yaml"
+
+module Gloss
+  CONFIG_PATH = ".gloss.yml"
+  Config = OpenStruct.new(
+    default_config: {
+      frozen_string_literals: true,
+      src_dir: "src",
+    }
+  )
+
+  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,26 @@
+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 : nil)
+      formatter = Logger::Formatter.new
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        formatter.call(severity, datetime, progname, msg)
+      end
+      @logger
+    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/scope.gl

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Gloss
+  class Scope < Hash[String, String]
+    def [](k)
+      fetch(k) { raise "Undefined expression for current scope: #{k}" }
+    end
+  end
+end

data/src/lib/gloss/source.gl

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Gloss
+  class Source < String
+    def initialize(@indent_level)
+      super()
+    end
+
+    def write(*args : String)
+      args.each do |a|
+        self << a
+      end
+      self
+    end
+
+    def write_indnt(*args : String)
+      write(*args.map { |a| "#{("  " * @indent_level)}#{a}" })
+    end
+
+    def write_ln(*args : String)
+      write_indnt(*args.map { |a| a.strip << "\n" })
+    end
+
+    def increment_indent
+      @indent_level += 1
+    end
+
+    def decrement_indent
+      @indent_level -= 1
+    end
+  end
+end

data/src/lib/gloss/type_checker.gl

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+      require "pry-byebug"
+
+module Gloss
+  class TypeChecker
+    Project = Struct.new :targets
+
+    attr_reader :steep_target, :top_level_decls
+
+    def initialize
+      @steep_target = Steep::Project::Target.new(
+        name: "gloss",
+        options: Steep::Project::Options.new.tap do |o|
+          o.allow_unknown_constant_assignment = true
+        end,
+        source_patterns: ["gloss.rb"],
+        ignore_patterns: Array.new,
+        signature_patterns: ["sig"]
+      )
+      @top_level_decls = {}
+    end
+
+    def run(rb_str)
+      begin
+        valid_types = check_types 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_type}
+              method name: #{e.method_type.method_decls.first.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.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
+
+      @steep_target.add_source("gloss.rb", rb_str)
+
+      @top_level_decls.each do |_, decl|
+        env << decl
+      end
+      env = env.resolve_type_names
+
+      @steep_target.instance_variable_set("@environment", env)
+
+      @steep_target.type_check
+
+      if @steep_target.status.is_a? Steep::Project::Target::SignatureErrorStatus
+        throw :error, @steep_target.status.errors.map { |e|
+          <<~MSG
+            SignatureSyntaxError:
+              Location: #{e.location}
+              Message: "#{e.exception.error_value.value}"
+          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
+  end
+end

data/src/lib/gloss/version.gl

@@ -0,0 +1,3 @@
+module Gloss
+  VERSION = "0.0.6"
+end

data/src/lib/gloss/watcher.gl

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "listen"
+
+module Gloss
+  class Watcher
+    def initialize(@paths : Array[String])
+      if @paths.empty?
+        @paths = [File.join(Dir.pwd, Config.src_dir)]
+        @only = /\.gl$/
+      else
+        file_names = Array.new
+        paths = Array.new
+        @paths.each do |pa|
+          pn = Pathname.new(pa)
+          paths << pn.parent.to_s
+          file_names << (pn.file? ? pn.basename.to_s : pa)
+        end
+        @paths = paths.uniq
+        @only = /#{Regexp.union(file_names)}/
+      end
+    end
+
+    def watch
+      Gloss.logger.info "Now listening for changes in #{@paths.join(', ')}"
+      listener = Listen.to(
+        *@paths,
+        latency: 2,
+        only: @only
+      ) do |modified, added, removed|
+        (modified + added).each do |f|
+          Gloss.logger.info "Rewriting #{f}"
+          content = File.read(f)
+          err = catch :error do
+            Writer.new(
+              Builder.new(
+                Parser.new(
+                  content
+                ).run
+              ).run, f
+            ).run
+            nil
+          end
+          if err
+            Gloss.logger.error err
+          else
+            Gloss.logger.info "Done"
+          end
+        end
+        removed.each do |f|
+          out_path = Utils.src_path_to_output_path(f)
+          Gloss.logger.info "Removing #{out_path}"
+          File.delete out_path if File.exist? out_path
+
+          Gloss.logger.info "Done"
+        end
+      end
+      begin
+        listener.start
+        sleep
+      rescue Interrupt
+        Gloss.logger.info "Interrupt signal received, shutting down"
+        exit 0
+      end
+    end
+  end
+end

data/src/lib/gloss/writer.gl

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "fileutils"
+
+module Gloss
+  module Utils
+    module_function
+
+    def src_path_to_output_path(src_path : String) : String
+      src_path.sub("#{Config.src_dir}/", "")
+              .sub(/\.gl$/, ".rb")
+    end
+  end
+
+  class Writer
+    include Utils
+
+    def initialize(
+      @content,
+      src_path : String,
+      @output_path : Pathname? = Pathname.new(src_path_to_output_path(src_path))
+    )
+    end
+
+    def run
+      FileUtils.mkdir_p(@output_path.parent) unless @output_path.parent.exist?
+      File.open(@output_path, "wb") do |file|
+        file.puts @content
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gloss
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.6
 platform: ruby
 authors:
 - johansenja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-30 00:00:00.000000000 Z
+date: 2021-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast_blank
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: steep
   requirement: !ruby/object:Gem::Requirement
@@ -117,40 +131,62 @@ extensions:
 - ext/gloss/extconf.rb
 extra_rdoc_files: []
 files:
+- ".gitattributes"
+- ".github/workflows/crystal_specs.yml"
+- ".github/workflows/ruby_specs.yml"
 - ".gitignore"
 - ".gloss.yml"
+- ".rspec"
 - ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.md
 - Rakefile
 - bin/console
 - exe/gloss
 - ext/gloss/Makefile
 - ext/gloss/extconf.rb
+- ext/gloss/lib/cr_ruby.cr
+- ext/gloss/lib/rbs_types.cr
 - ext/gloss/shard.yml
+- ext/gloss/spec/parser_spec.cr
+- ext/gloss/spec/spec_helper.cr
 - ext/gloss/src/cr_ast.cr
 - ext/gloss/src/gloss.cr
 - ext/gloss/src/lexer.cr
-- ext/gloss/src/lib/cr_ruby.cr
 - ext/gloss/src/parser.cr
 - ext/gloss/src/rb_ast.cr
 - gloss.gemspec
-- lib/gloss.bundle.dwarf
 - lib/gloss.rb
 - lib/gloss/builder.rb
 - lib/gloss/cli.rb
 - lib/gloss/config.rb
 - lib/gloss/errors.rb
 - lib/gloss/initializer.rb
+- lib/gloss/logger.rb
+- lib/gloss/parser.rb
 - lib/gloss/scope.rb
 - lib/gloss/source.rb
+- lib/gloss/type_checker.rb
 - lib/gloss/version.rb
 - lib/gloss/watcher.rb
 - lib/gloss/writer.rb
+- sig/gloss.rbs
 - sig/listen.rbs
-- src/lib/hrb/initializer.gl
-- src/lib/hrb/watcher.gl
+- src/lib/gloss/builder.gl
+- src/lib/gloss/cli.gl
+- src/lib/gloss/config.gl
+- src/lib/gloss/errors.gl
+- src/lib/gloss/initializer.gl
+- src/lib/gloss/logger.gl
+- src/lib/gloss/parser.gl
+- src/lib/gloss/scope.gl
+- src/lib/gloss/source.gl
+- src/lib/gloss/type_checker.gl
+- src/lib/gloss/version.gl
+- src/lib/gloss/watcher.gl
+- src/lib/gloss/writer.gl
 homepage:
 licenses:
 - MIT