code-ruby 0.3.1 → 0.4.0

data/lib/code/object.rb

@@ -5,38 +5,35 @@ class Code
     def call(**args)
       operator = args.fetch(:operator, nil)
       arguments = args.fetch(:arguments, [])
-      if %w[== === !=].detect { |o| operator == o }
-        comparaison(operator.to_sym, arguments)
+
+      if operator == "=="
+        sig(arguments, ::Code::Object)
+        equal(arguments.first.value)
+      elsif operator == "==="
+        sig(arguments, ::Code::Object)
+        strict_equal(arguments.first.value)
+      elsif operator == "!="
+        sig(arguments, ::Code::Object)
+        different(arguments.first.value)
       elsif operator == "<=>"
-        compare(arguments)
+        sig(arguments, ::Code::Object)
+        compare(arguments.first.value)
       elsif operator == "&&"
-        and_operator(arguments)
+        sig(arguments, ::Code::Object)
+        and_operator(arguments.first.value)
       elsif operator == "||"
-        or_operator(arguments)
+        sig(arguments, ::Code::Object)
+        or_operator(arguments.first.value)
       elsif operator == "to_string"
-        to_string(arguments)
+        sig(arguments)
+        to_string
       else
-        raise ::Code::Error::Undefined.new(
-                "#{operator} not defined on #{inspect}",
-              )
+        raise(
+          Code::Error::Undefined.new("#{operator} not defined on #{inspect}"),
+        )
       end
     end
 
-    def []=(key, value)
-      @attributes ||= {}
-      @attributes[key] = value
-    end
-
-    def [](key)
-      @attributes ||= {}
-      @attributes[key]
-    end
-
-    def key?(key)
-      @attributes ||= {}
-      @attributes.key?(key)
-    end
-
     def truthy?
       true
     end
@@ -78,10 +75,12 @@ class Code
 
     def sig(actual_arguments, *expected_arguments)
       if actual_arguments.size != expected_arguments.size
-        raise ::Code::Error::ArgumentError.new(
-                "Expected #{expected_arguments.size} arguments, " \
-                  "got #{actual_arguments.size} arguments",
-              )
+        raise(
+          ::Code::Error::ArgumentError.new(
+            "Expected #{expected_arguments.size} arguments, " \
+              "got #{actual_arguments.size} arguments",
+          ),
+        )
       end
 
       expected_arguments.each.with_index do |expected_argument, index|
@@ -91,46 +90,49 @@ class Code
           if expected_argument.none? { |expected_arg|
                actual_argument.is_a?(expected_arg)
              }
-            raise ::Code::Error::TypeError.new(
-                    "Expected #{expected_argument}, got #{actual_argument.class}",
-                  )
+            raise(
+              ::Code::Error::TypeError.new(
+                "Expected #{expected_argument}, got #{actual_argument.class}",
+              ),
+            )
           end
         else
           if !actual_argument.is_a?(expected_argument)
-            raise ::Code::Error::TypeError.new(
-                    "Expected #{expected_argument}, got #{actual_argument.class}",
-                  )
+            raise(
+              ::Code::Error::TypeError.new(
+                "Expected #{expected_argument}, got #{actual_argument.class}",
+              ),
+            )
           end
         end
       end
     end
 
-    def comparaison(operator, arguments)
-      sig(arguments, ::Code::Object)
-      other = arguments.first.value
-      ::Code::Object::Boolean.new(public_send(operator, other))
+    def equal(other)
+      ::Code::Object::Boolean.new(self == other)
+    end
+
+    def strict_equal(other)
+      ::Code::Object::Boolean.new(self === other)
+    end
+
+    def different(other)
+      ::Code::Object::Boolean.new(self != other)
     end
 
-    def compare(arguments)
-      sig(arguments, ::Code::Object)
-      other = arguments.first.value
+    def compare(other)
       ::Code::Object::Integer.new(self <=> other)
     end
 
-    def and_operator(arguments)
-      sig(arguments, ::Code::Object)
-      other = arguments.first.value
+    def and_operator(other)
       truthy? ? other : self
     end
 
