kapusta 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25c55d7f1c7a4b1dcd3cca0e7a513a74591905e9dfc97e96f015b695d75905a2
-  data.tar.gz: '0940fc49053103149667dd8bf515e159d87a10182bb3fbd5eb152ba63f487e06'
+  metadata.gz: 62ac0b0f6d3ce6116b82110191b5c36783ed1689e2567076dbe68fc66e6ab3f7
+  data.tar.gz: 6b705edf9d441c4f753e8420b0e8bc6a2327d91f6ab9041a603c3afe6546487b
 SHA512:
-  metadata.gz: a3a8cb442fcb6d5157dcf3885e9d6a7323735418e488715e35baea0006b098e8822b8252013eea2636f96a35665db8173556507af293188f632108827f8119d5
-  data.tar.gz: d0f19cbc23c569524cb64c0b70b14d4ea5ed149291acad18528611a7b12c2ff1b4d9c27ce1a239ec07e9c19bb36c5907f294fbca4b0b783bfc2991c880b93fc7
+  metadata.gz: 243b1e47fd6a5684f7b4d2a9bf46e27d6b96883fb3cf71bf4f90edb4d48f0e5afa006c2da0191f5fc3cb116e37b506243b0f7030b90a6c6096629173e98074de
+  data.tar.gz: 825b21b71cb0eacb24623beff28dc2fcb1b542cf50268d78ebcfba2b156bf634992975fb1f1a3a0e27f407c51e54c8eb96683d544f861de5f5cc51731fc819c3

data/README.md

@@ -10,6 +10,14 @@ For more information about Kapusta, see the official Fennel documentation and tu
 
 ## Usage
 
+```
+gem install kapusta
+kapfmt --fix examples/fizzbuzz.kap
+kapusta examples/fizzbuzz.kap
+```
+
+or
+
 ```
 exe/kapusta examples/fizzbuzz.kap
 ```
@@ -37,7 +45,7 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 Kapusta-specific additions:
 
 - `module` and `class` for Ruby host structure, including file-header forms
-- `ivar` / `cvar` / `gvar` escape hatches
+- `ivar` (`@var`) / `cvar` (`@@var`) / `gvar` (`$var`) escape hatches
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch
 - a trailing symbol-keyed hash is emitted as Ruby keyword arguments

data/lib/kapusta/compiler/runtime.rb

@@ -63,12 +63,29 @@ module Kapusta
             end
           end
         RUBY
-        stringify: <<~RUBY.chomp,
+        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
@@ -327,257 +344,19 @@ module Kapusta
         seen[name] = true
       end
 
-      def 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
-
-      def 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
-
-      def 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
-
-      def stringify(value)
-        case value
-        when nil then 'nil'
-        when true then 'true'
-        when false then 'false'
-        else value.to_s
-        end
-      end
-
-      def print_values(*values)
-        $stdout.puts(values.map { |value| stringify(value) }.join("\t"))
-        nil
-      end
-
-      def concat(values)
-        values.map { |value| stringify(value) }.join
-      end
-
-      def get_path(obj, keys)
-        keys.reduce(obj) { |acc, key| acc[key] }
-      end
-
-      def qget_path(obj, keys)
-        keys.each do |key|
-          return nil if obj.nil?
-
-          obj = obj[key]
-        end
-        obj
-      end
-
-      def set_path(obj, keys, value)
-        target = obj
-        keys[0...-1].each { |key| target = target[key] }
-        target[keys.last] = value
-      end
-
-      def method_path_value(base, segments)
-        segments.reduce(base) { |obj, segment| obj.public_send(Kapusta.kebab_to_snake(segment).to_sym) }
-      end
-
-      def set_method_path(base, segments, value)
-        target = base
-        segments[0...-1].each do |segment|
-          target = target.public_send(Kapusta.kebab_to_snake(segment).to_sym)
-        end
-        setter = "#{Kapusta.kebab_to_snake(segments.last)}="
-        target.public_send(setter.to_sym, value)
-      end
-
-      def current_class_scope(receiver)
-        receiver.is_a?(Module) ? receiver : receiver.class
-      end
-
-      def get_ivar(receiver, name)
-        receiver.instance_variable_get("@#{Kapusta.kebab_to_snake(name)}")
-      end
-
-      def set_ivar(receiver, name, value)
-        receiver.instance_variable_set("@#{Kapusta.kebab_to_snake(name)}", value)
-      end
-
-      def get_cvar(receiver, name)
-        current_class_scope(receiver).class_variable_get("@@#{Kapusta.kebab_to_snake(name)}")
-      end
-
-      def set_cvar(receiver, name, value)
-        current_class_scope(receiver).class_variable_set("@@#{Kapusta.kebab_to_snake(name)}", value)
+      HELPER_SOURCES.each_value do |source|
+        module_eval(source, __FILE__, __LINE__)
       end
 
-      def get_gvar(name)
-        Kernel.eval("$#{Kapusta.kebab_to_snake(name)}", binding, __FILE__, __LINE__) # $stderr
-      end
+      helper_methods = []
 
-      def set_gvar(name, value)
-        Kernel.eval("$#{Kapusta.kebab_to_snake(name)} = value", binding, __FILE__, __LINE__) # $stderr = value
+      HELPER_SOURCES.each_key do |name|
+        helper_method = :"__kap_#{name}"
+        define_singleton_method(name, instance_method(helper_method))
+        helper_methods << helper_method
       end
 
-      def 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
-
-      def 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
-
-      def destructure(pattern, value)
-        bindings = {}
-        destructure_into(pattern, value, bindings)
-        bindings
-      end
-
-      def 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|
-              destructure_into(item, value ? value[i] : nil, bindings)
-            end
-            rest_value = value ? (value[rest_idx..] || []) : []
-            destructure_into(rest_pattern, rest_value, bindings)
-          else
-            items.each_with_index do |item, i|
-              destructure_into(item, value ? value[i] : nil, bindings)
-            end
-          end
-        when :hash
-          pattern[1].each do |key, subpattern|
-            destructure_into(subpattern, value ? value[key] : nil, bindings)
-          end
-        when :ignore
-          nil
-        else
-          raise "unknown destructure pattern: #{pattern.inspect}"
-        end
-      end
-
-      def match_pattern(pattern, value)
-        bindings = {}
-        [match_pattern_into(pattern, value, bindings), bindings]
-      end
-
-      def match_pattern_into(pattern, value, bindings)
-        case pattern[0]
-        when :sym
-          name = pattern[1]
-          bindings[name] = value unless name == '_'
-          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 match_pattern_into(item, array[i], bindings)
-            end
-            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 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 match_pattern_into(subpattern, value[key], bindings)
-          end
-          true
-        when :lit
-          value == pattern[1]
-        when :nil
-          value.nil?
-        else
-          raise "bad pattern: #{pattern.inspect}"
-        end
-      end
+      send(:private, *helper_methods)
     end
   end
 end

data/lib/kapusta/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Evgenii Morozov