kapusta 0.1.3 → 0.1.4

data/lib/kapusta/compiler/runtime.rb

@@ -20,12 +20,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 +36,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 +51,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)
@@ -64,7 +64,7 @@ module Kapusta
           end
         RUBY
         stringify: <<~'RUBY'.chomp,
-          def __kap_stringify(value)
+          def kap_stringify(value)
             render = nil
             render = lambda do |item|
               case item
@@ -91,23 +91,23 @@ module Kapusta
           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?
 
@@ -117,64 +117,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 +198,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 +222,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 +241,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 +262,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 +293,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 +309,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 +319,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 +334,7 @@ module Kapusta
       module_function
 
       def helper_name(name)
-        "__kap_#{name}"
+        "kap_#{name}"
       end
 
       def helper_source(helpers)
@@ -366,7 +366,7 @@ module Kapusta
       helper_methods = []
 
       HELPER_SOURCES.each_key do |name|
-        helper_method = :"__kap_#{name}"
+        helper_method = :"kap_#{name}"
         define_singleton_method(name, instance_method(helper_method))
         helper_methods << helper_method
       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

@@ -25,6 +25,14 @@ module Kapusta
       @vars.key?(name) || @parent&.defined?(name)
     end
 
+    def ruby_name_defined?(name)
+      @vars.value?(name) || @parent&.ruby_name_defined?(name)
+    end
+
+    def local_ruby_name_defined?(name)
+      @vars.value?(name)
+    end
+
     def set_existing!(name, value)
       if @vars.key?(name)
         @vars[name] = value

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

@@ -675,15 +675,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 +825,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
@@ -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.4'
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -33,6 +33,7 @@ files:
 - examples/block-sort.kap
 - examples/blocks-and-kwargs.kap
 - examples/calc.kap
+- examples/contains-duplicate.kap
 - examples/counter.kap
 - examples/describe.kap
 - examples/destructure.kap
@@ -94,6 +95,7 @@ files:
 - lib/kapusta/compiler/normalizer.rb
 - lib/kapusta/compiler/runtime.rb
 - lib/kapusta/env.rb
+- lib/kapusta/error.rb
 - lib/kapusta/formatter.rb
 - lib/kapusta/reader.rb
 - lib/kapusta/support.rb