code-ruby 0.5.6 → 0.6.1

data/lib/code/type.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Code
+  class Type
+    def name
+      raise NotImplementedError, "#{self.class}#name"
+    end
+
+    def valid?(argument)
+      raise NotImplementedError, "#{self.class}#valid?"
+    end
+
+    def valid_for?(expected:, actual:)
+      expected.is_a?(Type) ? expected.valid?(actual) : actual.is_a?(expected)
+    end
+
+    def min_arguments_of(clazz)
+      clazz.is_a?(Type) ? clazz.min_arguments : 1
+    end
+
+    def max_arguments_of(clazz)
+      clazz.is_a?(Type) ? clazz.max_arguments : 1
+    end
+  end
+end

data/lib/code/version.rb

@@ -0,0 +1,3 @@
+require_relative "../code"
+
+Code::Version = Gem::Version.new("0.6.1")

data/lib/code-ruby.rb

@@ -2,9 +2,8 @@ require "bigdecimal"
 require "stringio"
 require "timeout"
 require "zeitwerk"
+require "language-ruby"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
-loader.ignore("#{__dir__}/template-ruby.rb")
 loader.ignore("#{__dir__}/code-ruby.rb")
-loader.ignore("#{__dir__}/language-ruby.rb")
 loader.setup

data/lib/code.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 class Code
   EMPTY_STRING = ""
-  GLOBALS = %i[io context object]
-  DEFAULT_TIMEOUT = Template::DEFAULT_TIMEOUT
+  GLOBALS = %i[io context object].freeze
+  DEFAULT_TIMEOUT = 0
 
   def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT, ruby: {})
     @input = input
     @parsed = Timeout.timeout(timeout) { ::Code::Parser.parse(@input).to_raw }
     @io = io
     @timeout = timeout || DEFAULT_TIMEOUT
-    @ruby = ::Code::Ruby.to_code(ruby || {})
+    @ruby = ::Code::Ruby.to_code(ruby || {}).code_to_context
   end
 
   def self.evaluate(
@@ -18,26 +20,23 @@ class Code
     timeout: DEFAULT_TIMEOUT,
     ruby: {}
   )
-    new(input, io: io, timeout: timeout, ruby: ruby).evaluate(context)
+    new(input, io:, timeout:, ruby:).evaluate(context)
   end
 
   def evaluate(context = "")
     Timeout.timeout(timeout) do
-      if context != EMPTY_STRING
-        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 =
+        if context == EMPTY_STRING
+          Object::Context.new
+        else
+          Code.evaluate(context, timeout:, io:, ruby:).code_to_context
+        end
+
+      raise(Error::IncompatibleContext) unless context.is_a?(Object::Context)
 
       context = context.merge(ruby)
 
-      ::Code::Node::Code.new(parsed).evaluate(context: context, io: io)
+      Node::Code.new(parsed).evaluate(context:, io:)
     end
   end
 

data/spec/code/node/call_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Node::Call do
+=begin
+  let(:context) { <<~CONTEXT }
+    render = (*args, **kargs, &block) => {
+      [args, kargs, block&.call(:dorian)]
+    }
+
+    { render:, user: { name: :Dorian } }"
+  CONTEXT
+
+  [
+    ["render", "[[], {}, nothing]"],
+    ["render()", "[[], {}, nothing]"],
+    ["render(user)", "[[user], {}, nothing]"],
+    [
+      "render(user, first_name: :Dorian)",
+      "[[user], { first_name: :Dorian }, nothing]"
+    ],
+    ["render { }", "[[], {}, nothing]"],
+    ["render do end", "[[], {}, nothing]"],
+    ["render { |name| name.upcase }", "[[], {}, :Dorian]"],
+    ["render(user) { |name| name.upcase }", "[[user], {}, :Dorian]"],
+    ["render(user) do |name| name.upcase end", "[[user], {}, :Dorian]"],
+    ["render { :Dorian }", "[[], {}, :Dorian]"],
+    ["render(user) { :Dorian }", "[[user], {}, :Dorian]"],
+    ["render(user) do :Dorian end", "[[user], {}, :Dorian]"]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input, context)).to eq(
+        Code.evaluate(expected, context)
+      )
+    end
+  end
+=end
+end

