gloss 0.0.1 → 0.0.6

data/ext/gloss/lib/rbs_types.cr

@@ -0,0 +1,3 @@
+module Gloss
+  class Any; end
+end

data/ext/gloss/spec/parser_spec.cr

@@ -0,0 +1,124 @@
+require "./spec_helper"
+
+module Gloss
+  describe Parser do
+    it "allows single quoted strings" do
+      Gloss.parse_string("puts 'hello world'").should be_truthy
+    end
+
+    it "doesn't require 'of' after empty arrays" do
+      Gloss.parse_string("arr = []").should eq(
+        %q|{"type":"Assign","op":null,"target":{"type":"Var","name":"arr"},"value":{"type":"ArrayLiteral","elements":[],"frozen":false}}|
+      )
+    end
+
+    it "doesn't require 'of' after empty hashes" do
+      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 rescue with ruby syntax" do
+      Gloss.parse_string(<<-GLOSS).should be_truthy
+        begin
+          raise "Abc"
+        rescue RuntimeError => e
+          p e.message
+        rescue NoMethodError
+        rescue => e
+        end
+      GLOSS
+    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 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 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 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/spec/spec_helper.cr

@@ -0,0 +1,2 @@
+require "spec"
+require "../src/parser"

data/ext/gloss/src/cr_ast.cr

@@ -1,5 +1,6 @@
 require "compiler/crystal/syntax/*"
 require "json"
+require "./rb_ast"
 
 module Crystal
   abstract class ASTNode
@@ -61,7 +62,7 @@ module Crystal
 
   class SymbolLiteral < ASTNode
     def to_rb
-      Rb::AST::LiteralNode.new(":#{@value.to_s}", Rb::AST::RbLiteral::Symbol)
+      Rb::AST::LiteralNode.new(%{:"#{@value.to_s}"}, Rb::AST::RbLiteral::Symbol)
     end
   end
 
@@ -73,13 +74,13 @@ module Crystal
 
   class HashLiteral < ASTNode
     def to_rb
-      Rb::AST::HashLiteral.new(@entries.map { |e| { e.key.to_rb, e.value.to_rb }})
+      Rb::AST::HashLiteral.new(@entries.map { |e| {e.key.to_rb, e.value.to_rb} })
     end
   end
 
   class NamedTupleLiteral < ASTNode
     def to_rb
-      Rb::AST::HashLiteral.new(@entries.map { |e| { e.key, e.value.to_rb }}, frozen: true)
+      Rb::AST::HashLiteral.new(@entries.map { |e| {e.key, e.value.to_rb} }, frozen: true)
     end
   end
 
@@ -91,7 +92,7 @@ module Crystal
 
   class RegexLiteral < ASTNode
     def to_rb
-      Rb::AST::RegexLiteral.new("//")
+      Rb::AST::RegexLiteral.new(@value.to_rb)
     end
   end
 
@@ -103,8 +104,19 @@ module Crystal
 
   class Def < ASTNode
     def to_rb
-      Rb::AST::DefNode.new(@name, @args.map(&.to_rb), @body.to_rb, receiver.try(&.to_rb),
-                           return_type.try(&.to_rb), @double_splat.try(&.to_rb))
+      positional_args = args.dup
+      splat = @splat_index ? positional_args.delete_at(@splat_index.as(Int32)) : nil
+      Rb::AST::DefNode.new(
+        receiver.try(&.to_rb),
+        @name,
+        positional_args.map(&.to_rb),
+        splat.try(&.to_rb),
+        @double_splat.try(&.to_rb),
+        @body.to_rb,
+        return_type.try(&.to_rb),
+        @yields,
+        @block_arg.try &.to_rb
+      )
     end
   end
 
@@ -128,28 +140,38 @@ 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
 
   class Call < ASTNode
     def to_rb
