gloss 0.0.4 → 0.1.2

data/src/lib/gloss/utils.gl

@@ -0,0 +1,38 @@
+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)
+      Gem.ui.instance_variable_set :"@outs", StringIO.new
+      Gem::GemRunner.new.run(["which", gem_name])
+      Gem.ui.outs.string
+    rescue SystemExit => e
+      nil
+    end
+
+    def with_file_header(str)
+      "#{Visitor::FILE_HEADER}\n\n#{str}"
+    end
+
+    def src_path_to_output_path(src_path : String) : String
+      src_path.sub("#{Config.src_dir}/", "")
+              .sub(/\.gl$/, ".rb")
+    end
+  end
+end

data/src/lib/gloss/version.gl

@@ -1,3 +1,3 @@
 module Gloss
-  VERSION = "0.0.4"
+  VERSION = "0.1.2"
 end

data/src/lib/gloss/{builder.gl → visitor.gl}

@@ -1,27 +1,26 @@
-# frozen_string_literal: true
-
 module Gloss
-  class Builder
+  class Visitor
+    FILE_HEADER = <<~RUBY
+      #{"# frozen_string_literal: true\n" if Config.frozen_string_literals}
+      ##### This file was generated by Gloss; any changes made here will be overwritten.
+      ##### See #{Config.src_dir}/ to make changes
+    RUBY
+
     attr_reader :tree
 
-    def initialize(tree_hash, type_checker = nil)
+    def initialize(tree_hash, type_checker = nil, @on_new_file_referenced = nil)
       @indent_level = 0
       @inside_macro = false
       @eval_vars = false
       @current_scope = nil
       @tree = tree_hash
       @type_checker = type_checker
+      @after_module_function = false
     end
 
     def run
       rb_output = visit_node(@tree)
-      <<~RUBY
-        #{"# frozen_string_literal: true\n" if Config.frozen_string_literals}
-        ##### This file was generated by Gloss; any changes made here will be overwritten.
-        ##### See #{Config.src_dir}/ to make changes
-
-        #{rb_output}
-      RUBY
+      Utils.with_file_header(rb_output)
     end
 
     # type node = Hash[Symbol, String | Array[String | node] | Hash[Symbol, node]] | true | false
@@ -33,18 +32,31 @@ module Gloss
         class_name = visit_node(node[:name])
         current_namespace = @current_scope ? @current_scope.name.to_namespace : RBS::Namespace.root
         superclass_type = nil
-        superclass_output = nil
+        superclass_output = ""
         if node[:superclass]
           @eval_vars = true
           superclass_output = visit_node(node[:superclass])
           @eval_vars = false
-          superclass_type = RBS::Parser.parse_type superclass_output
+          args = Array.new
           if node.dig(:superclass, :type) == "Generic"
