gloss 0.0.1 → 0.0.6

data/lib/gloss/cli.rb

@@ -1,35 +1,75 @@
-# 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)
-
-          puts "=====> Writing #{fp}"
-          Writer.new(Builder.new(content).run, fp).run
+    def run()
+      command = @argv.first
+      files = @argv.[](((1)..(-1)))
+      err_msg = catch(:"error") { ||
+case command
+          when "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
+          when "build"
+            (if files.empty?
+              Dir.glob("#{Config.src_dir}/**/*.gl")
+            else
+              files
+            end)
+.each() { |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
+            }
+          when "init"
+            force = false
+            OptionParser.new() { |opt|
+              opt.on("--force", "-f") { ||
+                force = true
+              }
+            }
+.parse(@argv)
+            Initializer.new(force)
+.run
+          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
+       Gloss.logger.fatal(err_msg)
+       exit(1)
+      end)
     end
   end
 end

data/lib/gloss/config.rb

@@ -1,15 +1,21 @@
-# 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"}.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,34 @@
+  # 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
+        nil
+      end))
+      formatter = Logger::Formatter.new
+      @logger.formatter=(proc() { |severity, datetime, progname, msg|
+        formatter.call(severity, datetime, progname, msg)
+      })
+@logger
+    end)
+  end
+end

data/lib/gloss/parser.rb

@@ -0,0 +1,35 @@
+  # 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()
+      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
+          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
+end

data/lib/gloss/scope.rb

@@ -1,9 +1,14 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
 
-module Gloss
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
+  module Gloss
   class Scope < Hash
     def [](k)
-      fetch(k) { raise "Undefined expression for current scope: #{k}" }
+      fetch(k) { ||
+        raise("Undefined expression for current scope: #{k}")
+      }
     end
   end
 end

data/lib/gloss/source.rb

@@ -1,31 +1,34 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
 
-module Gloss
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
+  module Gloss
   class Source < String
     def initialize(indent_level)
-      super()
       @indent_level = indent_level
+      super()
     end
-
     def write(*args)
-      args.each do |a|
-        self << a
-      end
+      args.each() { |a|
+        self.<<(a)
+      }
+self
     end
-
     def write_indnt(*args)
-      write(*args.map { |a| "#{("  " * @indent_level)}#{a}" })
+      write(*args.map() { |a|
+"#{"  ".*(@indent_level)}#{a}"      })
     end
-
     def write_ln(*args)
-      write_indnt(*args.map { |a| a.strip << "\n" })
+      write_indnt(*args.map() { |a|
+        a.strip
+.<<("\n")
+      })
     end
-
-    def increment_indent
+    def increment_indent()
       @indent_level += 1
     end
-
-    def decrement_indent
+    def decrement_indent()
       @indent_level -= 1
     end
   end

data/lib/gloss/type_checker.rb

@@ -0,0 +1,96 @@
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
+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() { |o|
+        o.allow_unknown_constant_assignment=(true)
+      }, 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
+              "Invalid argmuents - method type: #{e.method_type}\nmethod name: #{e.method_type
+.method_decls
+.first
+.method_name}"
+            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() { |_, decl|
+        env.<<(decl)
+      }
+      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|
+"  SignatureSyntaxError:\n    Location: #{e.location}\n    Message: \"#{e.exception
+.error_value
+.value}\""        }
+.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
+  end
+end

data/lib/gloss/version.rb

@@ -1,3 +1,8 @@
+  # frozen_string_literal: true
+
+  ##### This file was generated by Gloss; any changes made here will be overwritten.
+  ##### See src/ to make changes
+
 module Gloss
-  VERSION = "0.0.1"
+  VERSION = "0.0.6"
 end

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$/
+      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(Builder.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