-      Rb::AST::Call.new(@obj.try(&.to_rb), @name, @args.map(&.to_rb), @block.try(&.to_rb),
-                        @block_arg.try(&.to_rb))
+      Rb::AST::Call.new(
+        @obj.try(&.to_rb),
+        @name,
+        @args.map(&.to_rb),
+        @named_args.try(&.map(&.to_rb.as(Rb::AST::Arg))),
+        @block.try(&.to_rb),
+        @block_arg.try(&.to_rb),
+        @has_parentheses
+      )
     end
   end
 
-  class NamedArgument < ASTNode
+  class Arg < ASTNode
+    property keyword_arg : Bool = false
+
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::Arg.new(@name, @external_name, @restriction.try(&.to_rb),
+        @default_value.try(&.to_rb), @keyword_arg)
     end
   end
 
-  class Arg < ASTNode
-    property keyword_arg : Bool = false
-
+  class NamedArgument < ASTNode
     def to_rb
-      Rb::AST::Arg.new(@name, @external_name, @restriction.try(&.to_rb), @default_value.try(&.to_rb))
+      Rb::AST::Arg.new(@name, @name, nil, @value.to_rb, true)
     end
   end
 
@@ -159,6 +181,12 @@ module Crystal
     end
   end
 
+  class Unless < ASTNode
+    def to_rb
+      Rb::AST::Unless.new(@cond.to_rb, @then.to_rb, @else.to_rb)
+    end
+  end
+
   class Assign < ASTNode
     def to_rb
       Rb::AST::Assign.new(@target.to_rb, @value.to_rb)
@@ -173,7 +201,7 @@ module Crystal
 
   class MultiAssign < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::MultiAssign.new(@targets.map(&.to_rb), @values.map(&.to_rb))
     end
   end
 
@@ -197,7 +225,7 @@ module Crystal
 
   class Global < ASTNode
     def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
+      Rb::AST::GlobalVar.new(@name)
     end
   end
 
@@ -207,12 +235,6 @@ module Crystal
     end
   end
 
-  class MacroExpression < ASTNode
-    def to_rb
-      Rb::AST::EmptyNode.new(self.class.name)
-    end
-  end
-
   class MacroIf < ASTNode
     def to_rb
       Rb::AST::MacroIf.new(@cond.to_rb, @then.to_rb, @else.to_rb)
@@ -293,7 +315,20 @@ module Crystal
   class When < ASTNode
     def to_rb
       Rb::AST::When.new(
-        @conds.map(&.to_rb),
+        @conds.map do |c|
+          if c.is_a? Call
+            arg_name = "x"
+            ProcLiteral.new(
+              Def.new(
+                "->",
+                [Arg.new(arg_name)],
+                c.tap { |call| call.obj = Var.new(arg_name) }
+              )
+            ).to_rb
+          else
+            c.to_rb
+          end
+        end,
         @body.to_rb,
         @exhaustive
       )
@@ -349,7 +384,7 @@ module Crystal
   class ExceptionHandler < ASTNode
     def to_rb
       Rb::AST::ExceptionHandler.new(@body.to_rb, @rescues.try(&.map(&.to_rb)), @else.try(&.to_rb),
-                                    @ensure.try(&.to_rb))
+        @ensure.try(&.to_rb))
     end
   end
 
@@ -359,11 +394,74 @@ module Crystal
     end
   end
 
