kapusta 0.1.3 → 0.1.5

data/lib/kapusta/compiler/runtime.rb

@@ -4,6 +4,7 @@ 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],
@@ -20,12 +21,12 @@ module Kapusta
 
       HELPER_SOURCES = {
         kebab_to_snake: <<~RUBY.chomp,
-          def __kap_kebab_to_snake(name)
+          def kap_kebab_to_snake(name)
             name.tr('-', '_')
           end
         RUBY
         call: <<~'RUBY'.chomp,
-          def __kap_call(callee, positional, kwargs = nil, block = nil)
+          def kap_call(callee, positional, kwargs = nil, block = nil)
             raise "not callable: #{callee.inspect}" unless callee.respond_to?(:call)
 
             if block
@@ -36,7 +37,7 @@ module Kapusta
           end
         RUBY
         send_call: <<~RUBY.chomp,
-          def __kap_send_call(receiver, method_name, positional, kwargs = nil, block = nil)
+          def kap_send_call(receiver, method_name, positional, kwargs = nil, block = nil)
             if block
               if kwargs
                 receiver.public_send(method_name, *positional, **kwargs, &block)
@@ -51,7 +52,7 @@ module Kapusta
           end
         RUBY
         invoke_self: <<~RUBY.chomp,
-          def __kap_invoke_self(receiver, method_name, positional, kwargs = nil, block = nil)
+          def kap_invoke_self(receiver, method_name, positional, kwargs = nil, block = nil)
             if block
               if kwargs
                 receiver.send(method_name, *positional, **kwargs, &block)
@@ -63,53 +64,50 @@ module Kapusta
             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
-
+        stringify: <<~RUBY.chomp,
+          def kap_stringify(value)
             case value
             when nil then 'nil'
-            when true then 'true'
-            when false then 'false'
-            when Array, Hash then render.call(value)
+            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"))
+          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
+          def kap_concat(values)
+            values.map { |value| kap_stringify(value) }.join
           end
         RUBY
         get_path: <<~RUBY.chomp,
-          def __kap_get_path(obj, keys)
+          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)
+          def kap_qget_path(obj, keys)
             keys.each do |key|
-              return nil if obj.nil?
+              return if obj.nil?
 
               obj = obj[key]
             end
@@ -117,64 +115,64 @@ module Kapusta
           end
         RUBY
         set_path: <<~RUBY.chomp,
-          def __kap_set_path(obj, keys, value)
+          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) }
+          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)
+          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)
+              target = target.public_send(kap_kebab_to_snake(segment).to_sym)
             end
-            setter = "#{__kap_kebab_to_snake(segments.last)}="
+            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)
+          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)}")
+          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)
+          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)}")
+          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)
+          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__)
+          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__)
+          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)
+          def kap_ensure_module(holder, path)
             segments = path.split('.')
             last = segments.pop
             scope = holder.is_a?(Module) ? holder : Object
@@ -198,7 +196,7 @@ module Kapusta
           end
         RUBY
         ensure_class: <<~RUBY.chomp,
-          def __kap_ensure_class(holder, path, super_class)
+          def kap_ensure_class(holder, path, super_class)
             segments = path.split('.')
             last = segments.pop
             scope = holder.is_a?(Module) ? holder : Object
@@ -222,14 +220,14 @@ module Kapusta
           end
         RUBY
         destructure: <<~RUBY.chomp,
-          def __kap_destructure(pattern, value)
+          def kap_destructure(pattern, value)
             bindings = {}
-            __kap_destructure_into(pattern, value, bindings)
+            kap_destructure_into(pattern, value, bindings)
             bindings
           end
         RUBY
         destructure_into: <<~'RUBY'.chomp,
-          def __kap_destructure_into(pattern, value, bindings)
+          def kap_destructure_into(pattern, value, bindings)
             case pattern[0]
             when :sym
               name = pattern[1]
@@ -241,18 +239,18 @@ module Kapusta
                 before = items[0...rest_idx]
                 rest_pattern = items[rest_idx][1]
                 before.each_with_index do |item, i|
-                  __kap_destructure_into(item, value ? value[i] : nil, bindings)
+                  kap_destructure_into(item, value ? value[i] : nil, bindings)
                 end
                 rest_value = value ? (value[rest_idx..] || []) : []
-                __kap_destructure_into(rest_pattern, rest_value, bindings)
+                kap_destructure_into(rest_pattern, rest_value, bindings)
               else
                 items.each_with_index do |item, i|
-                  __kap_destructure_into(item, value ? value[i] : nil, bindings)
+                  kap_destructure_into(item, value ? value[i] : nil, bindings)
                 end
               end
             when :hash
               pattern[1].each do |key, subpattern|
-                __kap_destructure_into(subpattern, value ? value[key] : nil, bindings)
+                kap_destructure_into(subpattern, value ? value[key] : nil, bindings)
               end
             when :ignore
               nil
@@ -262,13 +260,13 @@ module Kapusta
           end
         RUBY
         match_pattern: <<~RUBY.chomp,
