gloss 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a630a77074bd1fa44113b542bd04b312957e3d59834dc9dec0282466e60d50a
-  data.tar.gz: 653fc89b0793a114f9d6a04348a63d76368db464bf93a713268467140551680c
+  metadata.gz: a26f64e872c2884f2fa5969d762e66ed6f1346732933f08ae7b92eb07aea5ab3
+  data.tar.gz: 9cf39520e8dc43e6a74f9ea606a719815e2bd503d19744c7979478f746b8345f
 SHA512:
-  metadata.gz: 0f8573f5596495a00d31c102edf033f010f07092a6441a26809dc7d0044e906651058191ff9b37a87d840cae4fb16916aad76e27d219688824cd06366ef46c3c
-  data.tar.gz: 22a085469dd74a3c88d3334ac8c75c44ea8e43fbca211acc5e25cd83230bc435b48b262787d6eccacf2efff2f4ed5324aa11a3e102e1aa9bc0ebe1dba04d2564
+  metadata.gz: bdb98f72e57945e9de8bbd03296d95b2cfc221f915e7e8e8fd511e8b4794ef3bb65f1830d9769486c30a004595c3a7f84e3e785bb1b1297d778cff984a0a3234
+  data.tar.gz: 9758d730e858adf27c60f89ec9e88ffb07d3950d2a4f493b1d0ad2b00b7a10999fd76c9ae802753428fdfb0cab005adfe773456c415b504809217507ac30fbc5

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gloss (0.0.4)
+    gloss (0.0.5)
       fast_blank
       listen
       rbs
@@ -17,9 +17,8 @@ GEM
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
     ast (2.4.1)
-    ast_utils (0.3.0)
-      parser (~> 2.4)
-      thor (>= 0.19)
+    ast_utils (0.4.0)
+      parser (>= 2.7.0)
     byebug (11.1.3)
     coderay (1.1.3)
     concurrent-ruby (1.1.8)
@@ -50,7 +49,7 @@ GEM
     rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (1.0.3)
+    rbs (1.0.4)
     regexp_parser (2.0.3)
     rexml (3.2.4)
     rspec (3.10.0)
@@ -78,15 +77,14 @@ GEM
     rubocop-ast (1.4.0)
       parser (>= 2.7.1.5)
     ruby-progressbar (1.11.0)
-    steep (0.39.0)
+    steep (0.40.0)
       activesupport (>= 5.1)
-      ast_utils (~> 0.3.0)
+      ast_utils (>= 0.4.0)
       language_server-protocol (~> 3.15.0.1)
       listen (~> 3.0)
-      parser (~> 2.7.0)
+      parser (>= 2.7)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (~> 1.0.0)
-    thor (1.1.0)
+      rbs (~> 1.0.3)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (1.7.0)

data/ext/gloss/spec/parser_spec.cr

@@ -16,13 +16,13 @@ module Gloss
       Gloss.parse_string("hsh = {}").should be_truthy
     end
 
