kapusta 0.2.3 → 0.3.0

data/lib/kapusta.rb

@@ -12,10 +12,12 @@ module Kapusta
   @loaded_kapusta_features = {}
 
   def self.eval(source, path: '(eval)', **_opts)
+    install!
     Compiler.run(source, path:)
   end
 
   def self.dofile(path, **_opts)
+    install!
     source = File.read(path)
     self.eval(source, path:)
   end
@@ -25,6 +27,7 @@ module Kapusta
   end
 
   def self.require(feature, relative_to: nil)
+    install!
     feature = feature.to_s
     local_path = resolve_require_path(feature, relative_to:)
 
@@ -35,12 +38,33 @@ module Kapusta
   end
 
   def self.install!
-    @install ||= begin
-      Kernel.require 'rubygems'
-      true
+    return if @installed
+
+    @installed = true
+    Kernel.module_eval do
+      alias_method :__kapusta_original_require_relative, :require_relative
+      private :__kapusta_original_require_relative
+
+      def require_relative(path)
+        kap_path = Kapusta.send(:resolve_kap_relative, path, caller_locations(1, 1).first)
+        return Kapusta.send(:require_kapusta_file, kap_path) if kap_path
+
+        __kapusta_original_require_relative(path)
+      end
     end
   end
 
+  def self.resolve_kap_relative(path, location)
+    return unless path.is_a?(String) && location
+
+    base_file = location.absolute_path || location.path
+    return unless base_file
+
+    full = File.expand_path(path, File.dirname(File.expand_path(base_file)))
+    candidates = full.end_with?('.kap') ? [full] : ["#{full}.kap"]
+    candidates.find { |c| File.file?(c) }
+  end
+
   def self.resolve_require_path(feature, relative_to:)
     return unless local_feature?(feature)
 
@@ -88,5 +112,5 @@ module Kapusta
   end
 
   private_class_method :resolve_require_path, :local_feature?, :require_base_dir,
-                       :existing_feature_path, :require_kapusta_file
+                       :existing_feature_path, :require_kapusta_file, :resolve_kap_relative
 end

data/spec/examples_spec.rb

@@ -280,6 +280,10 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'pivot-index.kap' do
+    expect(run_example('pivot-index.kap')).to eq("3\n-1\n0\n")
+  end
+
   it 'points.kap' do
     expect(run_example('points.kap')).to eq(<<~OUT)
       "origin"
@@ -480,6 +484,10 @@ RSpec.describe 'examples' do
     expect(run_example('majority-element.kap')).to eq("3\n2\n1\n")
   end
 
+  it 'manhattan-distance.kap' do
+    expect(run_example('manhattan-distance.kap')).to eq("14\n")
+  end
+
   it 'plus-one.kap' do
     expect(run_example('plus-one.kap')).to eq(<<~OUT)
       [1, 2, 4]
@@ -488,4 +496,8 @@ RSpec.describe 'examples' do
       [1, 0, 0]
     OUT
   end
+
+  it 'subtract-product-sum.kap' do
+    expect(run_example('subtract-product-sum.kap')).to eq("15\n21\n0\n")
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -57,6 +57,7 @@ files:
 - examples/leap-year.kap
 - examples/length-of-last-word.kap
 - examples/majority-element.kap
+- examples/manhattan-distance.kap
 - examples/match.kap
 - examples/maximum-subarray.kap
 - examples/min-max.kap
@@ -68,6 +69,7 @@ files:
 - examples/pangram.kap
 - examples/pcall.kap
 - examples/pipeline.kap
+- examples/pivot-index.kap
 - examples/plus-one.kap
 - examples/points.kap
 - examples/primes.kap
@@ -83,6 +85,7 @@ files:
 - examples/single-number.kap
 - examples/squares.kap
 - examples/stack.kap
+- examples/subtract-product-sum.kap
 - examples/sum.kap
 - examples/threading.kap
 - examples/tic-tac-toe.kap
@@ -111,7 +114,6 @@ files:
 - lib/kapusta/compiler/emitter/patterns.rb
 - lib/kapusta/compiler/emitter/support.rb
 - lib/kapusta/compiler/normalizer.rb
-- lib/kapusta/compiler/runtime.rb
 - lib/kapusta/env.rb
 - lib/kapusta/error.rb
 - lib/kapusta/formatter.rb

