code-ruby 0.8.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5dda57442d7fc50b08ceb9998021e623f226a0b8de3cdaf58fecd05d0ba3a30
-  data.tar.gz: bead8ebd992882ea955f10d24e10f110a5c9955926e0e4850cddbcb4e3afe34c
+  metadata.gz: 53b06f45f6875d9e78c0554c660567fcfc7837b2e3fc3bfa8f3773bbdf133831
+  data.tar.gz: 894638c2797c729099e577a8c7f10d21990d291a0cc2376760f5e61d58f0c6e4
 SHA512:
-  metadata.gz: 136c900a7f0efab8fbf2ada6bc90c018689f5545b350b1b3b77c19e07ebd2eb18addb6852a12ede8c7bb692ad48af341c9decab8740b26d92fd5f45ec2a5ffa6
-  data.tar.gz: 24881df454cb5e179265232a37c45a1d1322ed0606ed3caf82fc56ee3526df1b3dc3c1f06301f5887e48b5da65e2b01b9c4e8424c703ab47923325c3b5ee1d6f
+  metadata.gz: 387dde40ad9948f938cdaea2a94dfcaabe4e94cef99f8941340184287a8b79efcd378f1012d3a0b4215b394090efc51368b9770429a5b60e63804721487c3546
+  data.tar.gz: a5939cfca0ff262ac86075c141cb133b39126f0f99f61b4715a018e3f746a45513dce30b4a45520a5f95117cbd67716a6984236199ef45b6d527853a31dae3f0

data/Gemfile.lock

@@ -1,9 +1,10 @@
 PATH
   remote: .
   specs:
-    code-ruby (0.8.4)
+    code-ruby (0.9.0)
       activesupport (~> 7)
       bigdecimal (~> 3)
+      json (~> 2)
       language-ruby (~> 0)
       zeitwerk (~> 2)
 
@@ -29,6 +30,7 @@ GEM
       ruby2_keywords
     i18n (1.14.1)
       concurrent-ruby (~> 1.0)
+    json (2.7.1)
     language-ruby (0.6.2)
       zeitwerk (~> 2)
     minitest (5.22.2)
@@ -45,7 +47,7 @@ GEM
     rspec-mocks (3.13.0)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-support (3.13.0)
+    rspec-support (3.13.1)
     ruby-prof (1.7.0)
     ruby2_keywords (0.0.5)
     tzinfo (2.0.6)

data/README.md

@@ -1,7 +1,3 @@
 # code-ruby
 
 A programming language, like `Code.evaluate("1 + 1") # => 2`
-
-TODO
-
-- [ ] `code` command

data/code-ruby.gemspec

@@ -10,14 +10,15 @@ Gem::Specification.new do |s|
   s.description = 'A programming language, like Code.evaluate("1 + 1") # => 2'
   s.authors = ["Dorian Marié"]
   s.email = "dorian@dorianmarie.fr"
-  s.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  s.files = `git ls-files`.lines.map(&:strip)
   s.require_paths = ["lib"]
   s.homepage = "https://github.com/dorianmariecom/code-ruby"
   s.license = "MIT"
   s.executables = "code"
 
+  s.add_dependency "activesupport", "~> 7"
   s.add_dependency "bigdecimal", "~> 3"
+  s.add_dependency "json", "~> 2"
   s.add_dependency "language-ruby", "~> 0"
-  s.add_dependency "activesupport", "~> 7"
   s.add_dependency "zeitwerk", "~> 2"
 end

data/lib/code/object/integer.rb

@@ -6,15 +6,11 @@ class Code
       attr_reader :raw
 
       def initialize(whole, exponent: nil)
+        whole = whole.raw if whole.is_a?(Integer)
         @raw = whole.to_i
-
         return unless exponent
-
-        unless exponent.is_a?(Number)
-          raise Code::Error::TypeError, "exponent is not a number"
-        end
-
-        @raw *= 10**exponent.raw
+        exponent = exponent.raw if exponent.is_a?(Number)
+        @raw *= 10**exponent
       end
 
       def self.name

data/lib/code/object/time.rb

@@ -8,7 +8,10 @@ class Code
       attr_reader :raw
 
       def initialize(time)
-        @raw = time
+        ::Time.zone ||= DEFAULT_ZONE
+        time = time.raw if time.is_a?(Time)
+        time = time.to_s if time.is_a?(::Time)
+        @raw = ::Time.zone.parse(time)
       end
 
       def self.name

data/lib/code/version.rb

@@ -2,4 +2,4 @@
 
 require_relative "../code"
 
-Code::Version = Gem::Version.new("0.8.4")
+Code::Version = Gem::Version.new("0.9.0")

data/lib/code.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 class Code
-  EMPTY_STRING = ""
   GLOBALS = %i[output error context object].freeze
   DEFAULT_TIMEOUT = 0
 