-    it "parses all kinds of method args" do
-      output = %q|{"type":"DefNode","name":"abc","body":null,"rp_args":[{"type":"Arg","name":"a","external_name":"a","default_value":null,"restriction":{"type":"Path","value":"Float"},"keyword_arg":false},{"type":"Arg","name":"b","external_name":"b","default_value":null,"restriction":null,"keyword_arg":false},{"type":"Arg","name":"c","external_name":"c","default_value":null,"restriction":null,"keyword_arg":false,splat: "true"},{"type":"Arg","name":"d","external_name":"d","default_value":{"type":"LiteralNode","value":"nil","rb_type":"NilClass"},"restriction":{"type":"Union","types":[{"type":"Path","value":"String"},{"type":"Path","value":"Nil"}]},"keyword_arg":false},{"type":"Arg","name":"e","external_name":"e","default_value":null,"restriction":{"type":"Path","value":"Integer"},"keyword_arg":true},{"type":"Arg","name":"f","external_name":"f","default_value":null,"restriction":null,"keyword_arg":true},{"type":"Arg","name":"g","external_name":"g","default_value":{"type":"LiteralNode","value":"nil","rb_type":"NilClass"},"restriction":{"type":"Path","value":"String"},"keyword_arg":true}],"receiver":null,"return_type":null,"rest_kw_args":{"type":"Arg","name":"h","external_name":"h","default_value":null,"restriction":null,"keyword_arg":false}}|
-      Gloss.parse_string(<<-GLS).should eq output
-        def abc(a : Float, b, *c, d : String? = nil, e: : Integer, f:, g: : String = nil, **h)
-        end
-      GLS
-    end
+    # it "parses all kinds of method args" do
+    #   output = %q|{"type":"DefNode","name":"abc","body":null,"rp_args":[{"type":"Arg","name":"a","external_name":"a","default_value":null,"restriction":{"type":"Path","value":"Float"},"keyword_arg":false},{"type":"Arg","name":"b","external_name":"b","default_value":null,"restriction":null,"keyword_arg":false},{"type":"Arg","name":"c","external_name":"c","default_value":null,"restriction":null,"keyword_arg":false,splat: "true"},{"type":"Arg","name":"d","external_name":"d","default_value":{"type":"LiteralNode","value":"nil","rb_type":"NilClass"},"restriction":{"type":"Union","types":[{"type":"Path","value":"String"},{"type":"Path","value":"Nil"}]},"keyword_arg":false},{"type":"Arg","name":"e","external_name":"e","default_value":null,"restriction":{"type":"Path","value":"Integer"},"keyword_arg":true},{"type":"Arg","name":"f","external_name":"f","default_value":null,"restriction":null,"keyword_arg":true},{"type":"Arg","name":"g","external_name":"g","default_value":{"type":"LiteralNode","value":"nil","rb_type":"NilClass"},"restriction":{"type":"Path","value":"String"},"keyword_arg":true}],"receiver":null,"return_type":null,"rest_kw_args":{"type":"Arg","name":"h","external_name":"h","default_value":null,"restriction":null,"keyword_arg":false}}|
+    #   Gloss.parse_string(<<-GLS).should eq output
+    #     def abc(a : Float, b, *c, d : String? = nil, e: : Integer, f:, g: : String = nil, **h)
+    #     end
+    #   GLS
+    # end
 
     it "parses rescue with ruby syntax" do
       Gloss.parse_string(<<-GLOSS).should be_truthy
@@ -35,90 +35,90 @@ module Gloss
         end
       GLOSS
     end
-  end
-
-  it "parses shorthand blocks with ruby syntax" do
-    Gloss.parse_string("[1].map(&:to_s)").should eq(
-      %q<{"type":"Call","name":"map","args":[],"object":{"type":"ArrayLiteral","elements":[{"type":"LiteralNode","value":"1","rb_type":"Integer"}],"frozen":false},"block":null,"block_arg":{"type":"LiteralNode","value":":to_s","rb_type":"Symbol"}}>
-    )
-  end
-
-  it "parses tuples as frozen arrays" do
-    Gloss.parse_string("{ 'hello', 'world' }").should eq(
-      %q<{"type":"ArrayLiteral","elements":[{"type":"LiteralNode","value":"\"hello\"","rb_type":"String"},{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}],"frozen":true}>
-    )
-  end
 
-  it "parses named tuples as frozen hashes" do
-    Gloss.parse_string("{ hello: 'world' }").should eq(
-      %q<{"type":"HashLiteral","elements":[["hello",{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}]],"frozen":true}>
-    )
-  end
-
-  it "parses the and operator" do
-    Gloss.parse_string("puts 'hello world' if 1 and 2").should be_truthy
-  end
-
-  it "parses the or operator" do
-    Gloss.parse_string("puts 'hello world' if true or false").should be_truthy
-  end
-
-  it "parses the not operator" do
-    Gloss.parse_string("puts 'hello world' if true and not false").should be_truthy
-  end
+    # it "parses shorthand blocks with ruby syntax" do
+    #   Gloss.parse_string("[1].map(&:to_s)").should eq(
+    #     %q<{"type":"Call","name":"map","args":[],"object":{"type":"ArrayLiteral","elements":[{"type":"LiteralNode","value":"1","rb_type":"Integer"}],"frozen":false},"block":null,"block_arg":{"type":"LiteralNode","value":":to_s","rb_type":"Symbol"}}>
+    #   )
+    # end
 
