gloss 0.0.3 → 0.1.1

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

data/src/lib/gloss/writer.gl

@@ -4,29 +4,31 @@ require "pathname"
 require "fileutils"
 
 module Gloss
-  module Utils
-    module_function
-
-    def src_path_to_output_path(src_path)
-      src_path.sub(%r{\A(?:\./)?#{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))
+      @src_path : String,
+      @output_path : Pathname? = Pathname.new(
+        Utils.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 << @content
+        sb = shebang
+        file.puts sb if sb
+        file.puts @content
+      end
+    end
+
+    private def shebang
+      if @output_path.executable?
+        first_line = File.open(@src_path) { |f| f.readline }
+        first_line.start_with?("#!") ? first_line : nil
+      else
+        nil
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gloss
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.1
 platform: ruby
 authors:
 - johansenja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-20 00:00:00.000000000 Z
+date: 2021-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast_blank
@@ -131,10 +131,12 @@ extensions:
 - ext/gloss/extconf.rb
 extra_rdoc_files: []
 files:
-- ".github/workflows/crystal.yml"
-- ".github/workflows/ruby.yml"
+- ".gitattributes"
+- ".github/workflows/crystal_specs.yml"
+- ".github/workflows/ruby_specs.yml"
 - ".gitignore"
 - ".gloss.yml"
+- ".rspec"
 - ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
@@ -145,37 +147,55 @@ files:
 - 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.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/prog_loader.rb
 - lib/gloss/scope.rb
 - lib/gloss/source.rb
 - lib/gloss/type_checker.rb
+- lib/gloss/utils.rb
 - lib/gloss/version.rb
+- lib/gloss/visitor.rb
 - lib/gloss/watcher.rb
 - lib/gloss/writer.rb
-- sig/gloss.rbs
+- sig/core.rbs
+- sig/fast_blank.rbs
+- sig/gls.rbs
 - sig/listen.rbs
+- sig/optparse.rbs
+- sig/rubygems.rbs
+- sig/yaml.rbs
+- src/exe/gloss
+- src/lib/gloss.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/prog_loader.gl
+- src/lib/gloss/scope.gl
+- src/lib/gloss/source.gl
 - src/lib/gloss/type_checker.gl
+- src/lib/gloss/utils.gl
 - src/lib/gloss/version.gl
+- src/lib/gloss/visitor.gl
 - src/lib/gloss/watcher.gl
 - src/lib/gloss/writer.gl
 homepage:
@@ -197,7 +217,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

data/lib/gloss/builder.rb

@@ -1,447 +0,0 @@
-# frozen_string_literal: true
-
-module Gloss
-  class Builder
-    attr_reader :tree
-
-    def initialize(tree_hash, type_checker = nil)
-      @indent_level = 0
-      @inside_macro = false
-      @eval_vars = false
-      @current_scope = nil
-      @tree = tree_hash
-      @type_checker = type_checker
-    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
-    end
-
-    def visit_node(node, scope = Scope.new)
-      src = Source.new(@indent_level)
-      case node[:type]
-      when "ClassNode"
-        class_name = visit_node(node[:name])
-        current_namespace = @current_scope ? @current_scope.name.to_namespace : RBS::Namespace.root
-        superclass_type = nil
-        superclass_output = nil
-        if node[:superclass]
-          @eval_vars = true
-          superclass_output = visit_node(node[:superclass])
-          @eval_vars = false
-          ns = if superclass_output.start_with? '::'
-                 RBS::Namespace.root
-               elsif superclass_output.include? '::'
-                 current_namespace
-               else
-                 RBS::Namespace.empty
-               end
-          superclass_type = RBS::AST::Declarations::Class::Super.new(
-            name: RBS::TypeName.new(
-              name: superclass_output.to_sym,
-              namespace: ns
-            ),
-            args: [],
-            location: nil
-          )
-        end
-
-        src.write_ln "class #{class_name}#{" < #{superclass_output}" if superclass_output}"
-
-        class_type = RBS::AST::Declarations::Class.new(
-          name: RBS::TypeName.new(
-            namespace: current_namespace,
-            name: class_name.to_sym
-          ),
-          type_params: RBS::AST::Declarations::ModuleTypeParams.new, # responds to #add to add params
-          super_class: superclass_type,
-          members: [],
-          annotations: [],
-          location: node[:location],
-          comment: node[:comment]
-        )
-        old_parent_scope = @current_scope
-        @current_scope = class_type
-
-        indented(src) { src.write_ln visit_node(node[:body]) if node[:body] }
-
-        src.write_ln "end"
-
-        @current_scope = old_parent_scope
-
-        @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
-        end
-      when "ModuleNode"
-        module_name = visit_node node[:name]
-        src.write_ln "module #{module_name}"
-
-        current_namespace = @current_scope ? @current_scope.name.to_namespace : RBS::Namespace.root
-
-        module_type = RBS::AST::Declarations::Module.new(
-          name: RBS::TypeName.new(
-            namespace: current_namespace,
-            name: module_name.to_sym
-          ),
-          type_params: RBS::AST::Declarations::ModuleTypeParams.new, # responds to #add to add params
-          self_types: [],
-          members: [],
-          annotations: [],
-          location: node[:location],
-          comment: node[:comment]
-        )
-        old_parent_scope = @current_scope
-        @current_scope = module_type
-
-        indented(src) { src.write_ln visit_node(node[:body]) if node[:body] }
-
-        @current_scope = old_parent_scope
-
-        @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
-        end
-        src.write_ln "end"
-      when "DefNode"
-        args = render_args(node)
-        src.write_ln "def #{node[:name]}#{args}"
-
-        return_type = if node[:return_type]
-                        RBS::Types::ClassInstance.new(
-                          name: RBS::TypeName.new(
-                            name: eval(visit_node(node[:return_type])).to_s.to_sym,
-                            namespace: RBS::Namespace.root
-                          ),
-                          args: [],
-                          location: nil
-                        )
-                      else
-                        RBS::Types::Bases::Any.new(location: nil)
-                      end
-
-        method_types = [
-          RBS::MethodType.new(
-            type_params: [],
-            type: RBS::Types::Function.new(
-              required_positionals: node[:rp_args]&.map do |a|
-                RBS::Types::Function::Param.new(
-                  name: visit_node(a).to_sym,
-                  type: RBS::Types::Bases::Any.new(location: nil)
-                )
-              end || EMPTY_ARRAY,
-              optional_positionals: node[:op_args] || EMPTY_ARRAY,
-              rest_positionals: node[:rest_p_args],
-              trailing_positionals: [],
-              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: nil)
-                ) : nil,
-              return_type: return_type
-            ),
-            block: nil,
-            location: nil
-          )
-        ]
-        method_definition = RBS::AST::Members::MethodDefinition.new(
-          name: node[:name].to_sym,
-          kind: :instance,
-          types: method_types,
-          annotations: [],
-          location: node[:location],
-          comment: node[:comment],
-          overload: false
-        )
-
-        if @current_scope
-          @current_scope.members << method_definition
-        else
-          @type_checker.type_env << method_definition if @type_checker # should be new class declaration for Object with method_definition as private method
-        end
-
-        indented(src) { src.write_ln visit_node(node[:body]) if node[:body] }
-
-        src.write_ln "end"
-      when "CollectionNode"
-        src.write(*node[:children].map { |a| visit_node(a, scope) })
-      when "Call"
-        obj = node[:object] ? "#{visit_node(node[:object], scope)}." : ""
-        args = node[:args] || EMPTY_ARRAY
-        args += node[:named_args] if node[:named_args]
-        args = if !args.empty? || node[:block_arg]
-                 "(#{args.map { |a| visit_node(a, scope).strip }.reject(&:blank?).join(", ")}#{"&#{visit_node(node[:block_arg]).strip}" if node[:block_arg]})"
-               else
-                 nil
-               end
-        block = node[:block] ? " #{visit_node(node[:block])}" : nil
-        src.write_ln "#{obj}#{node[:name]}#{args}#{block}"
-
-      when "Block"
-
-        src.write "{ |#{node[:args].map { |a| visit_node a }.join(", ")}|\n"
-
-        indented(src) { src.write visit_node(node[:body]) }
-
-        src.write_ln "}"
-
-      when "RangeLiteral"
-        dots = node[:exclusive] ? "..." : ".."
-
-        # parentheses 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]), ")"
-
-      when "LiteralNode"
-
-        src.write node[:value]
-
-      when "ArrayLiteral"
-
-        src.write("[", *node[:elements].map { |e| visit_node e }.join(", "), "]")
-        src.write ".freeze" if node[:frozen]
-
-      when "StringInterpolation"
-
-        contents = node[:contents].inject(String.new) do |str, c|
-          str << case c[:type]
-                 when "LiteralNode"
-                   c[:value][1...-1]
-                 else
-                   "\#{#{visit_node(c).strip}}"
-                 end
-        end
-        src.write '"', contents, '"'
-
-      when "Path"
-
-        src.write node[:value]
-
-      when "Require"
-
-        src.write_ln %(require "#{node[:value]}")
-
-      when "Assign", "OpAssign"
-
-        src.write_ln "#{visit_node(node[:target])} #{node[:op]}= #{visit_node(node[:value]).strip}"
-
-      when "Var"
-
-        if @eval_vars
-          src.write scope[node[:name]]
-        else
-          src.write node[:name]
-        end
-
-      when "InstanceVar"
-
-        src.write node[:name]
-
-      when "GlobalVar"
-
-        src.write node[:name]
-
-      when "Arg"
-        val = node[:external_name]
-        if node[:keyword_arg]
-          val += ":"
-          val += " #{visit_node(node[:value])}" if node[:value]
-        elsif node[:value]
-          val += " = #{visit_node(node[:value])}"
-        end
-
-        src.write val
-
-      when "UnaryExpr"
-
-        src.write "#{node[:op]}#{visit_node(node[:value]).strip}"
-
-      when "BinaryOp"
-
-        src.write visit_node(node[:left]).strip, " #{node[:op]} ", visit_node(node[:right]).strip
-
-      when "HashLiteral"
-
-        contents = node[:elements].map do |k, v|
-          key = case k
-                when String
-                  k.to_sym
-                else
-                  visit_node k
-                end
-          value = visit_node v
-          "#{key.inspect} => #{value}"
-        end
-
-        src.write "{#{contents.join(",\n")}}"
-        src.write ".freeze" if node[:frozen]
-
-      when "Enum"
-        src.write_ln "module #{node[:name]}"
-        node[:members].each_with_index do |m, i|
-          indented(src) { src.write_ln(visit_node(m) + (!m[:value] ? " = #{i}" : "")) }
-        end
-        src.write_ln "end"
-      when "If"
-        src.write_ln "(if #{visit_node(node[:condition]).strip}"
-
-        indented(src) { src.write_ln visit_node(node[:then]) }
-
-        if node[:else]
-          src.write_ln "else"
-          indented(src) { src.write_ln visit_node(node[:else]) }
-        end
-
-        src.write_ln "end)"
-      when "Unless"
-        src.write_ln "unless #{visit_node node[:condition]}"
-        indented(src) { src.write_ln visit_node(node[:then]) }
-
-        if node[:else]
-          src.write_ln "else"
-          indented(src) { src.write_ln visit_node(node[:else]) }
-        end
-
-        src.write_ln "end"
-      when "Case"
-        src.write "case"
-        src.write " #{visit_node(node[:condition]).strip}\n" if node[:condition]
-        indented(src) do
-          node[:whens].each do |w|
-            src.write_ln visit_node(w)
-          end
-        end
-        src.write_ln "end"
-      when "When"
-        src.write_ln "when #{node[:conditions].map { |n| visit_node(n) }.join(", ")}"
-
-        indented(src) { src.write_ln visit_node(node[:body]) }
-      when "MacroFor"
-        vars, expr, body = node[:vars], node[:expr], node[:body]
-        var_names = vars.map { |v| visit_node v }
-        @inside_macro = true
-        indent_level = @indent_level
-        @indent_level -= 1 unless indent_level.zero?
-        expanded = eval(visit_node(expr)).map do |*a|
-          locals = Hash[[var_names.join(%(", "))].zip(a)]
-          locals.merge!(scope) if @inside_macro
-          visit_node(body, locals)
-        end.flatten
-        @indent_level += 1 unless indent_level.zero?
-        src.write(*expanded)
-        @inside_macro = false
-      when "MacroLiteral"
-        src.write node[:value]
-      when "MacroExpression"
-        if node[:output]
-          expr = visit_node node[:expr], scope
-          val = scope[expr]
-          src.write val
-        end
-      when "MacroIf"
-        if evaluate_macro_condition(node[:condition], scope)
-          src.write_ln visit_node(node[:then], scope) if node[:then]
-        else
-          src.write_ln visit_node(node[:else], scope) if node[:else]
-        end
-      when "Return"
-        val = node[:value] ? " #{visit_node(node[:value]).strip}" : nil
-        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])}"
-      when "ExceptionHandler"
-        src.write_ln "begin"
-        indented src do
-          src.write_ln visit_node(node[:body])
-        end
-          node[:rescues]&.each do |r|
-            src.write_ln "rescue #{r[:types].map { |n| visit_node n }.join(", ") if r[:types]}#{" => #{r[:name]}" if r[:name]}"
-            indented(src) { src.write_ln visit_node(r[:body]) } if r[:body]
-          end
-          if node[:else]
-            src.write_ln "else"
-            indented(src) { src.write_ln visit_node(node[:else]) }
-          end
-          if node[:ensure]
-            src.write_ln "ensure"
-            intended(src) { src.write_ln visit_node(node[:ensure]) }
-          end
-        src.write_ln "end"
-      when "Generic"
-        src.write "#{node[:name]}[#{node[:args].map { |a| visit_node a }.join(", ")}]"
-      when "Proc"
-        fn = node[:function]
-        src.write "->#{render_args(fn)} { #{visit_node fn[:body]} }"
-      when "Include"
-        src.write_ln "include #{visit_node node[:name]}"
-      when "Extend"
-        src.write_ln "extend #{visit_node node[:name]}"
-      when "RegexLiteral"
-        contents = visit_node node[:value]
-        src.write Regexp.new(contents.undump).inspect
-      when "EmptyNode"
-        # pass
-      else
-        raise "Not implemented: #{node[:type]}"
-      end
-
-      src
-    end
-
-    private
-
-    def evaluate_macro_condition(condition_node, scope)
-      @eval_vars = true
-      eval(visit_node(condition_node, scope))
-      @eval_vars = false
-    end
-
-    def indented(src)
-      increment_indent(src)
-      yield
-      decrement_indent(src)
-    end
-
-    def increment_indent(src)
-      @indent_level += 1
-      src.increment_indent
-    end
-
-    def decrement_indent(src)
-      @indent_level -= 1
-      src.decrement_indent
-    end
-
-    def render_args(node)
-      rp = node[:rp_args] || EMPTY_ARRAY
-      op = node[:op_args] || EMPTY_ARRAY
-      rkw = node[:req_kw_args] || EMPTY_HASH
-      okw = node[:opt_kw_args] || EMPTY_HASH
-      rest_p = node[:rest_p_args]
-      rest_kw = node[:rest_kw_args]
-      return nil unless [rp, op, rkw, okw, rest_p, rest_kw].any? { |a| !a.nil? || !a.empty? }
-
-      contents = [
-        rp.map { |a| visit_node(a) },
-        op.map { |pos| "#{pos.name} = #{value}" },
-        rkw.map { |name, _| "#{name}:" },
-        okw.map { |name, _| "#{name}: #{value}" },
-        rest_p ? "*#{rest_p}" : "",
-        rest_kw ? "**#{visit_node(rest_kw)}" : ""
-      ].reject(&:empty?).flatten.join(", ")
-      "(#{contents})"
-    end
-  end
-end