-    def or_operator(arguments)
-      sig(arguments, ::Code::Object)
-      other = arguments.first.value
+    def or_operator(other)
       truthy? ? self : other
     end
 
-    def to_string(arguments)
-      sig(arguments)
+    def to_string
       ::Code::Object::String.new(to_s)
     end
   end

data/lib/code/parser/function.rb

@@ -30,7 +30,9 @@ class Code
         ampersand.as(:block).maybe >>
           (asterisk >> asterisk).as(:keyword_splat).maybe >>
           asterisk.as(:splat).maybe >> name >>
-          (whitespace? >> equal >> whitespace? >> code_present.as(:default)).maybe
+          (
+            whitespace? >> equal >> whitespace? >> code_present.as(:default)
+          ).maybe
       end
 
       rule(:argument) do

data/lib/code/parser/if.rb

@@ -16,7 +16,7 @@ class Code
       rule(:if_rule) do
         (
           (if_keyword | unless_keyword).as(:if_operator) >> whitespace >>
-          if_modifier.as(:if_statement) >> code.as(:if_body).maybe >>
+            if_modifier.as(:if_statement) >> code.as(:if_body).maybe >>
             (
               else_keyword >>
                 (

data/lib/code/parser/string.rb

@@ -49,29 +49,29 @@ class Code
       end
 
       rule(:single_quoted_character) do
-        escaped_character | (opening_curly_bracket.absent? >> single_quote.absent? >> any)
+        escaped_character |
+          (opening_curly_bracket.absent? >> single_quote.absent? >> any)
       end
 
       rule(:double_quoted_character) do
-        escaped_character | (opening_curly_bracket.absent? >> double_quote.absent? >> any)
+        escaped_character |
+          (opening_curly_bracket.absent? >> double_quote.absent? >> any)
       end
 
       rule(:single_quoted_string) do
         single_quote.ignore >>
           (
             interpolation.as(:interpolation) |
-            single_quoted_character.repeat(1).as(:characters)
-          ).repeat >>
-          single_quote.ignore
+              single_quoted_character.repeat(1).as(:characters)
+          ).repeat >> single_quote.ignore
       end
 
       rule(:double_quoted_string) do
         double_quote.ignore >>
           (
             interpolation.as(:interpolation) |
-            double_quoted_character.repeat(1).as(:characters)
-          ).repeat >>
-          double_quote.ignore
+              double_quoted_character.repeat(1).as(:characters)
+          ).repeat >> double_quote.ignore
       end
 
       rule(:symbol) { colon.ignore >> name }

data/lib/code/ruby.rb

@@ -0,0 +1,161 @@
+class Code
+  class Ruby
+    def initialize(raw = {})
+      @raw = raw
+    end
+
+    def self.to_code(raw)
+      new(raw).to_code
+    end
+
+    def self.from_code(raw)
+      new(raw).from_code
+    end
+
+    def to_code
+      if code?
+        raw
+      elsif true?
+        ::Code::Object::Boolean.new(raw)
+      elsif false?
+        ::Code::Object::Boolean.new(raw)
+      elsif string?
+        ::Code::Object::String.new(raw)
+      elsif symbol?
+        ::Code::Object::String.new(raw.to_s)
+      elsif integer?
+        ::Code::Object::Integer.new(raw)
+      elsif float?
+        ::Code::Object::Decimal.new(raw.to_s)
+      elsif big_decimal?
+        ::Code::Object::Decimal.new(raw)
+      elsif hash?
+        ::Code::Object::Dictionnary.new(
+          raw.map do |key, value|
+            [::Code::Ruby.to_code(key), ::Code::Ruby.to_code(value)]
+          end.to_h
+        )
+      elsif array?
+        ::Code::Object::List.new(
+          raw.map do |element|
+            ::Code::Ruby.to_code(key)
+          end
+        )
+      elsif proc?
+        ::Code::Object::RubyFunction.new(raw)
+      else
+        raise "Unsupported class #{raw.class} for Ruby to Code conversion"
+      end
+    end
+
+    def from_code
+      if code?
+        if code_boolean?
+          raw.raw
+        elsif code_decimal?
+          raw.raw
+        elsif code_integer?
+          raw.raw
+        elsif code_nothing?
+          raw.raw
+        elsif code_range?
+          raw.raw
+        elsif code_string?
+          raw.raw
+        elsif code_dictionnary?
+          raw.raw.map do |key, value|
+            [::Code::Ruby.to_code(key), ::Code::Ruby.to_code(value)]
+          end.to_h
+        elsif code_list?
+          raw.raw.map do |element|
+            ::Code::Ruby.to_code(element)
+          end
+        else
+          raise "Unsupported class #{raw.class} for Code to Ruby conversion"
+        end
+      else
+        raw
+      end
+    end
+
+    private
+
+    attr_reader :raw
+
+    def code?
+      raw.is_a?(::Code::Object)
+    end
+
+    def true?
+      raw.is_a?(::TrueClass)
+    end
+
+    def false?
+      raw.is_a?(::FalseClass)
+    end
+
+    def hash?
+      raw.is_a?(::Hash)
+    end
+
+    def array?
+      raw.is_a?(::Array)
+    end
+
+    def string?
+      raw.is_a?(::String)
+    end
+
+    def symbol?
+      raw.is_a?(::Symbol)
+    end
+
+    def integer?
+      raw.is_a?(::Integer)
+    end
+
+    def float?
+      raw.is_a?(::Float)
+    end
+
+    def big_decimal?
+      raw.is_a?(::BigDecimal)
+    end
+
+    def proc?
+      raw.is_a?(::Proc)
+    end
+
+    def code_boolean?
+      raw.is_a?(::Code::Object::Boolean)
+    end
+
+    def code_decimal?
+      raw.is_a?(::Code::Object::Decimal)
+    end
+
+    def code_integer?
+      raw.is_a?(::Code::Object::Integer)
+    end
+
+    def code_nothing?
+      raw.is_a?(::Code::Object::Nothing)
+    end
+
+    def code_range?
+      raw.is_a?(::Code::Object::Range)
+    end
+
+    def code_string?
+      raw.is_a?(::Code::Object::String)
+    end
+
+    def code_dictionnary?
+      raw.is_a?(::Code::Object::Dictionnary)
+    end
+
+    def code_list?
+      raw.is_a?(::Code::Object::List)
+    end
+  end
+end

data/lib/code-ruby.rb

@@ -11,3 +11,9 @@ loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
 loader.ignore("#{__dir__}/template-ruby.rb")
 loader.ignore("#{__dir__}/code-ruby.rb")
 loader.setup
+
+class Hash
+  def multi_fetch(*keys)
+    keys.map { |key| [key, fetch(key)] }.to_h
+  end
+end

data/lib/code.rb

@@ -1,30 +1,44 @@
 class Code
+  GLOBALS = [:io, :context, :object]
   DEFAULT_TIMEOUT = Template::DEFAULT_TIMEOUT
 
-  def initialize(input, io: $stdout, timeout: DEFAULT_TIMEOUT)
+  def initialize(input, io: $stdout, timeout: DEFAULT_TIMEOUT, ruby: {})
     @input = input
-    @parsed = Timeout.timeout(timeout) { ::Code::Parser::Code.new.parse(@input) }
+    @parsed =
+      Timeout.timeout(timeout) { ::Code::Parser::Code.new.parse(@input) }
     @io = io
     @timeout = timeout || DEFAULT_TIMEOUT
+    @ruby = ::Code::Ruby.to_code(ruby || {})
   end
 
-  def self.evaluate(input, context = "", io: $stdout, timeout: DEFAULT_TIMEOUT)
-    new(input, io: io, timeout: timeout).evaluate(context)
+  def self.evaluate(input, context = "", io: $stdout, timeout: DEFAULT_TIMEOUT, ruby: {})
+    new(input, io: io, timeout: timeout, ruby: ruby).evaluate(context)
   end
 
   def evaluate(context = "")
     Timeout.timeout(timeout) do
       if context.present?
-        context = ::Code.evaluate(context, timeout: timeout)
+        context = ::Code.evaluate(
+          context,
+          timeout: timeout,
+          io: io,
+          ruby: ruby
+        )
       else
         context = ::Code::Object::Dictionnary.new
       end
 
+      if !context.is_a?(::Code::Object::Dictionnary)
+        raise ::Code::Error::IncompatibleContext.new("context must be a dictionnary")
+      end
+
+      context = context.merge(ruby)
+
       ::Code::Node::Code.new(parsed).evaluate(context: context, io: io)
     end
   end
 
   private
 
-  attr_reader :input, :parsed, :timeout, :io
+  attr_reader :input, :parsed, :timeout, :io, :ruby
 end

data/lib/template/version.rb

@@ -1,3 +1,3 @@
 require_relative "../template"
 
-Template::Version = Gem::Version.new("0.3.1")
+Template::Version = Gem::Version.new("0.4.0")

data/lib/template-ruby.rb

@@ -11,3 +11,9 @@ loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
 loader.ignore("#{__dir__}/template-ruby.rb")
 loader.ignore("#{__dir__}/code-ruby.rb")
 loader.setup
+
+class Hash
+  def multi_fetch(*keys)
+    keys.map { |key| [key, fetch(key)] }.to_h
+  end
+end

data/lib/template.rb

@@ -1,7 +1,7 @@
 class Template
   DEFAULT_TIMEOUT = 10
 
-  def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT)
+  def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT, ruby: {})
     @input = input
     @parsed =
       Timeout.timeout(timeout) do