@@ -9,50 +8,35 @@ class Code
     input,
     output: StringIO.new,
     error: StringIO.new,
-    timeout: DEFAULT_TIMEOUT,
-    ruby: {}
+    timeout: DEFAULT_TIMEOUT
   )
     @input = input
-    @parsed = Timeout.timeout(timeout) { ::Code::Parser.parse(input).to_raw }
     @output = output
     @error = error
     @timeout = timeout || DEFAULT_TIMEOUT
-    @ruby = ::Code::Ruby.to_code(ruby || {}).code_to_context
+    @context = Object::Context.new
   end
 
   def self.evaluate(
     input,
-    context = EMPTY_STRING,
     output: StringIO.new,
     error: StringIO.new,
-    timeout: DEFAULT_TIMEOUT,
-    ruby: {}
+    timeout: DEFAULT_TIMEOUT
   )
-    new(input, output:, error:, timeout:, ruby:).evaluate(context)
+    new(input, output:, error:, timeout:).evaluate
   end
 
-  def evaluate(context = EMPTY_STRING)
+  def evaluate
     Timeout.timeout(timeout) do
-      context =
-        if context == EMPTY_STRING
-          Object::Context.new
-        else
-          Code.evaluate(
-            context,
-            timeout:,
-            output:,
-            error:,
-            ruby:
-          ).code_to_context
-        end
-
-      context = ruby.merge(context)
-
-      Node::Code.new(parsed).evaluate(context:, output:, error:)
+      Node::Code.new(::Code::Parser.parse(input).to_raw).evaluate(
+        context:,
+        output:,
+        error:
+      )
     end
   end
 
   private
 
-  attr_reader :input, :parsed, :timeout, :output, :error, :ruby
+  attr_reader :input, :timeout, :output, :error, :context
 end

data/spec/code/object/dictionary_spec.rb

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

data/spec/code/object/string_spec.rb

@@ -2,12 +2,12 @@ require "spec_helper"
 
 RSpec.describe Code::Object::String do
   [
-    [":a", "a"],
-    [":a_b_c_0123", "a_b_c_0123"],
-    ['"Hello"', "Hello"],
-    ["'Hello'", "Hello"],
+    %w[:a a],
+    %w[:a_b_c_0123 a_b_c_0123],
+    %w["Hello" Hello],
+    %w['Hello' Hello],
     ['"Hello\nWorld"', "Hello\nWorld"],
-    ["'Hello\\nWorld'", "Hello\nWorld"],
+    ["'Hello\\nWorld'", "Hello\nWorld"]
   ].each do |input, expected|
     it "(#{input}).to_s == #{expected.inspect}" do
       expect(Code.evaluate(input).to_s).to eq(expected)

data/spec/code_spec.rb

@@ -57,14 +57,14 @@ RSpec.describe Code do
     ["1 >> 1", "0"],
     ["1 ^ 2", "3"],
     ["1 | 2", "3"],
-    ["1.day.ago.after?(1.day.from_now)", 'false'],
-    ["1.day.ago.before?(1.day.from_now)", 'true'],
-    ["1.day.from_now.after?(1.day.ago)", 'true'],
-    ["1.day.from_now.before?(1.day.ago)", 'false'],
-    ["1.day.ago.after?", 'false'],
-    ["1.day.ago.before?", 'true'],
-    ["1.day.from_now.after?", "true"],
-    ["1.day.from_now.before?", "false"],
+    %w[1.day.ago.after?(1.day.from_now) false],
+    %w[1.day.ago.before?(1.day.from_now) true],
+    %w[1.day.from_now.after?(1.day.ago) true],
+    %w[1.day.from_now.before?(1.day.ago) false],
+    %w[1.day.ago.after? false],
+    %w[1.day.ago.before? true],
+    %w[1.day.from_now.after? true],
+    %w[1.day.from_now.before? false],
     ["2 * 3 + 2", "8"],
     ["2 * 3", "6"],
     ["2 ** 3 ** 2", "512"],
@@ -141,13 +141,26 @@ RSpec.describe Code do
     ['"Hello {1}"', '"Hello 1"'],
     ['user = {} user.name = "Dorian" user.name', ":Dorian"],
     ['user = {} user[:name] = "Dorian" user[:name]', ":Dorian"],
-    ['{ "first_name": "Dorian" }', '{"first_name" => "Dorian"}'],
+    ['{ "first_name": "Dorian" }', '{"first_name" => "Dorian"}']
   ].each do |input, expected|
     it "#{input} == #{expected}" do
       expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
     end
   end
 