-            superclass_output = superclass_output[/^[^\[]+/]
+            superclass_output = superclass_output[/^[^\[]+/] || superclass_output
+            args = node.dig(:superclass, :args).map { |n| RBS::Parser.parse_type(visit_node(n)) }
           end
+
+          class_name_index = superclass_output.index(/[^(?:::)]+\z/) || 0
+          namespace = superclass_output[0, class_name_index]
+          superclass_name = superclass_output[/[^(?:::)]+\z/] || superclass_output
+          superclass_type = RBS::AST::Declarations::Class::Super.new(
+            name: RBS::TypeName.new(
+              namespace: method(:Namespace).call(namespace),
+              name: superclass_name.to_sym,
+            ),
+            args: args,
+            location: build_location(node),
+          )
         end
 
-        src.write_ln "class #{class_name}#{" < #{superclass_output}" if superclass_output}"
+        src.write_ln "class #{class_name}#{" < #{superclass_output}" unless superclass_output.blank?}"
 
         class_type = RBS::AST::Declarations::Class.new(
           name: RBS::TypeName.new(
@@ -55,7 +67,7 @@ module Gloss
           super_class: superclass_type,
           members: Array.new, # TODO
           annotations: Array.new, # TODO
-          location: node[:location],
+          location: build_location(node),
           comment: node[:comment]
         )
         old_parent_scope = @current_scope
@@ -69,10 +81,12 @@ module Gloss
 
         @current_scope.members << class_type if @current_scope
 
-        if @type_checker
-          @type_checker.top_level_decls[class_type.name.name] = class_type unless @current_scope
+        if @type_checker && !@current_scope
+          @type_checker.top_level_decls.add(class_type)
         end
       when "ModuleNode"
+        existing_module_function_state = @after_module_function.dup
+        @after_module_function = false
         module_name = visit_node node[:name]
         src.write_ln "module #{module_name}"
 
@@ -87,7 +101,7 @@ module Gloss
           self_types: Array.new, # TODO
           members: Array.new, # TODO
           annotations: Array.new, # TODO
-          location: node[:location],
+          location: build_location(node),
           comment: node[:comment]
         )
         old_parent_scope = @current_scope
@@ -99,13 +113,15 @@ module Gloss
 
         @current_scope.members << module_type if @current_scope
 
-        if @type_checker
-          @type_checker.top_level_decls[module_type.name.name] = module_type unless @current_scope
+        if @type_checker && !@current_scope
+          @type_checker.top_level_decls.add(module_type)
         end
         src.write_ln "end"
+        @after_module_function = existing_module_function_state
       when "DefNode"
         args = render_args(node)
-        src.write_ln "def #{node[:name]}#{args}"
+        receiver = node[:receiver] ? visit_node(node[:receiver]) : nil
+        src.write_ln "def #{"#{receiver}." if receiver}#{node[:name]}#{args[:representation]}"
 
         return_type = if node[:return_type]
                         RBS::Types::ClassInstance.new(
@@ -114,44 +130,25 @@ module Gloss
                             namespace: RBS::Namespace.root
                           ),
                           args: EMPTY_ARRAY, # TODO
-                          location: node[:location]
+                          location: build_location(node)
                         )
                       else
                         RBS::Types::Bases::Any.new(
-                          location: node[:location]
+                          location: build_location(node)
                         )
                       end
 
-        rp : Array[Hash[Symbol, Any]] = node.fetch(:positional_args) { EMPTY_ARRAY }.filter { |a| !a[:value] }
-        op : Array[Hash[Symbol, Any]] = node.fetch(:positional_args) { EMPTY_ARRAY }.filter { |a| a[:value] }
-
         method_types = [
           RBS::MethodType.new(
             type_params: EMPTY_ARRAY, # TODO
             type: RBS::Types::Function.new(
-              required_positionals: rp.map do |a|
-                RBS::Types::Function::Param.new(
-                  name: visit_node(a).to_sym,
-                  type: RBS::Types::Bases::Any.new(
-                    location: a[:location]
-                  )
-                )
-              end,
-              optional_positionals: op.map do |a|
-                RBS::Types::Function::Param.new(
-                  name: visit_node(a).to_sym,
-                  type: RBS::Types::Bases::Any.new(location: a[:location])
-                )
-              end,
-              rest_positionals: (rpa = node[:rest_p_args]) ? RBS::Types::Function::Param.new(name: visit_node(rpa).to_sym, type: RBS::Types::Bases::Any.new(location: node[:location])) : nil,
-              trailing_positionals: EMPTY_ARRAY, # TODO
-              required_keywords: node[:req_kw_args] || EMPTY_HASH,
-              optional_keywords: node[:opt_kw_args] || EMPTY_HASH,
-              rest_keywords: node[:rest_kw_args] ?
-                RBS::Types::Function::Param.new(
-                  name: visit_node(node[:rest_kw_args]).to_sym,
-                  type: RBS::Types::Bases::Any.new(location: node[:location])
-                ) : nil,
+              required_positionals: args.dig(:types, :required_positionals),
+              optional_positionals: args.dig(:types, :optional_positionals),
+              rest_positionals: args.dig(:types, :rest_positionals),
+              trailing_positionals: args.dig(:types, :trailing_positionals),
+              required_keywords: args.dig(:types, :required_keywords),
+              optional_keywords: args.dig(:types, :optional_keywords),
+              rest_keywords: args.dig(:types, :rest_keywords),
               return_type: return_type
             ),
             block: node[:yield_arg_count] ?
@@ -164,19 +161,19 @@ module Gloss
                   required_keywords: Hash.new,
                   optional_keywords: Hash.new,
                   rest_keywords: nil,
-                  return_type: RBS::Types::Bases::Any.new(location: node[:location])
+                  return_type: RBS::Types::Bases::Any.new(location: build_location(node))
                 ),
                 required: !!(node[:block_arg] || node[:yield_arg_count])
               ) : nil,
-            location: node[:location]
+            location: build_location(node)
           )
         ]
         method_definition = RBS::AST::Members::MethodDefinition.new(
           name: node[:name].to_sym,
-          kind: :instance,
+          kind: @after_module_function ? :singleton_instance : receiver ? :singleton : :instance,
           types: method_types,
           annotations: EMPTY_ARRAY, # TODO
-          location: node[:location],
+          location: build_location(node),
           comment: node[:comment],
           overload: false
         )
