code-ruby 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dfeedb1e668e150c3039e1cee85eee9072ea16d0f619f45e71263c8c94ae707
-  data.tar.gz: 1c2fb6de918462b02df14191ab14f7d27a92f0bea9113a54fa8344e7b8bab48e
+  metadata.gz: f269ce2ed25933bd413596e077a7f37fdd8b2914d4f2a40c49ae040a3d80eaa2
+  data.tar.gz: ca1870d839bd4ad4d46546b7320c39469fbe8f37425fb3ba0457f9584a6e4907
 SHA512:
-  metadata.gz: c810a7b5a9ca1cbfc9c710e1ec615dd043dccf047fd220f35b71cf8e7fa2feab9cbf3fde9b1f31b57c690e25f5be1e71f4881a0efced0baea0b9f51e4a9abd78
-  data.tar.gz: 45571c9a8247d75f3c513e52dfebc4ed3e3fe527996c5a1dc8717fb740c6fa4736c6fb26da93c57a73558318f45a4bf5dc3d2ccf38b460d570b58d1171e8a776
+  metadata.gz: e00e5e53b5bd74c402f7e6ea3b32d05ecf06faab892a52cf6b28e4c7c926821f33e7e7fea098b0d7350f58e20c548797bd297c5b6ff2743bbc04a7f8778b92a7
+  data.tar.gz: 4120703ce09203e412baa280f2dae7ea19d51beec10c08f393d8d362e7a294a3a9e21c6ed125768d88fc619f0908d252ce3bd67e2f5fe067e0c320b08a764659

data/CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.4.0 / 2022-10-21
+
+- Rewrite of how functions are called internally (no more `public_send`)
+- Call ruby functions from template/code
+
 ## 0.3.1 / 2022-10-13
 
 - Fix Zeitwerk auto-loading issue

data/Gemfile

@@ -2,3 +2,6 @@ source "https://rubygems.org"
 
 gemspec name: "template-ruby"
 gemspec name: "code-ruby"
+
+gem "prettier"
+gem "rspec"

data/Gemfile.lock

@@ -1,11 +1,11 @@
 PATH
   remote: .
   specs:
-    code-ruby (0.2.4)
+    code-ruby (0.3.1)
       activesupport (~> 7)
       parslet (~> 2)
       zeitwerk (~> 2.6)
-    template-ruby (0.2.4)
+    template-ruby (0.3.1)
       activesupport (~> 7)
       parslet (~> 2)
       zeitwerk (~> 2.6)