-  it "parses global variables" do
-    Gloss.parse_string("$var : String = 'hello world'").should eq(
-      %q|{"type":"TypeDeclaration","var":{"type":"GlobalVar","name":"$var"},"declared_type":{"type":"Path","value":"String"},"value":{"type":"LiteralNode","value":"\"hello world\"","rb_type":"String"},"var_type":"GlobalVar"}|
-    )
-  end
-
-  it "parses for loops" do
-    Gloss.parse_string(<<-GLS).should be_truthy
-      for k, v in { hello: world }
-        puts key: k, value: v
-      end
-    GLS
-  end
+    it "parses tuples as frozen arrays" do
+      Gloss.parse_string("{ 'hello', 'world' }").should eq(
+        %q<{"type":"ArrayLiteral","elements":[{"type":"LiteralNode","value":"\"hello\"","rb_type":"String"},{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}],"frozen":true}>
+      )
+    end
 
-  it "parses generics as RBS generics" do
-    expected =
-      %q|{"type":"TypeDeclaration","var":{"type":"Var","name":"hsh"},"declared_type":{"type":"Generic","name":{"type":"Path","value":"Hash"},"args":[{"type":"Path","value":"String"},{"type":"Path","value":"String"}]},"value":{"type":"HashLiteral","elements":[[{"type":"LiteralNode","value":"\"hello\"","rb_type":"String"},{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}]],"frozen":false},"var_type":"Var"}|
-    Gloss.parse_string(<<-GLS).should eq expected
-      hsh : Hash[String, String] = { "hello" => "world" }
-    GLS
-  end
+    it "parses named tuples as frozen hashes" do
+      Gloss.parse_string("{ hello: 'world' }").should eq(
+        %q<{"type":"HashLiteral","elements":[["hello",{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}]],"frozen":true}>
+      )
+    end
 
-  it "parses method calls in case statements" do
-    expected =
-      %q|{"type":"Case","condition":{"type":"LiteralNode","value":"\"abc\"","rb_type":"String"},"whens":[{"type":"When","conditions":[{"type":"Proc","function":{"type":"DefNode","name":"->","body":{"type":"Call","name":"start_with?","args":[{"type":"LiteralNode","value":"\"a\"","rb_type":"String"}],"object":{"type":"Var","name":"x"},"block":null,"block_arg":null},"rp_args":[{"type":"Arg","name":"x","external_name":"x","default_value":null,"restriction":null,"keyword_arg":false}],"receiver":null,"return_type":null,"rest_kw_args":null}}],"body":{"type":"LiteralNode","value":"1","rb_type":"Integer"},"exhaustive":false}],"else":{"type":"LiteralNode","value":"0","rb_type":"Integer"},"exhaustive":false}|
-    Gloss.parse_string(<<-GLS).should eq expected
-      case "abc"
-      when .start_with? 'a'
-        1
-      else
-        0
-      end
-    GLS
-  end
+    # it "parses the and operator" do
+    #   Gloss.parse_string("puts 'hello world' if 1 and 2").should be_truthy
+    # end
 
-  it "allows constant methods" do
-    Gloss.parse_string(<<-GLS).should be_truthy
-      def Hello(arg = nil)
-      end
+    # it "parses the or operator" do
+    #   Gloss.parse_string("puts 'hello world' if true or false").should be_truthy
+    # end
 
-      Hello()
+    # it "parses the not operator" do
+    #   Gloss.parse_string("puts 'hello world' if true and not false").should be_truthy
+    # end
 
-      Hello("a")
-    GLS
-  end
+    it "parses global variables" do
+      Gloss.parse_string("$var : String = 'hello world'").should eq(
+        %q|{"type":"TypeDeclaration","var":{"type":"GlobalVar","name":"$var"},"declared_type":{"type":"Path","value":"String"},"value":{"type":"LiteralNode","value":"\"hello world\"","rb_type":"String"},"var_type":"GlobalVar"}|
+      )
+    end
 