data/lib/kapusta/compiler/runtime.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-module Kapusta
-  module Compiler
-    module Runtime
-      HELPER_DEPENDENCIES = {
-        destructure: %i[destructure_into],
-        match_pattern: %i[match_pattern_into]
-      }.freeze
-
-      HELPER_SOURCES = {
-        qget_path: <<~RUBY.chomp,
-          def kap_qget_path(obj, keys)
-            keys.each do |key|
-              return if obj.nil?
-
-              obj = obj[key]
-            end
-            obj
-          end
-        RUBY
-        ensure_module: <<~RUBY.chomp,
-          def kap_ensure_module(holder, path)
-            segments = path.split('.')
-            last = segments.pop
-            scope = holder.is_a?(Module) ? holder : Object
-            segments.each do |segment|
-              scope =
-                if scope.const_defined?(segment, false)
-                  scope.const_get(segment, false)
-                else
-                  mod = Module.new
-                  scope.const_set(segment, mod)
-                  mod
-                end
-            end
-            if scope.const_defined?(last, false)
-              scope.const_get(last, false)
-            else
-              mod = Module.new
-              scope.const_set(last, mod)
-              mod
-            end
-          end
-        RUBY
-        ensure_class: <<~RUBY.chomp,
-          def kap_ensure_class(holder, path, super_class)
-            segments = path.split('.')
-            last = segments.pop
-            scope = holder.is_a?(Module) ? holder : Object
-            segments.each do |segment|
-              scope =
-                if scope.const_defined?(segment, false)
-                  scope.const_get(segment, false)
-                else
-                  mod = Module.new
-                  scope.const_set(segment, mod)
-                  mod
-                end
-            end
-            if scope.const_defined?(last, false)
-              scope.const_get(last, false)
-            else
-              klass = Class.new(super_class)
-              scope.const_set(last, klass)
-              klass
-            end
-          end
-        RUBY
-        destructure: <<~RUBY.chomp,
-          def kap_destructure(pattern, value)
-            bindings = {}
-            kap_destructure_into(pattern, value, bindings)
-            bindings
-          end
-        RUBY
-        destructure_into: <<~'RUBY'.chomp,
-          def kap_destructure_into(pattern, value, bindings)
-            case pattern[0]
-            when :sym
-              name = pattern[1]
-              bindings[name] = value unless name == '_'
-            when :vec
-              items = pattern[1]
-              rest_idx = items.index { |item| item.is_a?(Array) && item[0] == :rest }
-              if rest_idx
-                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)
-                end
-                rest_value = value ? (value[rest_idx..] || []) : []
-                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)
-                end
-              end
-            when :hash
-              pattern[1].each do |key, subpattern|
-                kap_destructure_into(subpattern, value ? value[key] : nil, bindings)
-              end
-            when :ignore
-              nil
-            else
-              raise "unknown destructure pattern: #{pattern.inspect}"
-            end
-          end
-        RUBY
-        match_pattern: <<~RUBY.chomp,
-          def kap_match_pattern(pattern, value)
-            bindings = {}
-            [kap_match_pattern_into(pattern, value, bindings), bindings]
-          end
-        RUBY
-        match_pattern_into: <<~'RUBY'.chomp
-          def kap_match_pattern_into(pattern, value, bindings)
-            case pattern[0]
-            when :bind
-              name = pattern[1]
-              allow_nil = pattern[2]
-              return false if value.nil? && !allow_nil
-
-              bindings[name] = value
-              true
-            when :ref
-              bindings.key?(pattern[1]) && bindings[pattern[1]] == value
-            when :wild
-              true
-            when :vec
-              return false unless value.is_a?(Array) || value.respond_to?(:to_ary)
-
-              array = value.is_a?(Array) ? value : value.to_ary
-              items = pattern[1]
-              rest_idx = items.index { |item| item.is_a?(Array) && item[0] == :rest }
-              if rest_idx
-                before = items[0...rest_idx]
-                rest_pattern = items[rest_idx][1]
-                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)
-                end
-                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)
-                end
-                true
-              end
-            when :hash
-              return false unless value.is_a?(Hash)
-
-              pattern[1].each do |key, subpattern|
-                return false unless value.key?(key)
-                return false unless kap_match_pattern_into(subpattern, value[key], bindings)
-              end
-              true
-            when :lit
-              value == pattern[1]
-            when :pin
-              value == pattern[1]
-            when :or
-              pattern[1].any? do |option|
-                option_bindings = bindings.dup
-                next false unless kap_match_pattern_into(option, value, option_bindings)
-
-                bindings.replace(option_bindings)
-                true
-              end
-            else
-              raise "bad pattern: #{pattern.inspect}"
-            end
-          end
-        RUBY
-      }.transform_values(&:freeze).freeze
-
-      module_function
-
-      def helper_name(name)
-        "kap_#{name}"
-      end
-
-      def helper_source(helpers)
-        ordered = []
-        seen = {}
-        helpers.each { |name| append_helper_source(name.to_sym, ordered, seen) }
-        return '' if ordered.empty?
-
-        [
-          ordered.map { |name| HELPER_SOURCES.fetch(name) }.join("\n\n"),
-          "private #{ordered.map { |name| ":#{helper_name(name)}" }.join(', ')}"
-        ].join("\n\n")
-      end
-
-      def append_helper_source(name, ordered, seen)
-        return if seen[name]
-
-        HELPER_DEPENDENCIES.fetch(name, []).each do |dependency|
-          append_helper_source(dependency, ordered, seen)
-        end
-        ordered << name
-        seen[name] = true
-      end
-
-      HELPER_SOURCES.each_value do |source|
-        module_eval(source, __FILE__, __LINE__)
-      end
-
-      helper_methods = []
-
-      HELPER_SOURCES.each_key do |name|
-        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
-end