@@ -9,24 +9,39 @@ class Template
       end
     @io = io
     @timeout = timeout || DEFAULT_TIMEOUT
+    @ruby = ::Code::Ruby.to_code(ruby || {})
   end
 
-  def self.render(input, context = "", io: StringIO.new, timeout: DEFAULT_TIMEOUT)
-    new(input, io: io, timeout: timeout).render(context)
+  def self.render(
+    input,
+    context = "",
+    io: StringIO.new,
+    timeout: DEFAULT_TIMEOUT,
+    ruby: {}
+  )
+    new(input, io: io, timeout: timeout, ruby: ruby).render(context)
   end
 
   def render(context = "")
     Timeout.timeout(timeout) do
       if context.present?
-        context = ::Code.evaluate(context, timeout: timeout)
+        context = ::Code.evaluate(
+          context,
+          timeout: timeout,
+          io: io,
+          ruby: ruby
+        )
       else
         context = ::Code::Object::Dictionnary.new
       end
 
-      ::Template::Node::Template.new(parsed).evaluate(
-        context: context,
-        io: io,
-      )
+      if !context.is_a?(::Code::Object::Dictionnary)
+        raise ::Code::Template::IncompatibleContext.new("context must be a dictionnary")
+      end
+
+      context = context.merge(ruby)
+
+      ::Template::Node::Template.new(parsed).evaluate(context: context, io: io)
 
       io.is_a?(StringIO) ? io.string : nil
     end