@@ -212,12 +209,19 @@ module Gloss
                             else
                               nil
                             end
-        call = "#{obj}#{node[:name]}#{opening_delimiter}#{args}#{")" if has_parens}#{block}"
+        name = node[:name]
+        call = "#{obj}#{name}#{opening_delimiter}#{args}#{")" if has_parens}#{block}"
+        case name
+        when "require_relative"
+          @on_new_file_referenced.call(name, true) if @on_new_file_referenced
+        when "module_function"
+          @after_module_function = true
+        end
         src.write_ln(call)
 
       when "Block"
-
-        src.write "{ |#{node[:args].map { |a| visit_node a }.join(", ")}|\n"
+        args = render_args node
+        src.write "{ #{args[:representation].gsub(/(\A\(|\)\z)/,'|')}\n"
 
         indented(src) { src.write visit_node(node[:body]) }
 
@@ -226,9 +230,10 @@ module Gloss
       when "RangeLiteral"
         dots = node[:exclusive] ? "..." : ".."
 
-        # parentheses help the compatibility with precendence of operators in some situations
+        # parentheses around the whole thing help the compatibility with precendence of operators in some situations
         # eg. (1..3).cover? 2 vs. 1..3.cover? 2
-        src.write "(", visit_node(node[:from]), dots, visit_node(node[:to]), ")"
+        # parentheses around either number help with things like arithemtic ((x-1)..(y+5))
+        src.write "(", "(", visit_node(node[:from]), ")", dots, "(", visit_node(node[:to]), ")", ")"
 
       when "LiteralNode"
 
@@ -256,9 +261,10 @@ module Gloss
         src.write node[:value]
 
       when "Require"
+        path = node[:value]
+        src.write_ln %(require "#{path}")
 
-        src.write_ln %(require "#{node[:value]}")
-
+        @on_new_file_referenced.call(path, false) if @on_new_file_referenced
       when "Assign", "OpAssign"
 
         src.write_ln "#{visit_node(node[:target])} #{node[:op]}= #{visit_node(node[:value]).strip}"
@@ -307,12 +313,12 @@ module Gloss
         contents = node[:elements].map do |k, v|
           key = case k
                 when String
-                  k.to_sym
+                  k.to_sym.inspect
                 else
                   visit_node k
                 end
           value = visit_node v
-          "#{key.inspect} => #{value}"
+          "#{key} => #{value}"
         end
 
         src.write "{#{contents.join(",\n")}}"
@@ -397,7 +403,8 @@ module Gloss
         src.write "return#{val}"
       when "TypeDeclaration"
         src.write_ln "# @type var #{visit_node(node[:var])}: #{visit_node(node[:declared_type])}"
-        src.write_ln "#{visit_node(node[:var])} = #{visit_node(node[:value])}"
+        value = node[:value] ? " = #{visit_node node[:value]}" : nil
+        src.write_ln "#{visit_node(node[:var])}#{value}"
       when "ExceptionHandler"
         src.write_ln "begin"
         indented src do
@@ -431,7 +438,7 @@ module Gloss
             name: method(:TypeName).call(name),
             args: Array.new,
             annotations: Array.new,
-            location: node[:location],
+            location: build_location(node),
             comment: node[:comment]
           )
         if @current_scope
@@ -447,7 +454,7 @@ module Gloss
             name: method(:TypeName).call(name),
             args: Array.new,
             annotations: Array.new,