data/spec/code/object/boolean_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Object::Boolean do
+  [
+    ["true & false", "false"],
+    %w[true.bitwise_and(false) false],
+    ["true | false", "true"],
+    %w[true.bitwise_or(false) true],
+    ["true ^ false", "true"],
+    %w[true.bitwise_xor(false) true]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
+    end
+  end
+end

data/spec/code/object/decimal_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Object::Decimal do
+  [
+    ["10.2 % 5.1", "0"],
+    ["5.5 * 2.5", "13.75"],
+    ["1.5 ** 2", "2.25"],
+    ["1.5 + 1.5", "3"],
+    ["1.5 - 0.5", "1"],
+    %w[-1.5 -3/2],
+    ["1.5 / 2", "0.75"],
+    ["1.1 < 1.2", "true"],
+    ["1.1 <= 1.1", "true"],
+    ["1.1 <=> 1.2", "-1"],
+    ["1.1 > 0.9", "true"],
+    ["1.1 >= 1.1", "true"],
+    ["1.1 === 1.1", "true"],
+    %w[-1.1.abs 1.1],
+    %w[-1.1.ceil -1],
+    %w[-1.123.ceil(2) -1.12],
+    %w[-1.1.floor -2],
+    %w[-1.123.floor(2) -1.13],
+    %w[1.1.round 1],
+    %w[1.123.round(2) 1.12],
+    %w[1.2.clone 1.2],
+    %w[0.0.zero? true],
+    %w[1.2.truncate 1],
+    %w[1.234.truncate(2) 1.23],
+    %w[1.2.to_string "1.2"],
+    %w[1.2.to_integer 1],
+    %w[1.2.to_decimal 1.2],
+    %w[4.0.sqrt 2.0],
+    %w[0.0.zero? true],
+    %w[1.0.one? true],
+    %w[2.0.two? true],
+    %w[3.0.three? true],
+    %w[4.0.four? true],
+    %w[5.0.five? true],
+    %w[6.0.six? true],
+    %w[7.0.seven? true],
+    %w[8.0.eight? true],
+    %w[9.0.nine? true],
+    %w[10.0.ten? true]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
+    end
+  end
+end

data/spec/code/object/dictionary_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Object::Dictionary do
+  let(:context) { '{ first_name: "Dorian", language: :code }' }
+
+  [
+    ["{} == {}", "true"],
+    ['{ "name" => "Dorian" } == { name: :Dorian }', "true"],
+    %w[context.first_name :Dorian],
+    ["context[:first_name]", ":Dorian"],
+    %w[context.language :code],
+    ["context > { first_name: :Dorian", "true"],
+    ["{ first_name: :Dorian } < context", "true"],
+    ["context <= context", "true"],
+    ["context >= {}", "true"],
+    ["context <=> context", "0"],
+    ["context === context", "true"],
+    ["{ first_name: :Dorian }.any? { |_, value| value == :Dorian }", "true"],
+    %w[context.any?(String) true],
+    ["{ a: nothing }.compact", "{}"],
+    ["d = { a: nothing } d.compact! d", "{}"],
+    %w[context.dig(:first_name) :Dorian],
+    %w[context.empty? false],
+    %w[context.truthy? true],
+    %w[context.falsy? false],
+    %w[context.fetch(:first_name) :Dorian],
+    ["context.fetch(:unknown) { :Good }", ":Good"],
+    ["context.fetch(:first_name, :language)", "context"],
+    [
+      "context.fetch(:first_name, :last_name) { :Marié }",
+      "{ first_name: :Dorian, last_name: :Marié }"
+    ],
+    ["context.delete(:last_name) { true }", "true"],
+    [
+      "context.delete(:first_name, :language)",
+      "{ first_name: :Dorian, language: :code }"
+    ],
+    ["{ first_name: :Dorian }.delete_if(String)", "{}"],
+    ["{ age: 31 }.delete_unless(Number)", "{ age: 31 }"],
+    ["{ age: 31 }.delete_unless(Integer)", "{ age: 31 }"],
+    ["{ first_name: :Dorian }.delete_if { |_, value| value == :Dorian }", "{}"],
+    ["{ age: 31 }.delete_unless { |key| key == :age }", "{ age: 31 }"],
+    ["{ first_name: :Dorian }.keep_if(String)", "{ first_name: :Dorian }"],
+    ["{ age: 31 }.keep_unless(Number)", "{}"],
+    ["{ age: 31 }.keep_unless(Integer)", "{}"],
+    ["{ first_name: :Dorian }.keep_if { |_, value| value != :Dorian }", "{}"],
+    ["{ age: 31 }.keep_unless { |key| key == :age }", "{}"],
+    ["context.except(:first_name, :language)", "{}"],
+    ["context.fetch_values(:first_name, :language)", "[:Dorian, :code]"],
+    ["context.fetch_values(:first_name)", "[:Dorian]"],
+    %w[context.select(String) context],
+    %w[context.select(Integer) {}],
+    ["context.select(Integer) context", "context"],
+    %w[context.select!(Integer) {}],
+    ["context.select!(Integer) context", "{}"],
+    [
+      "context.select { |key, value, dictionnary, index| key == :first_name }",
+      "{ first_name: :Dorian }"
+    ],
+    [
+      "context.select { |key, value, dictionnary, index| value == :Dorian }",
+      "{ first_name: :Dorian }"
+    ],
+    [
+      "context.select { |key, value, dictionnary, index| dictionnary.two? }",
+      "context"
+    ],
+    [
+      "context.select { |key, value, dictionnary, index| index.zero? }",
+      "{ first_name: :Dorian }"
+    ],
+    ["{ a: 1, b: [2, 3] }.to_list", "[[:a, 1], [:b, [2, 3]]]"],
+    ["{ a: 1, b: [2, 3] }.flatten", "[:a, 1, :b, 2, 3]"],
+    ["{ a: 1, b: [2, 3] }.flatten(0)", "[[:a, 1], [:b, [2, 3]]]"],
+    ["{ a: 1, b: [2, 3] }.flatten(1)", "[:a, 1, :b, [2, 3]]"],
+    ["{ a: 1, b: [2, 3] }.flatten(-1)", "[:a, 1, :b, 2, 3]"],
+    %w[context.has_key?(:first_name) true],
+    %w[context.has_key?(:unknown) false],
+    %w[context.has_value?(:Dorian) true],
+    %w[context.has_value?(:Unknown) false],
+    ["context.invert", "{ Dorian: :first_name, code: :language }"],
+    %w[context.key(:Dorian) :first_name],
+    %w[context.key(:Unknown) nothing],
+    ["context.key(:Unknown) { true }", "true"],
+    ["{ a: 1 }.merge(b: 2)", "{ a: 1, b: 2 }"],
+    ["{ a: 1 }.merge({ b: 2 })", "{ a: 1, b: 2 }"],
+    ["{ a: 1 }.merge({ a: 2 })", "{ a: 2 }"],
+    ["{ a: 1 }.merge({ a: 2 }) { |_, old, new| old + new }", "{ a: 3 }"]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input, context)).to eq(
+        Code.evaluate(expected, context)
+      )
+    end
+  end
+end

data/spec/code/object/function_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Object::Function do
+=begin
+  [
+    ["even? = (i) => { i.even? } even?(2)", "true"],
+    ["even? = (i:) => { i.even? } even?(i: 2)", "true"],
+    ["add = (a, b) => { a + b } add(1, 2)", "3"],
+    ["minus = (a:, b:) => { a - b } minus(b: 1, a: 2)", "1"]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
+    end
+  end
+=end
+
+  context "valid" do
+    [
+      "f = () => {} f",
+      "f = (x) => {} f(1)",
+#      "f = (x:) => {} f(x: 1)"
+    ].each do |input|
+      it "#{input} is valid" do
+        Code.evaluate(input)
+      end
+    end
+  end
+
+  context "invalid" do
+    [
+      "f = (x) => {} f",
+      "f = (x:) => {} f(1)",
+      "f = (x:) => {} f(y: 1)"
+    ].each do |input|
+      it "#{input} is invalid" do
+        expect { Code.evaluate(input) }.to raise_error(Code::Error)
+      end
+    end
+  end
+end

data/spec/code/object/integer_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Object::Integer do
+  [
+    ["10 % 5", "0"],
+    ["5 * 2", "10"],
+    ["2 ** 2", "4"],
+    ["1 + 1", "2"],
+    ["1 - 0", "1"],
+    ["-1", "1 - 2"],
+    ["1 / 2", "0.5"],
+    ["1 < 2", "true"],
+    ["1 <= 1", "true"],
+    ["1 <=> 2", "-1"],
+    ["1 > 0", "true"],
+    ["1 >= 1", "true"],
+    ["1 === 1", "true"],
+    %w[-1.abs 1],
+    %w[-1.ceil -1],
+    %w[1234.ceil(-2) 1300],
+    %w[-1.floor -1],
+    %w[1234.floor(-2) 1200],
+    %w[1.round 1],
+    %w[1234.round(-2) 1200],
+    %w[1.clone 1],
+    %w[0.zero? true],
+    %w[1.truncate 1],
+    %w[1234.truncate(-2) 1200],
+    %w[1.to_string :1],
+    %w[1.to_integer 1],
+    %w[1.to_decimal 1.0],
+    %w[4.sqrt 2.0],
+    ["1 + 2", "3"],
+    ["2 - 1", "1"],
+    ["a = 2 - 1 a", "1"]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
+    end
+  end
+end

data/spec/code/object/nothing_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Object::Nothing do
+  [
+    %w[nothing nothing],
+    ["nothing nothing", "nothing"]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
+    end
+  end
+end

data/spec/code/object/range_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Object::Range do
+  [
+    %w[(0..1).any?(&:even?) true],
+    %w[(0..1).all?(&:even?) false],
+    ["a = 0 (0..1).each { a += 1 } a", "2"],
+    ["(0..1).select(&:even?)", "[0]"],
+    ["(0..1).map(&:increment)", "[1, 2]"],
+    ["(0..10).step(3)", "[0, 3, 6, 9]"],
+    ["(0...9).step(3)", "[0, 3, 6]"],
+    ["(0..1).to_list", "[0, 1]"],
+    ["(0...1).to_list", "[0]"],
+    %w[(0..1).first 0],
+    %w[(0..1).last 1]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
+    end
+  end
+end

data/spec/code/parser/boolean_spec.rb

@@ -1,16 +1,11 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe Code::Parser::Boolean do
-  subject { Code::Parser.parse(input) }
-
-  [
-    ["true", [{ boolean: "true" }]],
-    ["false", [{ boolean: "false" }]]
-  ].each do |input, output|
-    context input.inspect do
-      let(:input) { input }
-
-      it { expect(subject).to eq(output) }
+  [%w[true !false], %w[false !true]].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
     end
   end
 end

data/spec/code/parser/chained_call.rb

@@ -1,17 +1,16 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe Code::Parser::ChainedCall do
-  subject { Code::Parser.parse(input) }
-
   [
     "a.b",
     "user.first_name",
     "user.admin?",
     'user.update!(name: "Dorian")'
   ].each do |input|
-    context input do
-      let(:input) { input }
-      it { subject }
+    it "parses #{input}" do
+      Code::Parser.parse(input)
     end
   end
 end

data/spec/code/parser/{dictionnary_spec.rb → dictionary_spec.rb}

@@ -1,8 +1,8 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-RSpec.describe Code::Parser::Dictionnary do
-  subject { Code::Parser.parse(input) }
+require "spec_helper"
 
+RSpec.describe Code::Parser::Dictionary do
   [
     "{}",
     "{ }",
@@ -10,9 +10,8 @@ RSpec.describe Code::Parser::Dictionnary do
     "{ a: 1, b: 2, c: 3 }",
     '{ "first_name": "Dorian" }'
   ].each do |input|
-    context input do
-      let(:input) { input }
-      it { subject }
+    it "parses #{input}" do
+      Code::Parser.parse(input)
     end
   end
 end

data/spec/code/parser/function_spec.rb

@@ -1,16 +1,15 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe Code::Parser::Function do
-  subject { Code::Parser.parse(input) }
-
   [
     "() => {}",
     "(a, b) => { add(a, b) }",
     "(a:, b:) => { add(a, b) }"
   ].each do |input|
-    context input do
-      let(:input) { input }
-      it { subject }
+    it "parses #{input}" do
+      Code::Parser.parse(input)
     end
   end
 end

data/spec/code/parser/group_spec.rb

@@ -1,18 +1,11 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe Code::Parser::Group do
-  subject { Code::Parser.parse(input) }
-
-  [
-    [
-      "(true (nothing))",
-      [{ group: [{ boolean: "true" }, { group: [{ nothing: "nothing" }] }] }]
-    ]
-  ].each do |input, output|
-    context input.inspect do
-      let(:input) { input }
-
-      it { expect(subject).to eq(output) }
+  ["(true (nothing))"].each do |input|
+    it "parses #{input}" do
+      Code::Parser.parse(input)
     end
   end
 end

data/spec/code/parser/if_modifier_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Code::Parser::IfModifier do
+  [
+    ["1 if true", "1"],
+    ["1 if false", "nothing"],
+    ["1 unless true", "nothing"],
+    ["1 unless false", "1"],
+    ["a = 0 a += 1 while a < 10 a", "10"],
+    ["a = 0 a += 1 until a > 10 a", "11"]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
+    end
+  end
+end

data/spec/code/parser/list_spec.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe Code::Parser::List do
-  subject { Code::Parser.parse(input) }
-
   [
     "[]",
     "[ ]",
@@ -10,9 +10,8 @@ RSpec.describe Code::Parser::List do
     "[1, 2, 3]",
     "['hello', 1, true, [false, nothing]]"
   ].each do |input|
-    context input do
-      let(:input) { input }
-      it { subject }
+    it "parses #{input}" do
+      Code::Parser.parse(input)
     end
   end
 end

data/spec/code/parser/number_spec.rb

@@ -1,12 +1,11 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe Code::Parser::Number do
-  subject { Code::Parser.parse(input) }
-
   %w[0 1 1.1 123.123 1_000.12_244 0xf0 0o70 0b10].each do |input|
-    context input do
-      let(:input) { input }
-      it { subject }
+    it "parses #{input}" do
+      Code::Parser.parse(input)
     end
   end
 end

data/spec/code/parser/string_spec.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe Code::Parser::String do
-  subject { Code::Parser.parse(input) }
-
   [
     "''",
     '""',
@@ -13,9 +13,8 @@ RSpec.describe Code::Parser::String do
     "'Hello {name}'",
     '"Hello {name}"'
   ].each do |input|
-    context input do
-      let(:input) { input }
-      it { subject }
+    it "parses #{input}" do
+      Code::Parser.parse(input)
     end
   end
 end