@@ -34,7 +49,7 @@ class Template
 
   private
 
-  attr_reader :parsed, :io, :timeout
+  attr_reader :parsed, :io, :timeout, :ruby
 end
 
 require_relative "template/version"

data/spec/code/parser/string_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe Code::Parser::String do
     "'\\u0123\\u4567\\u89aA\\ubBcC\\UdDeE\\ufFfF'",
     ":asc",
     "'1 + 1 = {1 + 1}'",
-    "'a + b = {'{'a'}{'b'}'}'"
+    "'a + b = {'{'a'}{'b'}'}'",
   ].each do |input|
     context input.inspect do
       let(:input) { input }

data/spec/code_spec.rb

@@ -1,7 +1,15 @@
 require "spec_helper"
 
 RSpec.describe Code do
-  subject { described_class.evaluate(input).to_s }
+  let!(:input) { "" }
+  let!(:context) { "" }
+  let!(:io) { StringIO.new }
+  let!(:timeout) { 0.1 }
+  let!(:ruby) { {} }
+
+  subject do
+    Code.evaluate(input, context, io: io, timeout: timeout, ruby: ruby).to_s
+  end
 
   [
     ["nothing", ""],
@@ -108,6 +116,7 @@ RSpec.describe Code do
     ["1.0 << 1", "2"],
     ["1 << 1.0", "2"],
     ["1.0 << 1.0", "2"],
+    ["eval('1 + 1')", "2"],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }
@@ -117,4 +126,57 @@ RSpec.describe Code do
       end
     end
   end