-            location: node[:location],
+            location: build_location(node),
             comment: node[:comment]
           )
         if @current_scope
@@ -466,6 +473,9 @@ module Gloss
                    types.map { |t| visit_node(t) }.join(" | ")
                  end
         src.write output
+      when "Next"
+        val = " #{node[:value]}" if node[:value]
+        src.write "next#{val}"
       when "EmptyNode"
         # pass
       else
@@ -497,7 +507,8 @@ module Gloss
       src.decrement_indent
     end
 
-    private def render_args(node)
+    # TODO: allow NamedTuple as return type
+    private def render_args(node)# : { representation: String, types: Hash[Symbol, Any] }
       rp : Array[Hash[Symbol, Any]] = node.fetch(:positional_args) { EMPTY_ARRAY }.filter { |a| !a[:value] }
       op : Array[Hash[Symbol, Any]] = node.fetch(:positional_args) { EMPTY_ARRAY }.filter { |a| a[:value] }
       rkw : Hash[Symbol, Any] = node.fetch(:req_kw_args) { EMPTY_HASH }
@@ -514,7 +525,51 @@ module Gloss
         rest_p ? "*#{rest_p}" : "",
         rest_kw ? "**#{visit_node(rest_kw)}" : ""
       ].reject(&:empty?).flatten.join(", ")
-      "(#{contents})"
+      representation = "(#{contents})"
+      rp_args = rp.map do |a|
+        RBS::Types::Function::Param.new(
+          name: visit_node(a).to_sym,
+          type: RBS::Types::Bases::Any.new(
+            location: build_location(a)
+          )
+        )
+      end
+      op_args = op.map do |a|
+        RBS::Types::Function::Param.new(
+          name: visit_node(a).to_sym,
+          type: RBS::Types::Bases::Any.new(location: build_location(a))
+        )
+      end
+      rpa = rest_p ? RBS::Types::Function::Param.new(
+              name: rest_p.to_sym,
+              type: RBS::Types::Bases::Any.new(location: build_location(node))
+            ) : nil
+      {
+        representation: representation,
+        types: {
+          required_positionals: rp_args,
+          optional_positionals: op_args,
+          rest_positionals: rpa,
+          trailing_positionals: EMPTY_ARRAY, # TODO
+          required_keywords: node[:req_kw_args] || EMPTY_HASH,
+          optional_keywords: node[:opt_kw_args] || EMPTY_HASH,
+          rest_keywords: node[:rest_kw_args] ?
+            RBS::Types::Function::Param.new(
+              name: visit_node(node[:rest_kw_args]).to_sym,
+              type: RBS::Types::Bases::Any.new(location: build_location(node))
+            ) : nil
+        }
+      }
+    end
+
+    def build_location(node)
+      return nil unless node[:location]
+
+#      RBS::Location.new(
+#        buffer: RBS::Buffer.new(@file_path, @file_content),
+#        start_pos: node[:location][:start],
+#        end_pos: node[:location][:end]
+#      )
     end
   end
 end

data/src/lib/gloss/watcher.gl

@@ -1,30 +1,64 @@
-# frozen_string_literal: true
-
 require "listen"
 
 module Gloss
   class Watcher
-    def initialize
-      @paths = %w[src/]
+    def initialize(@paths : Array[String])
+      if @paths.empty?
+        @paths = [File.join(Dir.pwd, Config.src_dir)]
+        # either any filepath with .gl extension, or executable with extension
+        @only = /(?:(\.gl|(?:(?<=\/)[^\.\/]+))\z|\A[^\.\/]+\z)/
+      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
-      puts "=====> Now listening for changes in #{@paths.join(', ')}"
-      listener = Listen.to(*@paths, latency: 2) do |modified, added, removed|
+      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)
-          Writer.new(Builder.new(content).run, f).run
+          err = catch :error do
+            Writer.new(
+              Visitor.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
-      listener.start
       begin
-        loop { sleep 10 }
+        listener.start
+        sleep
       rescue Interrupt
-        puts "=====> Interrupt signal received, shutting down"
+        Gloss.logger.info "Interrupt signal received, shutting down"
         exit 0
       end
     end