-  it "requires constant methods to be called with ()" do
-    Gloss.parse_string(<<-GLS).should be_falsey
-      def Hello(arg = nil)
-      end
+    # it "parses for loops" do
+    #   Gloss.parse_string(<<-GLS).should be_truthy
+    #     for k, v in { hello: world }
+    #       puts key: k, value: v
+    #     end
+    #   GLS
+    # end
+
+    it "parses generics as RBS generics" do
+      expected =
+        %q|{"type":"TypeDeclaration","var":{"type":"Var","name":"hsh"},"declared_type":{"type":"Generic","name":{"type":"Path","value":"Hash"},"args":[{"type":"Path","value":"String"},{"type":"Path","value":"String"}]},"value":{"type":"HashLiteral","elements":[[{"type":"LiteralNode","value":"\"hello\"","rb_type":"String"},{"type":"LiteralNode","value":"\"world\"","rb_type":"String"}]],"frozen":false},"var_type":"Var"}|
+      Gloss.parse_string(<<-GLS).should eq expected
+        hsh : Hash[String, String] = { "hello" => "world" }
+      GLS
+    end
 
-      Hello
-    GLS
+    # it "parses method calls in case statements" do
+    #   expected =
+    #     %q|{"type":"Case","condition":{"type":"LiteralNode","value":"\"abc\"","rb_type":"String"},"whens":[{"type":"When","conditions":[{"type":"Proc","function":{"type":"DefNode","name":"->","body":{"type":"Call","name":"start_with?","args":[{"type":"LiteralNode","value":"\"a\"","rb_type":"String"}],"object":{"type":"Var","name":"x"},"block":null,"block_arg":null},"rp_args":[{"type":"Arg","name":"x","external_name":"x","default_value":null,"restriction":null,"keyword_arg":false}],"receiver":null,"return_type":null,"rest_kw_args":null}}],"body":{"type":"LiteralNode","value":"1","rb_type":"Integer"},"exhaustive":false}],"else":{"type":"LiteralNode","value":"0","rb_type":"Integer"},"exhaustive":false}|
+    #   Gloss.parse_string(<<-GLS).should eq expected
+    #     case "abc"
+    #     when .start_with? 'a'
+    #       1
+    #     else
+    #       0
+    #     end
+    #   GLS
+    # end
+
+    # it "allows constant methods" do
+    #   Gloss.parse_string(<<-GLS).should be_truthy
+    #     def Hello(arg = nil)
+    #     end
+
+    #     Hello()
+
+    #     Hello("a")
+    #   GLS
+    # end
+
+    # it "requires constant methods to be called with ()" do
+    #   Gloss.parse_string(<<-GLS).should be_falsey
+    #     def Hello(arg = nil)
+    #     end
+
+    #     Hello
+    #   GLS
+    # end
   end
 end

data/ext/gloss/src/cr_ast.cr

@@ -140,7 +140,9 @@ module Crystal
 
   class Block < ASTNode
     def to_rb
-      Rb::AST::Block.new(@args.map(&.to_rb), @body.to_rb)
+      positional_args = args.dup
+      splat = @splat_index ? positional_args.delete_at(@splat_index.as(Int32)) : nil
+      Rb::AST::Block.new(positional_args.map(&.to_rb), splat.try &.to_rb, @body.to_rb)
     end
   end
 

data/ext/gloss/src/rb_ast.cr

@@ -43,13 +43,14 @@ module Rb
     end
 
     class Block < Node
-      @info : NamedTuple(type: String, args: Array(Var), body: Node)
+      @info : NamedTuple(type: String, positional_args: Array(Var), body: Node, rest_p_args: Node?)
 
-      def initialize(args, body)
+      def initialize(args, splat, body)
         @info = {
           type: self.class.name.split("::").last,
           body: body,
-          args: args,
+          positional_args: args,
+          rest_p_args: splat
         }
       end
 

data/lib/gloss/builder.rb

@@ -3,8 +3,18 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
+module Gloss
+  module Utils
+    module_function
+    def with_file_header(str)
+      "#{Builder::FILE_HEADER}\n\n#{str}"
+    end
+  end
   class Builder
+    FILE_HEADER = "  #{(if Config.frozen_string_literals
+      "# frozen_string_literal: true\n"
+    end)}\n  ##### This file was generated by Gloss; any changes made here will be overwritten.\n  ##### See #{Config.src_dir}/ to make changes"
+    include Utils
     attr_reader(:"tree")
     def initialize(tree_hash, type_checker = nil)
       @indent_level = 0
@@ -16,9 +26,7 @@
     end
     def run()
       rb_output = visit_node(@tree)