-          def __kap_match_pattern(pattern, value)
+          def kap_match_pattern(pattern, value)
             bindings = {}
-            [__kap_match_pattern_into(pattern, value, bindings), bindings]
+            [kap_match_pattern_into(pattern, value, bindings), bindings]
           end
         RUBY
         match_pattern_into: <<~'RUBY'.chomp
-          def __kap_match_pattern_into(pattern, value, bindings)
+          def kap_match_pattern_into(pattern, value, bindings)
             case pattern[0]
             when :bind
               name = pattern[1]
@@ -293,14 +291,14 @@ module Kapusta
                 return false if array.length < before.length
 
                 before.each_with_index do |item, i|
-                  return false unless __kap_match_pattern_into(item, array[i], bindings)
+                  return false unless kap_match_pattern_into(item, array[i], bindings)
                 end
-                __kap_match_pattern_into(rest_pattern, array[rest_idx..], bindings)
+                kap_match_pattern_into(rest_pattern, array[rest_idx..], bindings)
               else
                 return false unless array.length >= items.length
 
                 items.each_with_index do |item, i|
-                  return false unless __kap_match_pattern_into(item, array[i], bindings)
+                  return false unless kap_match_pattern_into(item, array[i], bindings)
                 end
                 true
               end
@@ -309,7 +307,7 @@ module Kapusta
 
               pattern[1].each do |key, subpattern|
                 return false unless value.key?(key)
-                return false unless __kap_match_pattern_into(subpattern, value[key], bindings)
+                return false unless kap_match_pattern_into(subpattern, value[key], bindings)
               end
               true
             when :lit
@@ -319,7 +317,7 @@ module Kapusta
             when :or
               pattern[1].any? do |option|
                 option_bindings = bindings.dup
-                next false unless __kap_match_pattern_into(option, value, option_bindings)
+                next false unless kap_match_pattern_into(option, value, option_bindings)
 
                 bindings.replace(option_bindings)
                 true
@@ -334,7 +332,7 @@ module Kapusta
       module_function
 
       def helper_name(name)
-        "__kap_#{name}"
+        "kap_#{name}"
       end
 
       def helper_source(helpers)
@@ -366,11 +364,14 @@ module Kapusta
       helper_methods = []
 
       HELPER_SOURCES.each_key do |name|
-        helper_method = :"__kap_#{name}"
-        define_singleton_method(name, instance_method(helper_method))
+        helper_method = :"kap_#{name}"
+        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/compiler.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'error'
 require_relative 'compiler/runtime'
 require_relative 'compiler/normalizer'
 require_relative 'compiler/emitter'
 
 module Kapusta
   module Compiler