+
+  context "with ruby" do
+    context "with a constant" do
+      let!(:input) { "a + a" }
+      let!(:ruby) { { a: 1 } }
+
+      it "can access a" do
+        expect(subject).to eq("2")
+      end
+    end
+
+    context "with a function without arguments" do
+      let!(:input) { "a + a" }
+      let!(:ruby) { { a: ->{ "hello" } } }
+
+      it "can call a" do
+        expect(subject).to eq("hellohello")
+      end
+    end
+
+    context "with a function with regular arguments" do
+      let!(:input) { "add(1, 2)" }
+      let!(:ruby) { { add: ->(a, b){ a + b } } }
+
+      it "can call add" do
+        expect(subject).to eq("3")
+      end
+    end
+
+    context "with a function with keyword arguments" do
+      let!(:input) { "add(a: 1, b: 2)" }
+      let!(:ruby) { { add: ->(a:, b:){ a + b } } }
+
+      it "can call add" do
+        expect(subject).to eq("3")
+      end
+    end
+
+    context "with a complex function" do
+      let!(:input) { "add(1, 1, 1, 1, c: 1, d: 1, e: 1)" }
+      let!(:ruby) do
+        {
+          add: ->(a, b = 1, *args, c:, d: 2, **kargs){
+            a + b + args.sum + c + d + kargs.values.sum
+          }
+        }
+      end
+
+      it "can call add" do
+        expect(subject).to eq("7")
+      end
+    end
+  end
 end

data/spec/template_spec.rb

@@ -1,7 +1,11 @@
 require "spec_helper"
+require "prime"
 
 RSpec.describe Template do
-  subject { described_class.render(input, input_context) }
+  let!(:ruby) { {} }
+  let!(:input_context) { "" }
+  let!(:timeout) { 0 }
+  subject { Template.render(input, input_context, ruby: ruby, timeout: timeout) }
 
   [
     ["Hello World", "", "Hello World"],
@@ -12,13 +16,10 @@ RSpec.describe Template do
       '{ user: { first_name: "Dorian" } }',
       "Hello Dorian",
     ],
-    [
-      "{add(1, 2)",
-      'add = (a, b) => { a + b } { add: context(:add) }',
-      "3",
-    ],
+    ["{add(1, 2)", "add = (a, b) => { a + b } { add: context(:add) }", "3"],
     ["Hello {", "", "Hello "],
     ["{{a: 1}.each { |k, v| print(k) } nothing", "", "a"],
+    ["{{a: 1}.each { |k, v| puts(k) } nothing", "", "a\n"],
     ["", "", ""],
   ].each do |(input, input_context, expected)|
     context "#{input.inspect} #{input_context.inspect}" do
@@ -30,4 +31,22 @@ RSpec.describe Template do
       end
     end
   end
+
+  context "with a function from ruby" do
+    let!(:ruby) { { prime: ->(n){ n.prime? } } }
+    let!(:input) { "{prime(19201)" }
+
+    it "calls the ruby function" do
+      expect(subject).to eq("false")
+    end
+  end
+
+  context "with a function from ruby in an object" do
+    let!(:ruby) { { Prime: { prime: ->(n){ n.prime? } } } }
+    let!(:input) { "{Prime.prime(19201)" }
+
+    it "calls the ruby function" do
+      expect(subject).to eq("false")
+    end
+  end
 end

data/template-ruby.gemspec

@@ -18,7 +18,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