-  {% for class_name in %w[ProcNotation Macro OffsetOf VisibilityModifier IsA RespondsTo
-                         Select ImplicitObj AnnotationDef While Until Generic UninitializedVar
-                         ProcLiteral ProcPointer Union Self Yield Include
-                         Extend LibDef FunDef TypeDef CStructOrUnionDef ExternalVar Alias
-                         Metaclass Cast NilableCast TypeOf Annotation
+  class Union < ASTNode
+    def to_rb
+      Rb::AST::Union.new(@types.map(&.to_rb))
+    end
+  end
+
+  class Generic < ASTNode
+    def to_rb
+      Rb::AST::Generic.new(@name.to_rb, @type_vars.map(&.to_rb))
+    end
+  end
+
+  class ProcLiteral < ASTNode
+    def to_rb
+      Rb::AST::Proc.new(@def.to_rb)
+    end
+  end
+
+  class Include < ASTNode
+    def to_rb
+      Rb::AST::Include.new(@name.to_rb)
+    end
+  end
+
+  class Extend < ASTNode
+    def to_rb
+      Rb::AST::Extend.new(@name.to_rb)
+    end
+  end
+
+  class IsA < ASTNode
+    def to_rb
+      Rb::AST::Call.new(
+        @obj.to_rb,
+        "is_a?",
+        [@const.to_rb],
+        nil,
+        nil,
+        nil,
+        false
+      )
+    end
+  end
+
+  class VisibilityModifier < ASTNode
+    def to_rb
+      Rb::AST::VisibilityModifier.new(@modifier, @exp.to_rb)
+    end
+  end
+
+  class Yield < ASTNode
+    def to_rb
+      Rb::AST::Call.new(
+        nil,
+        "yield",
+        @exps.map(&.to_rb),
+        nil,
+        nil,
+        nil,
+        !@exps.empty?
+      )
+    end
+  end
+
+  {% for class_name in %w[ProcNotation Macro OffsetOf RespondsTo
+                         Select ImplicitObj AnnotationDef While Until UninitializedVar
+                         ProcPointer Self LibDef FunDef TypeDef CStructOrUnionDef
+                         ExternalVar Alias Metaclass Cast NilableCast TypeOf Annotation
                          Underscore MagicConstant Asm AsmOperand] %}
     class {{class_name.id}} < ASTNode
       def to_rb
@@ -372,7 +470,7 @@ module Crystal
     end
   {% end %}
 
-  {% for class_name in %w[PointerOf SizeOf InstanceSizeOf Out MacroVerbatim DoubleSplat] %}
+  {% for class_name in %w[PointerOf SizeOf InstanceSizeOf Out MacroVerbatim] %}
     class {{class_name.id}} < UnaryExpression
       def to_rb
         Rb::AST::EmptyNode.new(self.class.name)

data/ext/gloss/src/gloss.cr

@@ -1,31 +1,25 @@
-require "./lib/cr_ruby"
+require "../lib/cr_ruby"
+require "../lib/rbs_types"
 require "./cr_ast"
 require "./rb_ast"
 require "./parser"
 
-def parse_buffer(self : CrRuby::VALUE, buffer : CrRuby::VALUE)
-  plain_buffer = CrRuby.rb_str_to_str(buffer)
-  c_buffer = CrRuby.rb_string_value_cstr(pointerof(plain_buffer))
-  crystal_buffer = String.new(c_buffer)
+def parse_string(self : CrRuby::VALUE, str : CrRuby::VALUE)
+  st = CrRuby.rb_str_to_str(str)
+  string = String.new(CrRuby.rb_string_value_cstr(pointerof(st)))
 
-  output = parse_buffer(crystal_buffer)
+  output = begin
+             Gloss.parse_string(string)
+           rescue e : Crystal::SyntaxException
+             e.to_s
+           end
 
   CrRuby.rb_str_new_cstr(output)
 end
 
-def parse_buffer(buffer : String)
-  begin
-    tree = Gloss::Parser.parse buffer
-    tree.to_rb.to_json
-  rescue e : Crystal::SyntaxException
-    pp e.backtrace
-    e.to_s
-  end
-end
-
-fun init = Init_gloss
+fun init = Init_gls
   GC.init
   LibCrystalMain.__crystal_main(0, Pointer(Pointer(UInt8)).null)
   gloss = CrRuby.rb_define_module("Gloss");
-  CrRuby.rb_define_singleton_method(gloss, "parse_buffer", ->parse_buffer(CrRuby::VALUE, CrRuby::VALUE), 1);
+  CrRuby.rb_define_singleton_method(gloss, "parse_buffer", ->parse_string(CrRuby::VALUE, CrRuby::VALUE), 1);
 end