-"  #{(if Config.frozen_string_literals
-        "# frozen_string_literal: true\n"
-      end)}\n  ##### This file was generated by Gloss; any changes made here will be overwritten.\n  ##### See #{Config.src_dir}/ to make changes\n\n  #{rb_output}"
+      with_file_header(rb_output)
     end
     def visit_node(node, scope = Scope.new)
       src = Source.new(@indent_level)
@@ -99,7 +107,7 @@ case node.[](:"type")
           src.write_ln("end")
         when "DefNode"
           args = render_args(node)
-          src.write_ln("def #{node.[](:"name")}#{args}")
+          src.write_ln("def #{node.[](:"name")}#{args.[](:"representation")}")
           return_type = (if node.[](:"return_type")
             RBS::Types::ClassInstance.new(name:             RBS::TypeName.new(name:             eval(visit_node(node.[](:"return_type")))
 .to_s
@@ -107,34 +115,7 @@ case node.[](:"type")
           else
             RBS::Types::Bases::Any.new(location:             node.[](:"location"))
           end)
-          # @type var rp: Array[Hash[Symbol, Any]]
-          rp =           node.fetch(:"positional_args") { ||
-EMPTY_ARRAY          }
-.filter() { |a|
-!a.[](:"value")          }
-          # @type var op: Array[Hash[Symbol, Any]]
-          op =           node.fetch(:"positional_args") { ||
-EMPTY_ARRAY          }
-.filter() { |a|
-            a.[](:"value")
-          }
-          method_types = [RBS::MethodType.new(type_params: EMPTY_ARRAY, type:           RBS::Types::Function.new(required_positionals:           rp.map() { |a|
-            RBS::Types::Function::Param.new(name:             visit_node(a)
-.to_sym, type:             RBS::Types::Bases::Any.new(location:             a.[](:"location")))
-          }, optional_positionals:           op.map() { |a|
-            RBS::Types::Function::Param.new(name:             visit_node(a)
-.to_sym, type:             RBS::Types::Bases::Any.new(location:             a.[](:"location")))
-          }, rest_positionals:           (if 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")))
-          else
-            nil
-          end), trailing_positionals: EMPTY_ARRAY, required_keywords: node.[](:"req_kw_args") || EMPTY_HASH, optional_keywords: node.[](:"opt_kw_args") || EMPTY_HASH, rest_keywords:           (if 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")))
-          else
-            nil
-          end), return_type: return_type), block:           (if node.[](:"yield_arg_count")
+          method_types = [RBS::MethodType.new(type_params: EMPTY_ARRAY, type:           RBS::Types::Function.new(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:           (if node.[](:"yield_arg_count")
             RBS::Types::Block.new(type:             RBS::Types::Function.new(required_positionals:             Array.new, optional_positionals:             Array.new, rest_positionals: nil, trailing_positionals:             Array.new, required_keywords:             Hash.new, optional_keywords:             Hash.new, rest_keywords: nil, return_type:             RBS::Types::Bases::Any.new(location:             node.[](:"location"))), required: !!node.[](:"block_arg") || node.[](:"yield_arg_count"))
           else
             nil
@@ -203,11 +184,9 @@ EMPTY_ARRAY          }
           end)}#{block}"
           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")))
           }
@@ -391,7 +370,7 @@ EMPTY_ARRAY          }
           end
           # @type var expanded: Array[String]
           expanded =           eval(visit_node(expr))
-.map() { |a|
+.map() { |*a|
             locals = [var_names.join("\", \"")].zip(a)
 .to_h
             (if @inside_macro
@@ -538,6 +517,11 @@ EMPTY_ARRAY          }
 .join(" | ")
           end)
           src.write(output)
+        when "Next"
+          (if node.[](:"value")
+            val = " #{node.[](:"value")}"
+          end)
+          src.write("next#{val}")
         when "EmptyNode"
           # no op
         else
@@ -610,7 +594,35 @@ a && a.empty?      }
       end)].reject(&:"empty?")
 .flatten
 .join(", ")
-"(#{contents})"
+      representation = "(#{contents})"
+      rp.map!() { |a|
+        RBS::Types::Function::Param.new(name:         visit_node(a)
+.to_sym, type:         RBS::Types::Bases::Any.new(location:         a.[](:"location")))
+      }
+      op.map!() { |a|
+        RBS::Types::Function::Param.new(name:         visit_node(a)
+.to_sym, type:         RBS::Types::Bases::Any.new(location:         a.[](:"location")))
+      }
+      rest_p = (if 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")))
+      else
+        nil
+      end)
+{:representation => representation,
+:types => {:required_positionals => rp,
+:optional_positionals => op,
+:rest_positionals => rest_p,
+:trailing_positionals => EMPTY_ARRAY,
+:required_keywords => node.[](:"req_kw_args") || EMPTY_HASH,
+:optional_keywords => node.[](:"opt_kw_args") || EMPTY_HASH,
+:rest_keywords =>       (if 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")))
+      else
+        nil
+      end)
+}.freeze}.freeze
     end
   end
 end

data/lib/gloss/cli.rb

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

data/lib/gloss/config.rb

@@ -3,12 +3,17 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  require "ostruct"
+require "ostruct"
 require "yaml"
 module Gloss
-  user_config = YAML.safe_load(File.read(".gloss.yml"))
+  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)

data/lib/gloss/initializer.rb

@@ -3,22 +3,22 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  require "yaml"
+require "yaml"
 module Gloss
   class Initializer
     def initialize(force)
       @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")
 .to_yaml)
       }