@@ -13,7 +13,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.3.1)
+    activesupport (7.0.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -39,13 +39,13 @@ GEM
       rspec-mocks (~> 3.11.0)
     rspec-core (3.11.0)
       rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rspec-expectations (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-mocks (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
+    rspec-support (3.11.1)
     syntax_tree (3.5.0)
       prettier_print
     syntax_tree-haml (1.3.1)
@@ -60,15 +60,15 @@ GEM
     tilt (2.0.11)
     tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
-    zeitwerk (2.6.0)
+    zeitwerk (2.6.1)
 
 PLATFORMS
   arm64-darwin-21
 
 DEPENDENCIES
   code-ruby!
-  prettier (~> 3)
-  rspec (~> 3)
+  prettier
+  rspec
   template-ruby!
 
 BUNDLED WITH

data/code-ruby.gemspec

@@ -16,7 +16,4 @@ Gem::Specification.new do |s|
   s.add_dependency "activesupport", "~> 7"
   s.add_dependency "parslet", "~> 2"
   s.add_dependency "zeitwerk", "~> 2.6"
-
-  s.add_development_dependency "prettier", "~> 3"
-  s.add_development_dependency "rspec", "~> 3"
 end

data/lib/code/error.rb

@@ -11,5 +11,8 @@ class Code
 
     class ArgumentError < ::Code::Error
     end
+
+    class IncompatibleContext < ::Code::Error
+    end
   end
 end

data/lib/code/node/call.rb

@@ -22,6 +22,7 @@ class Code
       def evaluate(**args)
         if @right
           left = @left.evaluate(**args)
+
           @right.reduce(left) do |acc, element|
             element.evaluate(**args.merge(object: acc))
           end

data/lib/code/node/chained_call.rb

@@ -16,7 +16,9 @@ class Code
         arguments =
           @arguments.map do |argument|
             ::Code::Object::Argument.new(
-              argument.evaluate(**args.merge(object: nil)),
+              argument.evaluate(
+                **args.merge(object: ::Code::Object::Global.new),
+              ),
               name: argument.name,
               splat: argument.splat?,
               keyword_splat: argument.keyword_splat?,
@@ -26,7 +28,7 @@ class Code
 
         if @block
           arguments << ::Code::Object::Argument.new(
-            @block.evaluate(**args.merge(object: nil)),
+            @block.evaluate(**args.merge(object: ::Code::Object::Global.new)),
             block: true,
           )
         end

data/lib/code/node/list.rb

@@ -5,9 +5,8 @@ class Code
         if codes.to_s.blank?
           @codes = []
         else
-          @codes = codes.map do |code|
-            ::Code::Node::Code.new(code.fetch(:code))
-          end
+          @codes =
+            codes.map { |code| ::Code::Node::Code.new(code.fetch(:code)) }
         end
       end
 

data/lib/code/node/name.rb

@@ -8,41 +8,14 @@ class Code
       def evaluate(**args)
         context = args.fetch(:context)
         arguments = args.fetch(:arguments, [])
-        object = args.fetch(:object, nil)
-        io = args.fetch(:io)
+        object = args.fetch(:object)
+        globals = args.multi_fetch(*::Code::GLOBALS)
 
-        if object
-          object.call(
-            context: context,
-            operator: name,
-            arguments: arguments,
-            io: io,
-          )
-        elsif context.key?(name)
-          object = context[name]
-
-          if object.is_a?(::Code::Object::Function)
-            object.call(
-              context: context,
-              operator: nil,
-              arguments: arguments,
-              io: io,
-            )
-          else
-            object
-          end
-        elsif name == "puts"
-          arguments.each { |argument| io.puts argument.value }
-          ::Code::Object::Nothing.new
-        elsif name == "print"
-          arguments.each { |argument| io.print argument.value }
-          ::Code::Object::Nothing.new
-        elsif name == "context"
-          return ::Code::Object::Nothing.new if arguments.size != 1
-          context[arguments.first&.value] || ::Code::Object::Nothing.new
-        else
-          raise ::Code::Error::Undefined.new("#{name} undefined")
-        end
+        object.call(
+          operator: name,
+          arguments: arguments,
+          **globals
+        )
       end
 
       private

data/lib/code/node/statement.rb

@@ -74,7 +74,7 @@ class Code
       end
 
       def evaluate(**args)
-        @statement.evaluate(**args)
+        @statement.evaluate(**args.merge(object: ::Code::Object::Global.new))
       end
     end
   end

data/lib/code/node/string.rb

@@ -5,16 +5,21 @@ class Code
         if string.to_s.blank?
           @string = []
         elsif string.is_a?(Array)
-          @string = string.map do |component|
-            ::Code::Node::StringComponent.new(component)
-          end
+          @string =
+            string.map do |component|
+              ::Code::Node::StringComponent.new(component)
+            end
         else
           @string = [::Code::Node::StringCharacters.new(string)]
         end
       end
 
       def evaluate(**args)
-        string = @string.map { |component| component.evaluate(**args) }.map(&:to_s).join
+        string =
+          @string
+            .map { |component| component.evaluate(**args) }
+            .map(&:to_s)
+            .join
         ::Code::Object::String.new(string)
       end
     end

data/lib/code/node/string_component.rb

@@ -3,13 +3,13 @@ class Code
     class StringComponent < Node
       def initialize(component)
         if component.key?(:characters)
-          @component = ::Code::Node::StringCharacters.new(
-            component.fetch(:characters)
-          )
+          @component =
+            ::Code::Node::StringCharacters.new(component.fetch(:characters))
         elsif component.key?(:interpolation)
-          @component = ::Code::Node::StringInterpolation.new(
-            component.fetch(:interpolation)
-          )
+          @component =
+            ::Code::Node::StringInterpolation.new(
+              component.fetch(:interpolation),
+            )
         else
           raise NotImplementedError.new(component.inspect)
         end

data/lib/code/node.rb

@@ -3,11 +3,11 @@ class Code
     private
 
     def simple_call(object, operator = nil, value = nil, **args)
+      args = args.multi_fetch(*::Code::GLOBALS)
       object.call(
         operator: operator && ::Code::Object::String.new(operator.to_s),
         arguments: [value && ::Code::Object::Argument.new(value)].compact,
-        context: args.fetch(:context),
-        io: args.fetch(:io),
+        **args
       )
     end
   end

data/lib/code/object/argument.rb

@@ -1,6 +1,6 @@
 class Code
   class Object
-    class Argument < ::Code::Object
+    class Argument
       attr_reader :value, :name, :splat, :keyword_splat, :block
 
       def initialize(

data/lib/code/object/decimal.rb

@@ -19,14 +19,51 @@ class Code
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
 
-        if %w[% - / * **].detect { |o| operator == o }
-          number_operation(operator.to_sym, arguments)
-        elsif %w[< <= > >=].detect { |o| operator == o }
-          comparaison(operator.to_sym, arguments)
-        elsif %w[<< >> & | ^].detect { |o| operator == o }
-          integer_operation(operator.to_sym, arguments)
+        if operator == "%"
+          sig(arguments, ::Code::Object::Number)
+          modulo(arguments.first.value)
         elsif operator == "+"
-          plus(arguments)
+          sig(arguments, ::Code::Object)
+          plus(arguments.first.value)
+        elsif operator == "-"
+          sig(arguments, ::Code::Object::Number)
+          minus(arguments.first.value)
+        elsif operator == "/"
+          sig(arguments, ::Code::Object::Number)
+          division(arguments.first.value)
+        elsif operator == "*"
+          sig(arguments, ::Code::Object::Number)
+          multiplication(arguments.first.value)
+        elsif operator == "**"
+          sig(arguments, ::Code::Object::Number)
+          power(arguments.first.value)
+        elsif operator == "<"
+          sig(arguments, ::Code::Object::Number)
+          inferior(arguments.first.value)
+        elsif operator == "<="
+          sig(arguments, ::Code::Object::Number)
+          inferior_or_equal(arguments.first.value)
+        elsif operator == ">"
+          sig(arguments, ::Code::Object::Number)
+          superior(arguments.first.value)
+        elsif operator == ">="
+          sig(arguments, ::Code::Object::Number)
+          superior_or_equal(arguments.first.value)
+        elsif operator == "<<"
+          sig(arguments, ::Code::Object::Number)
+          left_shift(arguments.first.value)
+        elsif operator == ">>"
+          sig(arguments, ::Code::Object::Number)
+          right_shift(arguments.first.value)
+        elsif operator == "&"
+          sig(arguments, ::Code::Object::Number)
+          bitwise_and(arguments.first.value)
+        elsif operator == "|"
+          sig(arguments, ::Code::Object::Number)
+          bitwise_or(arguments.first.value)
+        elsif operator == "^"
+          sig(arguments, ::Code::Object::Number)
+          bitwise_xor(arguments.first.value)
         else
           super
         end
@@ -42,34 +79,69 @@ class Code
 
       private
 
-      def number_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Decimal.new(raw.public_send(operator, other.raw))
+      def modulo(other)
+        ::Code::Object::Decimal.new(raw % other.raw)
       end
 
-      def integer_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Integer.new(raw.to_i.public_send(operator, other.raw.to_i))
-      end
-
-      def comparaison(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Boolean.new(raw.public_send(operator, other.raw))
-      end
-
-      def plus(arguments)
-        sig(arguments, ::Code::Object)
-        other = arguments.first.value
-
+      def plus(other)
         if other.is_a?(::Code::Object::Number)
           ::Code::Object::Decimal.new(raw + other.raw)
         else
           ::Code::Object::String.new(to_s + other.to_s)
         end
       end
+
+      def minus(other)
+        ::Code::Object::Decimal.new(raw - other.raw)
+      end
+
+      def division(other)
+        ::Code::Object::Decimal.new(raw / other.raw)
+      end
+
+      def multiplication(other)
+        ::Code::Object::Decimal.new(raw * other.raw)
+      end
+
+      def power(other)
+        ::Code::Object::Decimal.new(raw**other.raw)
+      end
+
+      def inferior(other)
+        ::Code::Object::Boolean.new(raw < other.raw)
+      end
+
+      def inferior_or_equal(other)
+        ::Code::Object::Boolean.new(raw <= other.raw)
+      end
+
+      def superior(other)
+        ::Code::Object::Boolean.new(raw > other.raw)
+      end
+
+      def superior_or_equal(other)
+        ::Code::Object::Boolean.new(raw >= other.raw)
+      end
+
+      def left_shift(other)
+        ::Code::Object::Integer.new(raw.to_i << other.raw.to_i)
+      end
+
+      def right_shift(other)
+        ::Code::Object::Integer.new(raw.to_i >> other.raw.to_i)
+      end
+
+      def bitwise_and(other)
+        ::Code::Object::Integer.new(raw.to_i & other.raw.to_i)
+      end
+
+      def bitwise_or(other)
+        ::Code::Object::Integer.new(raw.to_i | other.raw.to_i)
+      end
+
+      def bitwise_xor(other)
+        ::Code::Object::Integer.new(raw.to_i ^ other.raw.to_i)
+      end
     end
   end
 end

data/lib/code/object/dictionnary.rb

@@ -10,20 +10,35 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        context = args.fetch(:context)
-        io = args.fetch(:io)
+        globals = args.multi_fetch(*::Code::GLOBALS)
 
         if operator == "values"
-          values(arguments)
+          sig(arguments)
+          values
+        elsif operator == "keys"
+          sig(arguments)
+          keys
         elsif operator == "each"
-          each(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          each(arguments.first.value, **globals)
         elsif key?(operator)
-          fetch(operator)
+          result = fetch(operator)
+
+          if result.is_a?(::Code::Object::Function)
+            result.call(**args.merge(operator: nil))
+          else
+            sig(arguments)
+            result
+          end
         else
           super
         end
       end
 
+      def merge(other)
+        ::Code::Object::Dictionnary.new(raw.merge(other.raw))
+      end
+
       def fetch(key)
         raw.fetch(key)
       end
@@ -54,24 +69,25 @@ class Code
 
       private
 
-      def values(arguments)
-        sig(arguments)
+      def keys
+        ::Code::Object::List.new(raw.keys)
+      end
+
+      def values
         ::Code::Object::List.new(raw.values)
       end
 
-      def each(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def each(argument, **globals)
         raw.each do |key, value|
           argument.call(
             arguments: [
               ::Code::Object::Argument.new(key),
-              ::Code::Object::Argument.new(value)
+              ::Code::Object::Argument.new(value),
             ],
-            context: context,
-            io: io,
+            **globals,
           )
         end
+
         self
       end
     end

data/lib/code/object/function.rb

@@ -9,11 +9,10 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        context = args.fetch(:context)
-        io = args.fetch(:io)
+        globals = args.multi_fetch(*::Code::GLOBALS)
 
-        if operator.nil?
-          call_function(args: arguments, context: context, io: io)
+        if operator.nil? || operator == "call"
+          call_function(args: arguments, globals: globals)
         else
           super
         end
@@ -31,8 +30,8 @@ class Code
 
       attr_reader :arguments, :body
 
-      def call_function(args:, context:, io:)
-        new_context = context.deep_dup
+      def call_function(args:, globals:)
+        new_context = globals[:context].deep_dup
 
         arguments.each.with_index do |argument, index|
           if argument.regular?
@@ -46,19 +45,22 @@ class Code
               )
             else
               arg = args[index]&.value
-              arg = argument.evaluate(context: new_context, io: io) if arg.nil?
+              arg = argument.evaluate(**globals) if arg.nil?
               new_context[argument.name] = arg
             end
           elsif argument.keyword?
             arg = args.detect { |arg| arg.name == argument.name }&.value
-            arg = argument.evaluate(context: new_context, io: io) if arg.nil?
+            arg = argument.evaluate(**globals) if arg.nil?
             new_context[argument.name] = arg
           else
             raise NotImplementedError
           end
         end
 
-        body.evaluate(context: new_context, io: io)
+        body.evaluate(
+          **globals,
+          context: new_context,
+        )
       end
     end
   end

data/lib/code/object/global.rb

@@ -0,0 +1,37 @@
+class Code
+  class Object
+    class Global < ::Code::Object
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        context = args.fetch(:context)
+        io = args.fetch(:io)
+        globals = args.multi_fetch(*::Code::GLOBALS)
+
+        if operator == "print"
+          io.print(*arguments.map(&:value))
+          ::Code::Object::Nothing.new
+        elsif operator == "puts"
+          io.puts(*arguments.map(&:value))
+          ::Code::Object::Nothing.new
+        elsif operator == "context"
+          sig(arguments, ::Code::Object::String)
+          context[arguments.first.value] || ::Code::Object::Nothing.new
+        elsif operator == "eval"
+          sig(arguments, ::Code::Object::String)
+          Code.evaluate(arguments.first.value.raw)
+        else
+          result = context[operator]
+
+          if result && result.is_a?(::Code::Object::Function)
+            result.call(**args.merge(operator: nil))
+          elsif result
+            result
+          else
+            raise ::Code::Error::Undefined.new("#{operator} is not defined")
+          end
+        end
+      end
+    end
+  end
+end