kapusta 0.1.5 → 0.2.1

data/lib/kapusta/compiler/runtime.rb

@@ -4,106 +4,11 @@ module Kapusta
   module Compiler
     module Runtime
       HELPER_DEPENDENCIES = {
-        stringify: %i[repr],
-        print_values: %i[stringify],
-        concat: %i[stringify],
-        method_path_value: %i[kebab_to_snake],
-        set_method_path: %i[kebab_to_snake],
-        get_ivar: %i[kebab_to_snake],
-        set_ivar: %i[kebab_to_snake],
-        get_cvar: %i[current_class_scope kebab_to_snake],
-        set_cvar: %i[current_class_scope kebab_to_snake],
-        get_gvar: %i[kebab_to_snake],
-        set_gvar: %i[kebab_to_snake],
         destructure: %i[destructure_into],
         match_pattern: %i[match_pattern_into]
       }.freeze
 
       HELPER_SOURCES = {
-        kebab_to_snake: <<~RUBY.chomp,
-          def kap_kebab_to_snake(name)
-            name.tr('-', '_')
-          end
-        RUBY
-        call: <<~'RUBY'.chomp,
-          def kap_call(callee, positional, kwargs = nil, block = nil)
-            raise "not callable: #{callee.inspect}" unless callee.respond_to?(:call)
-
-            if block
-              kwargs ? callee.call(*positional, **kwargs, &block) : callee.call(*positional, &block)
-            else
-              kwargs ? callee.call(*positional, **kwargs) : callee.call(*positional)
-            end
-          end
-        RUBY
-        send_call: <<~RUBY.chomp,
-          def kap_send_call(receiver, method_name, positional, kwargs = nil, block = nil)
-            if block
-              if kwargs
-                receiver.public_send(method_name, *positional, **kwargs, &block)
-              else
-                receiver.public_send(method_name, *positional, &block)
-              end
-            elsif kwargs
-              receiver.public_send(method_name, *positional, **kwargs)
-            else
-              receiver.public_send(method_name, *positional)
-            end
-          end
-        RUBY
-        invoke_self: <<~RUBY.chomp,
-          def kap_invoke_self(receiver, method_name, positional, kwargs = nil, block = nil)
-            if block
-              if kwargs
-                receiver.send(method_name, *positional, **kwargs, &block)
-              else
-                receiver.send(method_name, *positional, &block)
-              end
-            else
-              kwargs ? receiver.send(method_name, *positional, **kwargs) : receiver.send(method_name, *positional)
-            end
-          end
-        RUBY
-        stringify: <<~RUBY.chomp,
-          def kap_stringify(value)
-            case value
-            when nil then 'nil'
-            when Array, Hash then kap_repr(value)
-            else value.to_s
-            end
-          end
-        RUBY
-        repr: <<~'RUBY'.chomp,
-          def kap_repr(value)
-            case value
-            when nil then 'nil'
-            when true, false then value.to_s
-            when String, Symbol then value.inspect
-            when Array
-              "[#{value.map { |item| kap_repr(item) }.join(', ')}]"
-            when Hash
-              "{#{value.map { |key, item| "#{kap_repr(key)}=>#{kap_repr(item)}" }.join(', ')}}"
-            else
-              value.inspect
-            end
-          end
-        RUBY
-        print_values: <<~'RUBY'.chomp,
-          def kap_print_values(*values)
-            $stdout.puts(values.map { |value| kap_stringify(value) }.join("\t"))
-            nil
-          end
-        RUBY
-        concat: <<~RUBY.chomp,
-          def kap_concat(values)
-            values.map { |value| kap_stringify(value) }.join
-          end
-        RUBY
-        get_path: <<~RUBY.chomp,
-          def kap_get_path(obj, keys)
-            keys.reduce(obj) { |acc, key| acc[key] }
-          end
-        RUBY
         qget_path: <<~RUBY.chomp,
           def kap_qget_path(obj, keys)
             keys.each do |key|
@@ -114,63 +19,6 @@ module Kapusta
             obj
           end
         RUBY
-        set_path: <<~RUBY.chomp,
-          def kap_set_path(obj, keys, value)
-            target = obj
-            keys[0...-1].each { |key| target = target[key] }
-            target[keys.last] = value
-          end
-        RUBY
-        method_path_value: <<~RUBY.chomp,
-          def kap_method_path_value(base, segments)
-            segments.reduce(base) { |obj, segment| obj.public_send(kap_kebab_to_snake(segment).to_sym) }
-          end
-        RUBY
-        set_method_path: <<~'RUBY'.chomp,
-          def kap_set_method_path(base, segments, value)
-            target = base
-            segments[0...-1].each do |segment|
-              target = target.public_send(kap_kebab_to_snake(segment).to_sym)
-            end
-            setter = "#{kap_kebab_to_snake(segments.last)}="
-            target.public_send(setter.to_sym, value)
-          end
-        RUBY
-        current_class_scope: <<~RUBY.chomp,
-          def kap_current_class_scope(receiver)
-            receiver.is_a?(Module) ? receiver : receiver.class
-          end
-        RUBY
-        get_ivar: <<~'RUBY'.chomp,
-          def kap_get_ivar(receiver, name)
-            receiver.instance_variable_get("@#{kap_kebab_to_snake(name)}")
-          end
-        RUBY
-        set_ivar: <<~'RUBY'.chomp,
-          def kap_set_ivar(receiver, name, value)
-            receiver.instance_variable_set("@#{kap_kebab_to_snake(name)}", value)
-          end
-        RUBY
-        get_cvar: <<~'RUBY'.chomp,
-          def kap_get_cvar(receiver, name)
-            kap_current_class_scope(receiver).class_variable_get("@@#{kap_kebab_to_snake(name)}")
-          end
-        RUBY
-        set_cvar: <<~'RUBY'.chomp,
-          def kap_set_cvar(receiver, name, value)
-            kap_current_class_scope(receiver).class_variable_set("@@#{kap_kebab_to_snake(name)}", value)
-          end
-        RUBY
-        get_gvar: <<~'RUBY'.chomp,
-          def kap_get_gvar(name)
-            Kernel.eval("$#{kap_kebab_to_snake(name)}", binding, __FILE__, __LINE__)
-          end
-        RUBY
-        set_gvar: <<~'RUBY'.chomp,
-          def kap_set_gvar(name, value)
-            Kernel.eval("$#{kap_kebab_to_snake(name)} = value", binding, __FILE__, __LINE__)
-          end
-        RUBY
         ensure_module: <<~RUBY.chomp,
           def kap_ensure_module(holder, path)
             segments = path.split('.')

data/lib/kapusta/env.rb

@@ -10,12 +10,13 @@ module Kapusta
     end
 
     def define(name, value)
-      @vars[name] = value
+      @vars[binding_key(name)] = value
     end
 
     def lookup(name)
-      if @vars.key?(name)
-        @vars[name]
+      key = binding_key(name)
+      if @vars.key?(key)
+        @vars[key]
       elsif @parent
         @parent.lookup(name)
       else
@@ -23,8 +24,17 @@ module Kapusta
       end
     end
 
+    def lookup_if_defined(name)
+      key = binding_key(name)
+      if @vars.key?(key)
+        @vars[key]
+      else
+        @parent&.lookup_if_defined(name)
+      end
+    end
+
     def defined?(name)
-      @vars.key?(name) || @parent&.defined?(name)
+      @vars.key?(binding_key(name)) || @parent&.defined?(name)
     end
 
     def ruby_name_defined?(name)
@@ -36,8 +46,9 @@ module Kapusta
     end
 
     def set_existing!(name, value)
-      if @vars.key?(name)
-        @vars[name] = value
+      key = binding_key(name)
+      if @vars.key?(key)
+        @vars[key] = value
       elsif @parent
         @parent.set_existing!(name, value)
       else
@@ -51,6 +62,10 @@ module Kapusta
 
     private
 
+    def binding_key(name)
+      name.respond_to?(:binding_key) ? name.binding_key : name
+    end
+
     def binding_ruby_name(value)
       value.respond_to?(:ruby_name) ? value.ruby_name : value
     end

data/lib/kapusta/reader.rb

@@ -8,6 +8,7 @@ module Kapusta
 
     WHITESPACE = [' ', "\t", "\n", "\r", "\f", "\v", ','].freeze
     DELIMS = ['(', ')', '[', ']', '{', '}', '"', ';'].freeze
+    CLOSING_DELIMS = [')', ']', '}'].freeze
 
     def self.read_all(source, preserve_comments: false)
       new(source, preserve_comments:).read_all
@@ -85,6 +86,7 @@ module Kapusta
         when '{' then read_hash
         when '"' then read_string
         when '#' then read_hashfn
+        when *CLOSING_DELIMS then raise unexpected_closing_delim(peek)
         else
           read_atom
         end
@@ -93,11 +95,12 @@ module Kapusta
     end
 
     def read_list
+      opening_position = source_position
       advance
       items = []
       loop do
         skip_ws
-        raise Error, 'unclosed (' if eof?
+        raise unclosed_opening_delim('(', opening_position) if eof?
         break if peek == ')'
 
         items << read_next_item
@@ -107,11 +110,12 @@ module Kapusta
     end
 
     def read_vec
+      opening_position = source_position
       advance
       items = []
       loop do
         skip_ws
-        raise Error, 'unclosed [' if eof?
+        raise unclosed_opening_delim('[', opening_position) if eof?
         break if peek == ']'
 
         items << read_next_item
@@ -121,12 +125,13 @@ module Kapusta
     end
 
     def read_hash
+      opening_position = source_position
       advance
       entries = []
       pending = []
       loop do
         skip_ws
-        raise Error, 'unclosed {' if eof?
+        raise unclosed_opening_delim('{', opening_position) if eof?
         break if peek == '}'
 
         item = read_next_item
@@ -218,6 +223,25 @@ module Kapusta
       parse_atom(token)
     end
 
+    def unexpected_closing_delim(char)
+      line, column = source_position
+      Error.new("unexpected closing delimiter '#{char}' at line #{line}, column #{column}")
+    end
+
+    def unclosed_opening_delim(char, position)
+      line, column = position
+      Error.new("unclosed opening delimiter '#{char}' at line #{line}, column #{column}")
+    end
+
+    def source_position
+      prefix = @src[0...@pos]
+      line = prefix.count("\n") + 1
+      last_newline = prefix.rindex("\n")
+      column = last_newline ? prefix.length - last_newline : prefix.length + 1
+
+      [line, column]
+    end
+
     def parse_atom(token)
       return true if token == 'true'
       return false if token == 'false'

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.1.5'
+  VERSION = '0.2.1'
 end

data/lib/kapusta.rb

@@ -9,6 +9,8 @@ require_relative 'kapusta/env'
 require_relative 'kapusta/compiler'
 
 module Kapusta
+  @loaded_kapusta_features = {}
+
   def self.eval(source, path: '(eval)', **_opts)
     Compiler.run(source, path:)
   end
@@ -22,10 +24,69 @@ module Kapusta
     Compiler.compile(source, path:)
   end
 
+  def self.require(feature, relative_to: nil)
+    feature = feature.to_s
+    local_path = resolve_require_path(feature, relative_to:)
+
+    return require_kapusta_file(local_path) if local_path&.end_with?('.kap')
+    return Kernel.require(local_path) if local_path
+
+    Kernel.require(feature)
+  end
+
   def self.install!
     @install ||= begin
-      require 'rubygems'
+      Kernel.require 'rubygems'
       true
     end
   end
+
+  def self.resolve_require_path(feature, relative_to:)
+    return unless local_feature?(feature)
+
+    path =
+      if File.absolute_path?(feature)
+        feature
+      else
+        File.expand_path(feature, require_base_dir(relative_to))
+      end
+    existing_feature_path(path)
+  end
+
+  def self.local_feature?(feature)
+    feature.start_with?('./', '../') || File.absolute_path?(feature)
+  end
+
+  def self.require_base_dir(relative_to)
+    return Dir.pwd if relative_to.nil? || relative_to.start_with?('(')
+
+    File.dirname(File.expand_path(relative_to))
+  end
+
+  def self.existing_feature_path(path)
+    candidates =
+      if File.extname(path).empty?
+        [path, "#{path}.kap", "#{path}.rb"]
+      else
+        [path]
+      end
+
+    candidates.find { |candidate| File.file?(candidate) }
+  end
+
+  def self.require_kapusta_file(path)
+    expanded = File.realpath(path)
+    return false if @loaded_kapusta_features[expanded]
+
+    @loaded_kapusta_features[expanded] = true
+    dofile(expanded)
+    $LOADED_FEATURES << expanded unless $LOADED_FEATURES.include?(expanded)
+    true
+  rescue StandardError, ScriptError
+    @loaded_kapusta_features.delete(expanded) if expanded
+    raise
+  end
+
+  private_class_method :resolve_require_path, :local_feature?, :require_base_dir,
+                       :existing_feature_path, :require_kapusta_file
 end

data/spec/cli_spec.rb

@@ -39,7 +39,28 @@ RSpec.describe Kapusta::CLI do
 
       stdout, stderr, status = Open3.capture3(RbConfig.ruby, output_path)
 
-      expected = "1\n2\nFizz\n4\nBuzz\nFizz\n7\n8\nFizz\nBuzz\n11\nFizz\n13\n14\nFizzBuzz\n16\n17\nFizz\n19\nBuzz\n"
+      expected = <<~OUT
+        1
+        2
+        "Fizz"
+        4
+        "Buzz"
+        "Fizz"
+        7
+        8
+        "Fizz"
+        "Buzz"
+        11
+        "Fizz"
+        13
+        14
+        "FizzBuzz"
+        16
+        17
+        "Fizz"
+        19
+        "Buzz"
+      OUT
       expect(status.success?).to eq(true), stderr
       expect(stdout).to eq(expected)
     end
@@ -63,7 +84,9 @@ RSpec.describe Kapusta::CLI do
       described_class.start([path, 'Ada'])
     end
 
-    expect(output).to eq("Hello, Ada!\n")
+    expect(output).to eq(<<~OUT)
+      "Hello, Ada!"
+    OUT
   end
 
   it 'prints the version with -v' do