-      puts("Created .gloss.yml with default preferences")
+      puts("Created #{CONFIG_PATH} with default preferences")
     end
   end
 end

data/lib/gloss/version.rb

@@ -3,6 +3,6 @@
   ##### This file was generated by Gloss; any changes made here will be overwritten.
   ##### See src/ to make changes
 
-  module Gloss
-  VERSION = "0.0.4"
+module Gloss
+  VERSION = "0.0.5"
 end

data/lib/gloss/watcher.rb

@@ -6,24 +6,38 @@
   require "listen"
 module Gloss
   class Watcher
-    def initialize()
-      @paths = ["src/"]
+    def initialize(paths)
+      @paths = paths
+      (if @paths.empty?
+        @paths = [File.join(Dir.pwd, Config.src_dir)]
+      end)
     end
     def watch()
       puts("=====> Now listening for changes in #{@paths.join(", ")}")
       listener = Listen.to(*@paths, latency: 2) { |modified, added, removed|
         modified.+(added)
 .each() { |f|
+          unless           f.end_with?(".gl")
+            next
+          end
+          puts("====> Rewriting #{f}")
           content = File.read(f)
-          Writer.new(Builder.new(content)
+          Writer.new(Builder.new(Parser.new(content)
+.run)
 .run, f)
 .run
+          puts("====> Done")
         }
         removed.each() { |f|
+          unless           f.end_with?(".gl")
+            next
+          end
           out_path = Utils.src_path_to_output_path(f)
+          puts("====> Removing #{out_path}")
           (if File.exist?(out_path)
             File.delete(out_path)
           end)
+          puts("====> Done")
         }
       }
       listener.start

data/lib/gloss/writer.rb

@@ -9,7 +9,7 @@ module Gloss
   module Utils
     module_function
     def src_path_to_output_path(src_path)
-      src_path.sub(/\A(?:\.\/)?#{Config.src_dir}\/?/, "")
+      src_path.sub("#{Config.src_dir}/", "")
 .sub(/\.gl$/, ".rb")
     end
   end
@@ -25,7 +25,7 @@ module Gloss
         FileUtils.mkdir_p(@output_path.parent)
       end
       File.open(@output_path, "wb") { |file|
-        file.<<(@content)
+        file.puts(@content)
       }
     end
   end

data/src/lib/gloss/builder.gl

@@ -1,7 +1,21 @@
-# frozen_string_literal: true
-
 module Gloss
+  module Utils
+    module_function
+
+    def with_file_header(str)
+      "#{Builder::FILE_HEADER}\n\n#{str}"
+    end
+  end
+
   class Builder
+    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
+
+    include Utils
+
     attr_reader :tree
 
     def initialize(tree_hash, type_checker = nil)
@@ -15,13 +29,7 @@ module Gloss
 
     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
+      with_file_header(rb_output)
     end
 
     # type node = Hash[Symbol, String | Array[String | node] | Hash[Symbol, node]] | true | false
@@ -105,7 +113,7 @@ module Gloss
         src.write_ln "end"
       when "DefNode"
         args = render_args(node)
-        src.write_ln "def #{node[:name]}#{args}"
+        src.write_ln "def #{node[:name]}#{args[:representation]}"
 
         return_type = if node[:return_type]
                         RBS::Types::ClassInstance.new(
@@ -122,36 +130,17 @@ module Gloss
                         )
                       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] ?
@@ -216,8 +205,8 @@ module Gloss
         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]) }
 
