kapusta 0.1.4 → 0.2.0

data/lib/kapusta/compiler/runtime.rb

@@ -4,175 +4,21 @@ module Kapusta
   module Compiler
     module Runtime
       HELPER_DEPENDENCIES = {
-        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)
-            render = nil
-            render = lambda do |item|
-              case item
-              when nil then 'nil'
-              when true then 'true'
-              when false then 'false'
-              when String, Symbol then item.inspect
-              when Array
-                "[#{item.map { |child| render.call(child) }.join(', ')}]"
-              when Hash
-                "{#{item.map { |key, child| "#{render.call(key)}=>#{render.call(child)}" }.join(', ')}}"
-              else
-                item.inspect
-              end
-            end
-
-            case value
-            when nil then 'nil'
-            when true then 'true'
-            when false then 'false'
-            when Array, Hash then render.call(value)
-            else value.to_s
-            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|
-              return nil if obj.nil?
+              return if obj.nil?
 
               obj = obj[key]
             end
             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('.')
@@ -367,10 +213,13 @@ module Kapusta
 
       HELPER_SOURCES.each_key do |name|
         helper_method = :"kap_#{name}"
-        define_singleton_method(name, instance_method(helper_method))
+        body = instance_method(helper_method)
+        define_singleton_method(helper_method, body)
+        define_singleton_method(name, body)
         helper_methods << helper_method
       end
 
+      private_class_method(*helper_methods)
       send(:private, *helper_methods)
     end
   end

data/lib/kapusta/env.rb

@@ -2,18 +2,21 @@
 
 module Kapusta
   class Env
+    MethodBinding = Struct.new(:ruby_name)
+
     def initialize(parent = nil)
       @parent = parent
       @vars = {}
     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
@@ -21,21 +24,31 @@ 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)
-      @vars.value?(name) || @parent&.ruby_name_defined?(name)
+      @vars.any? { |_source_name, value| binding_ruby_name(value) == name } || @parent&.ruby_name_defined?(name)
     end
 
     def local_ruby_name_defined?(name)
-      @vars.value?(name)
+      @vars.any? { |_source_name, value| binding_ruby_name(value) == name }
     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
@@ -46,5 +59,15 @@ module Kapusta
     def child
       Env.new(self)
     end
+
+    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
   end
 end

data/lib/kapusta/formatter.rb

@@ -177,15 +177,15 @@ module Kapusta
       when Sym
         form.name
       when Vec
-        return nil if contains_comments?(form.items)
+        return if contains_comments?(form.items)
 
         "[#{form.items.map { |item| flat_render(item) }.join(' ')}]"
       when HashLit
-        return nil if contains_comments?(form.entries)
+        return if contains_comments?(form.entries)
 
         "{#{form.pairs.map { |key, value| flat_hash_pair(key, value) }.join(' ')}}"
       when List
-        return nil if contains_comments?(form.items)
+        return if contains_comments?(form.items)
         return "##{flat_render(semantic_items(form.items)[1])}" if hashfn_literal?(form)
 
         "(#{form.items.map { |item| flat_render(item) }.join(' ')})"
@@ -548,13 +548,12 @@ module Kapusta
 
     def render_hanging_pairwise_vec(vec)
       pairs = vec.items.each_slice(2).to_a
-      rendered_pairs = pairs.map do |pair|
-        left, right = pair
-        return nil unless pair.length == 2
+      return unless pairs.all? { |pair| pair.length == 2 }
 
+      rendered_pairs = pairs.map do |left, right|
         render_binding_pair(left, right)
       end
-      return nil if rendered_pairs.any?(&:nil?)
+      return if rendered_pairs.any?(&:nil?)
 
       lines = ["[#{rendered_pairs.first}"]
       continuation = ' ' * '(let ['.length
@@ -609,7 +608,7 @@ module Kapusta
     def render_pair(left, right, indent)
       left_rendered = flat_render(left) || render(left, indent)
       right_rendered = flat_render(right) || render(right, indent)
-      return nil unless single_line?(left_rendered) && single_line?(right_rendered)
+      return unless single_line?(left_rendered) && single_line?(right_rendered)
 
       pair = "#{left_rendered} #{right_rendered}"
       fits?(pair, indent) ? pair : nil
@@ -617,12 +616,12 @@ module Kapusta
 
     def render_binding_pair(left, right)
       left_rendered = flat_render(left)
-      return nil unless left_rendered
+      return unless left_rendered
 
       right_rendered = render(right, '(let ['.length + left_rendered.length + 1)
       first_line, *rest = right_rendered.lines(chomp: true)
       pair = "#{left_rendered} #{first_line}"
-      return nil unless pair.length <= MAX_WIDTH
+      return unless pair.length <= MAX_WIDTH
 
       return pair if rest.empty?
 

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,12 +223,31 @@ 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'
-      return nil if token == 'nil'
-      return token.to_i if token.match?(/\A-?\d+\z/)
-      return token.to_f if token.match?(/\A-?\d+\.\d+\z/)
+      return if token == 'nil'
+      return Integer(token, 10) if token.match?(/\A-?\d+\z/)
+      return Float(token) if token.match?(/\A-?\d+\.\d+\z/)
 
       if token.start_with?(':') && token.length > 1
         Kapusta.kebab_to_snake(token[1..]).to_sym

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 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