+  %w[
+    1.day.ago
+    1.day.from_now
+    1.hour.ago
+    1.hour.from_now
+    2.days.ago
+    2.days.from_now
+    2.hours.ago
+    2.hours.from_now
+    Date.tomorrow
+    Time.tomorrow
+  ].each { |input| it(input) { Code.evaluate(input) } }
+
   [["puts(true)", "true\n"], %w[print(false) false]].each do |input, expected|
     it "#{input} prints #{expected}" do
       output = StringIO.new
@@ -155,62 +168,4 @@ RSpec.describe Code do
       expect(output.string).to eq(expected)
     end
   end
-
-  it "converts nil" do
-    ruby = Code::Ruby.from_code(Code.evaluate("a", ruby: { a: nil }))
-
-    expect(ruby).to eq(nil)
-  end
-
-  it "works with downcase" do
-    expect(Code.evaluate("downcase", "{ downcase: 1 }")).to eq(
-      Code.evaluate("1")
-    )
-  end
-
-  describe "#fetch" do
-    it "returns the value when present" do
-      expect(Code.evaluate("fetch(:downcase)", "{ downcase: 1 }")).to eq(
-        Code.evaluate("1")
-      )
-    end
-
-    it "returns the default value when not present" do
-      expect(Code.evaluate("fetch(:downcase) { 2 }")).to eq(
-        Code.evaluate("2")
-      )
-    end
-  end
-
-  it "works with nested objects" do
-    expect(
-      Code.evaluate("items.first.title", ruby: { items: [{ title: "Hello" }] })
-    ).to eq(Code.evaluate(":Hello"))
-  end
-
-  it "works with arrays" do
-    expect(
-      Code.evaluate(
-        "items.map { |item| item.title }",
-        ruby: {
-          items: [{ title: "Hello" }]
-        }
-      )
-    ).to eq(Code.evaluate("[:Hello]"))
-  end
-
-  [
-    "1.day.ago",
-    "1.day.from_now",
-    "1.hour.ago",
-    "1.hour.from_now",
-    "2.days.ago",
-    "2.days.from_now",
-    "2.hours.ago",
-    "2.hours.from_now",
-    "Date.tomorrow",
-    "Time.tomorrow",
-  ].each do |input|
-    it(input) { Code.evaluate(input) }
-  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.9.0
 platform: ruby
 authors:
 - Dorian Marié
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-26 00:00:00.000000000 Z
+date: 2024-02-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: bigdecimal
   requirement: !ruby/object:Gem::Requirement
@@ -25,33 +39,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
-  name: language-ruby
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: language-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -130,7 +144,6 @@ files:
 - lib/code/object/nothing.rb
 - lib/code/object/number.rb
 - lib/code/object/range.rb
-- lib/code/object/ruby_function.rb
 - lib/code/object/string.rb
 - lib/code/object/time.rb
 - lib/code/parser.rb
@@ -174,7 +187,6 @@ files:
 - lib/code/parser/unary_minus.rb
 - lib/code/parser/while.rb
 - lib/code/parser/whitespace.rb
-- lib/code/ruby.rb
 - lib/code/type.rb
 - lib/code/type/hash.rb
 - lib/code/type/maybe.rb

data/lib/code/object/ruby_function.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-class Code
-  class Object
-    class RubyFunction < Function
-      attr_reader :raw
-
-      def initialize(raw)
-        @raw = raw
-      end
-
-      def self.name
-        "RubyFunction"
-      end
-
-      # TODO: fix / refactor
-      def code_call(args:, globals:)
-        regular_arguments =
-          args
-            .select(&:regular?)
-            .map(&:value)
-            .map { |argument| Ruby.from_code(argument) }
-
-        keyword_arguments =
-          args
-            .select(&:keyword?)
-            .map do |argument|
-              [argument.name.to_sym, Ruby.from_code(argument.value)]
-            end
-            .to_h
-
-        Ruby.to_code(raw.call(*regular_arguments, **keyword_arguments))
-      end
-    end
-  end
-end

data/lib/code/ruby.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-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 nil?
-        ::Code::Object::Nothing.new
-      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::Dictionary.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 { |element| ::Code::Ruby.to_code(element) }
-        )
-      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_nothing? || code_boolean? || code_decimal? || code_integer? ||
-             code_range? || code_string?
-          raw.raw
-        elsif code_dictionnary?
-          raw
-            .raw
-            .map do |key, value|
-              [::Code::Ruby.from_code(key), ::Code::Ruby.from_code(value)]
-            end
-            .to_h
-        elsif code_list?
-          raw.raw.map { |element| ::Code::Ruby.from_code(element) }
-        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 nil?
-      raw.is_a?(::NilClass)
-    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_nothing?
-      raw.is_a?(::Code::Object::Nothing)
-    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_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::Dictionary)
-    end
-
-    def code_list?
-      raw.is_a?(::Code::Object::List)
-    end
-  end
-end