@@ -466,6 +455,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 +489,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 +507,38 @@ module Gloss
         rest_p ? "*#{rest_p}" : "",
         rest_kw ? "**#{visit_node(rest_kw)}" : ""
       ].reject(&:empty?).flatten.join(", ")
-      "(#{contents})"
+      representation = "(#{contents})"
+      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
+      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_p = (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
+      {
+        representation: representation,
+        types: {
+          required_positionals: rp,
+          optional_positionals: op,
+          rest_positionals: rest_p,
+          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
+        }
+      }
     end
   end
 end

data/src/lib/gloss/cli.gl

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "optparse"
 
 module Gloss
@@ -12,30 +10,35 @@ module Gloss
       # TODO: allow destructuring: command, *files = @argv
       command = @argv.first
       files = @argv[1..-1]
-      case command
-      when "watch"
-        Watcher.new.watch
-      when "build"
-        (files.empty? ? Dir.glob("#{Config.src_dir}/**/*.gl") : 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).run
-          type_checker.run(rb_output)
+      err_msg = catch :error do
+        case command
+        when "watch"
+          Watcher.new(files).watch
+        when "build"
+          (files.empty? ? Dir.glob("#{Config.src_dir}/**/*.gl") : 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).run
+            type_checker.run(rb_output)
 
-          puts "=====> Writing #{fp}"
-          Writer.new(rb_output, fp).run
+            puts "=====> 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
-      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}"
+        nil
       end
+
+      abort err_msg if err_msg
     end
   end
 end

data/src/lib/gloss/config.gl

@@ -4,12 +4,18 @@ require "ostruct"
 require "yaml"
 
 module Gloss
-  user_config = YAML.safe_load(File.read(".gloss.yml"))
+  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/initializer.gl

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "yaml"
 
 module Gloss
@@ -8,15 +6,15 @@ module Gloss
     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") do |file|
+      File.open(CONFIG_PATH, "wb") do |file|
         file.puts Config.default_config.transform_keys(&:to_s).to_yaml
       end
 
-      puts "Created .gloss.yml with default preferences"
+      puts "Created #{CONFIG_PATH} with default preferences"
     end
   end
 end

data/src/lib/gloss/version.gl

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

data/src/lib/gloss/watcher.gl

@@ -4,20 +4,36 @@ require "listen"
 
 module Gloss
   class Watcher
-    def initialize
-      @paths = %w[src/]
+    def initialize(@paths : Array[String])
+      @paths = [File.join(Dir.pwd, Config.src_dir)] if @paths.empty?
     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|
+          next unless f.end_with? ".gl"
+
+          puts "====> Rewriting #{f}"
           content = File.read(f)
-          Writer.new(Builder.new(content).run, f).run
+          Writer.new(
+            Builder.new(
+              Parser.new(
+                content
+              ).run
+            ).run, f
+          ).run
+
+          puts "====> Done"
         end
         removed.each do |f|
+          next unless f.end_with? ".gl"
+
           out_path = Utils.src_path_to_output_path(f)
+          puts "====> Removing #{out_path}"
           File.delete out_path if File.exist? out_path
+
+          puts "====> Done"
         end
       end
       listener.start

data/src/lib/gloss/writer.gl

@@ -8,7 +8,7 @@ module Gloss
     module_function
 
     def src_path_to_output_path(src_path : String) : String
-      src_path.sub(%r{\A(?:\./)?#{Config.src_dir}/?}, "")
+      src_path.sub("#{Config.src_dir}/", "")
               .sub(/\.gl$/, ".rb")
     end
   end
@@ -26,7 +26,7 @@ module Gloss
     def run
       FileUtils.mkdir_p(@output_path.parent) unless @output_path.parent.exist?
       File.open(@output_path, "wb") do |file|
-        file << @content
+        file.puts @content
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gloss
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - johansenja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-30 00:00:00.000000000 Z
+date: 2021-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast_blank
@@ -135,6 +135,7 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".gloss.yml"
+- ".rspec"
 - ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
@@ -202,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: A superset of ruby