-    class Error < StandardError; end
+    class Error < Kapusta::Error; end
     SPECIAL_FORMS = %w[
       fn lambda λ let local var set if when unless case match
       while for each do values

data/lib/kapusta/env.rb

@@ -2,6 +2,8 @@
 
 module Kapusta
   class Env
+    MethodBinding = Struct.new(:ruby_name)
+
     def initialize(parent = nil)
       @parent = parent
       @vars = {}
@@ -25,6 +27,14 @@ module Kapusta
       @vars.key?(name) || @parent&.defined?(name)
     end
 
+    def 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.any? { |_source_name, value| binding_ruby_name(value) == name }
+    end
+
     def set_existing!(name, value)
       if @vars.key?(name)
         @vars[name] = value
@@ -38,5 +48,11 @@ module Kapusta
     def child
       Env.new(self)
     end
+
+    private
+
+    def binding_ruby_name(value)
+      value.respond_to?(:ruby_name) ? value.ruby_name : value
+    end
   end
 end

data/lib/kapusta/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class Error < StandardError; 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?
 
@@ -675,15 +674,6 @@ module Kapusta
       end
     end
 
-    def fn_body(form)
-      args = list_rest(form)
-      if args[0].is_a?(Sym) && args[1].is_a?(Vec)
-        args.drop(2)
-      else
-        args.drop(1)
-      end
-    end
-
     def consecutive_requires?(previous, current)
       require_form?(previous) && require_form?(current)
     end
@@ -834,6 +824,6 @@ module Kapusta
       puts 'Formats Kapusta source using the built-in Kapusta reader and pretty-printer.'
     end
 
-    class Error < StandardError; end
+    class Error < Kapusta::Error; end
   end
 end

data/lib/kapusta/reader.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'error'
+
 module Kapusta
   class Reader
+    class Error < Kapusta::Error; end
+
     WHITESPACE = [' ', "\t", "\n", "\r", "\f", "\v", ','].freeze
     DELIMS = ['(', ')', '[', ']', '{', '}', '"', ';'].freeze
 
@@ -61,7 +65,7 @@ module Kapusta
 
     def read_next_item
       skip_ws
-      raise 'unexpected eof' if eof?
+      raise Error, 'unexpected eof' if eof?
 
       return read_comment if @preserve_comments && peek == ';'
 
@@ -70,7 +74,7 @@ module Kapusta
 
     def read_form
       skip_ws
-      raise 'unexpected eof' if eof?
+      raise Error, 'unexpected eof' if eof?
 
       return read_comment if @preserve_comments && peek == ';'
 
@@ -93,7 +97,7 @@ module Kapusta
       items = []
       loop do
         skip_ws
-        raise 'unclosed (' if eof?
+        raise Error, 'unclosed (' if eof?
         break if peek == ')'
 
         items << read_next_item
@@ -107,7 +111,7 @@ module Kapusta
       items = []
       loop do
         skip_ws
-        raise 'unclosed [' if eof?
+        raise Error, 'unclosed [' if eof?
         break if peek == ']'
 
         items << read_next_item
@@ -122,7 +126,7 @@ module Kapusta
       pending = []
       loop do
         skip_ws
-        raise 'unclosed {' if eof?
+        raise Error, 'unclosed {' if eof?
         break if peek == '}'
 
         item = read_next_item
@@ -139,7 +143,7 @@ module Kapusta
       end
       advance
 
-      raise 'odd number of forms in hash' unless pending.empty?
+      raise Error, 'odd number of forms in hash' unless pending.empty?
 
       HashLit.new(entries)
     end
@@ -168,7 +172,7 @@ module Kapusta
           buffer << advance
         end
       end
-      raise 'unterminated string' if eof?
+      raise Error, 'unterminated string' if eof?
 
       advance
       buffer
@@ -209,7 +213,7 @@ module Kapusta
       start = @pos
       advance until delim?(peek)
       token = @src[start...@pos]
-      raise 'empty token' if token.empty?
+      raise Error, 'empty token' if token.empty?
 
       parse_atom(token)
     end
@@ -217,9 +221,9 @@ module Kapusta
     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
@@ -230,7 +234,7 @@ module Kapusta
 
     def normalize_hash_pair(item, value)
       if item.is_a?(Sym) && item.name == ':'
-        raise 'bad shorthand' unless value.is_a?(Sym)
+        raise Error, 'bad shorthand' unless value.is_a?(Sym)
 
         key = Kapusta.kebab_to_snake(value.name).to_sym
         [key, value]

data/lib/kapusta/version.rb

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

data/lib/kapusta.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'kapusta/version'
+require_relative 'kapusta/error'
 require_relative 'kapusta/support'
 require_relative 'kapusta/ast'
 require_relative 'kapusta/reader'

data/spec/cli_spec.rb

@@ -26,17 +26,23 @@ ensure
 end
 
 RSpec.describe Kapusta::CLI do
-  it 'compiles a .kap file to stdout with --compile' do
+  it 'compiles a .kap file to runnable Ruby with --compile' do
     path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
 
-    output = capture_stdout do
+    ruby = capture_stdout do
       described_class.start(['--compile', path])
     end
 
-    expect(output).to include('__kap_print_values("FizzBuzz")')
-    expect(output).not_to include('Kapusta::Compiler::Runtime')
-    expect(output).not_to include('module Kapusta')
-    expect(output).not_to include('def __kap_get_path')
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, 'fizzbuzz.rb')
+      File.write(output_path, ruby)
+
+      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"
+      expect(status.success?).to eq(true), stderr
+      expect(stdout).to eq(expected)
+    end
   end
 
   it 'rejects extra positional arguments in compile mode' do
@@ -50,21 +56,6 @@ RSpec.describe Kapusta::CLI do
     expect(error_output).to include('usage: kapusta')
   end
 
-  it 'emits standalone Ruby that runs with plain ruby' do
-    source_path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
-
-    Dir.mktmpdir do |dir|
-      output_path = File.join(dir, 'fizzbuzz.rb')
-      ruby = Kapusta.compile(File.read(source_path), path: source_path)
-      File.write(output_path, ruby)
-
-      stdout, stderr, status = Open3.capture3(RbConfig.ruby, output_path)
-
-      expect(status.success?).to eq(true), stderr
-      expect(stdout).to include("FizzBuzz\n")
-    end
-  end
-
   it 'passes remaining arguments through to the Kapusta program' do
     path = File.expand_path('../examples/greet.kap', __dir__)
 

data/spec/examples_spec.rb

@@ -63,6 +63,10 @@ RSpec.describe 'examples' do
     expect(run_example('counter.kap')).to eq("12\n")
   end
 
+  it 'contains-duplicate.kap' do
+    expect(run_example('contains-duplicate.kap')).to eq("true\nfalse\ntrue\n")
+  end
+
   it 'doto.kap' do
     expect(run_example('doto.kap')).to eq("1, 2, 3\n")
   end
@@ -302,6 +306,6 @@ end
 RSpec.describe 'errors' do
   it 'raises on unclosed list' do
     expect { Kapusta.eval('(fn hello [name] (.. "Hi " name "!")') }
-      .to raise_error(/unclosed \(/)
+      .to raise_error(Kapusta::Reader::Error, /unclosed \(/)
   end
 end