code-ruby 1.9.12 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a8c532c56c64f318cc116ef97c0bc587edde1f306d5f8e53d75be893bf38b1f
-  data.tar.gz: ffc94431ea3528b547ab9b76e03d4efea7f9e2281a30da04e7528ea881d2d308
+  metadata.gz: 289eba7ee8807b4660bba3a8df2458d5d7b615deea52b66b3475eb2c306aa9e9
+  data.tar.gz: 6394f2e3a44499cdf85ecb315d1a303a52df7784f8c385c76b170702298d7d3c
 SHA512:
-  metadata.gz: 468c2777dab28cabbff2e918d5ee3a9a5a417063be54ad44026d20a096d0f234c6ee7fb633c17d707dbaf565eb61614ea4d6d67bc3888aa8895d9df092c37a50
-  data.tar.gz: 1f29b8a374565925fcbdf636bf7a1d60f45a5d5a23ba4bf24550c4f2964f695ac4691d0ea60d25825bd5e487c18e05feb14eab0b2df37c1c0c1f054c7d012b4b
+  metadata.gz: 1bb7bf8488694f407300e3a18258601ada0eba25cd54ab8e0184a05889ac1171c87f5c62de341a26bae7876372cec80e194c82a993277b85fc8bc11d2bba10ef
+  data.tar.gz: bf4b7f896dc52eb6afabcc25e863d96fbf71a801bd469344887f7cff95d3879442757b3d0723a5d0594ee11aff671d78da4abdcfad0d889672f0e407c040fa95

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    code-ruby (1.9.12)
+    code-ruby (2.0.1)
       activesupport
       base64
       bigdecimal

data/VERSION

@@ -1 +1 @@
-1.9.12
+2.0.1

data/lib/code/node/call.rb

@@ -13,8 +13,8 @@ class Code
           @body = Code.new(parsed.delete(:body).presence)
         end
 
-        def evaluate(**_args)
-          Object::Function.new(@parameters, @body)
+        def evaluate(**args)
+          Object::Function.new(@parameters, @body, args.fetch(:context))
         end
       end
 
@@ -22,7 +22,9 @@ class Code
         return if parsed.blank?
 
         @name = parsed.delete(:name).presence
+        @explicit_arguments = parsed.key?(:arguments)
         @arguments = parsed.delete(:arguments).presence || []
+        @arguments = [@arguments] unless @arguments.is_a?(Array)
         @arguments.map! { |argument| CallArgument.new(argument) }
 
         return unless parsed.key?(:block)
@@ -52,6 +54,7 @@ class Code
         args.fetch(:object).call(
           operator: name,
           arguments: Object::List.new(arguments),
+          explicit_arguments: @explicit_arguments,
           **args
         )
       end

data/lib/code/node/code.rb

@@ -6,6 +6,7 @@ class Code
       def initialize(parsed)
         return if parsed.blank?
 
+        @parsed = parsed.deep_dup
         @statements =
           (parsed.presence || []).map { |statement| Statement.new(statement) }
       end
@@ -57,6 +58,10 @@ class Code
       def to_code
         @statements.blank? ? Object::Nothing.new : Object::Code.new(self)
       end
+
+      def to_raw
+        @parsed.deep_dup
+      end
     end
   end
 end

data/lib/code/node/function.rb

@@ -12,8 +12,8 @@ class Code
         @body = Code.new(parsed.delete(:body).presence)
       end
 
-      def evaluate(**_args)
-        Object::Function.new(@parameters, @body)
+      def evaluate(**args)
+        Object::Function.new(@parameters, @body, args.fetch(:context))
       end
     end
   end

data/lib/code/node/right_operation.rb

@@ -41,6 +41,10 @@ class Code
           right = @right&.evaluate(**args) || Object::Nothing.new
           left = @left&.resolve(**args) || Object::Nothing.new
 
+          if @operator != EQUAL && right.nothing?
+            return @left&.evaluate(**args) || Object::Nothing.new
+          end
+
           left.call(
             operator: @operator,
             arguments: Object::List.new([right]),

data/lib/code/object/class.rb

@@ -19,6 +19,10 @@ class Code
       def call(...)
         raw.call(...)
       end
+
+      def code_to_string
+        String.new(raw.name.to_s.split("::")[2..].join("::"))
+      end
     end
   end
 end

data/lib/code/object/dictionary.rb

@@ -542,7 +542,7 @@ class Code
           result = code_fetch(code_operator)
 
           if result.is_a?(Function)
-            result.call(**args, operator: nil)
+            result.call(**args, operator: nil, bound_self: self)
           else
             sig(args)
             result

data/lib/code/object/function.rb

@@ -3,9 +3,9 @@
 class Code
   class Object
     class Function < Object
-      attr_reader :code_parameters, :code_body
+      attr_reader :code_parameters, :code_body, :definition_context, :parent
 
-      def initialize(*args, **_kargs, &_block)
+      def initialize(*args, parent: nil, methods: nil, **_kargs, &_block)
         @code_parameters =
           List
             .new(args.first)
@@ -14,6 +14,10 @@ class Code
             .to_code
 
         @code_body = Code.new(args.second.presence)
+        @definition_context = args.third if args.third.is_a?(Context)
+        @parent = parent.to_code
+        self.methods = methods.to_code
+        self.methods = Dictionary.new if self.methods.nothing?
 
         self.raw = List.new([code_parameters, code_body])
       end
@@ -26,15 +30,52 @@ class Code
         case code_operator.to_s
         when "", "call"
           sig(args) { signature_for_call }
-          code_call(*code_arguments.raw, **globals)
+          code_call(
+            *code_arguments.raw,
+            explicit_arguments: args.fetch(:explicit_arguments, true),
+            **globals
+          )
+        when "extend"
+          sig(args) { Function }
+          code_extend(code_arguments.code_first)
+        when /=$/
+          sig(args) { Object }
+          code_set(code_operator.to_s.chop, code_value)
+        when ->(operator) { code_has_key?(operator).truthy? }
+          result = code_fetch(code_operator)
+
+          if result.is_a?(Function)
+            result.call(**args, operator: nil, bound_self: self)
+          else
+            sig(args)
+            result
+          end
         else
           super
         end
       end
 
-      def code_call(*arguments, **globals)
+      def code_call(*arguments, explicit_arguments: true, bound_self: nil, **globals)
         code_arguments = arguments.to_code
-        code_context = Context.new({}, globals[:context])
+        code_context = Context.new({}, definition_context || globals[:context])
+        code_self = bound_self.to_code
+        code_self = captured_self if code_self.nothing? && captured_self
+        code_self = Dictionary.new if code_self.nil? || code_self.nothing?
+
+        code_context.code_set("self", code_self)
+
+        if parent.is_a?(Function)
+          code_context.code_set(
+            "super",
+            Super.new(
+              parent,
+              code_arguments,
+              code_self,
+              definition_context || globals[:context],
+              explicit_arguments: explicit_arguments
+            )
+          )
+        end
 
         code_parameters.raw.each.with_index do |code_parameter, index|
           code_argument =
@@ -111,7 +152,89 @@ class Code
       end
 
       def code_to_string
-        String.new("<#{self.class.name} #{raw}>")
+        String.new(
+          Format.format(
+            [
+              {
+                function: {
+                  parameters: code_parameters.raw.map { |parameter| parameter_to_raw(parameter) },
+                  body: code_body.raw.to_raw
+                }
+              }
+            ]
+          )
+        )
+      end
+
+      def code_extend(function)
+        code_function = function.to_code
+
+        Function.new(
+          code_function.code_parameters,
+          code_function.code_body.raw,
+          code_function.definition_context,
+          parent: self,
+          methods: methods.code_deep_duplicate
+        )
+      end
+
+      def code_fetch(key)
+        methods.code_fetch(key)
+      end
+
+      def code_get(key)
+        methods.code_get(key)
+      end
+
+      def code_has_key?(key)
+        methods.code_has_key?(key)
+      end
+
+      def code_set(key, value)
+        methods.code_set(key, value)
+      end
+
+      private
+
+      def captured_self
+        self_from(definition_context)
+      end
+
+      def self_from(context)
+        return if context.blank?
+
+        current = context
+
+        while current
+          return current.code_fetch("self") if current.code_has_key?("self").truthy?
+
+          current = current.parent
+        end
+
+        nil
+      end
+
+      def parameter_to_raw(parameter)
+        code_parameter = parameter.to_code
+        raw_parameter = { name: code_parameter.code_name.to_s }
+
+        if code_parameter.keyword?
+          raw_parameter[:keyword] = ":"
+        elsif code_parameter.keyword_splat?
+          raw_parameter[:keyword_splat] = "**"
+        elsif code_parameter.regular_splat?
+          raw_parameter[:regular_splat] = "*"
+        elsif code_parameter.block?
+          raw_parameter[:block] = "&"
+        elsif code_parameter.spread?
+          raw_parameter[:spread] = "..."
+        end
+
+        unless code_parameter.code_default.nothing?
+          raw_parameter[:default] = code_parameter.code_default.code_to_string.raw == "nothing" ? [] : Code.parse(code_parameter.code_default.to_s)
+        end
+
+        raw_parameter
       end
     end
   end

data/lib/code/object/global.rb

@@ -199,7 +199,10 @@ class Code
           code_context = code_context.code_lookup!(code_operator)
           code_result = code_context.code_fetch(code_operator)
 
-          if code_result.is_a?(Function)
+          if code_result.is_a?(Super)
+            code_result.call(**args, operator: nil)
+          elsif code_result.is_a?(Function) &&
+                args.fetch(:explicit_arguments, false)
             code_result.call(**args, operator: nil)
           else
             sig(args)

data/lib/code/object/super.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class Super < Function
+      def initialize(
+        parent,
+        forwarded_arguments,
+        code_self,
+        definition_context,
+        explicit_arguments: false
+      )
+        @parent = parent.to_code
+        @forwarded_arguments = forwarded_arguments.to_code
+        @code_self = code_self.to_code
+        @definition_context = definition_context
+        self.methods = Dictionary.new
+        self.raw = @parent.raw
+      end
+
+      def call(**args)
+        code_arguments = args.fetch(:arguments, List.new).to_code
+        explicit_arguments = args.fetch(:explicit_arguments, false)
+
+        @parent.code_call(
+          *(arguments_for(code_arguments, explicit_arguments).raw),
+          explicit_arguments: explicit_arguments,
+          bound_self: @code_self,
+          **multi_fetch(args, *GLOBALS).merge(context: parent_context)
+        )
+      end
+
+      private
+
+      def parent_context
+        context = Context.new({}, @definition_context)
+        context.code_set("self", @code_self)
+        context
+      end
+
+      def arguments_for(code_arguments, explicit_arguments)
+        if explicit_arguments && code_arguments.raw.empty?
+          List.new
+        elsif code_arguments.any?
+          code_arguments
+        else
+          @forwarded_arguments
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/call.rb

@@ -151,7 +151,8 @@ class Code
 
       def root
         (
-          name.aka(:name) << (whitespace? << arguments.aka(:arguments)).maybe <<
+          name.aka(:name) <<
+            (whiltespace_without_newline? << arguments.aka(:arguments)).maybe <<
             (whiltespace_without_newline? << block.aka(:block)).maybe
         ).aka(:call)
       end

data/spec/code/object/function_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe Code::Object::Function do
 
   context "invalid" do
     [
-      "f = (x) => {} f",
+      "f = (x) => {} f()",
       "f = (x:) => {} f(1)",
       "f = (x:) => {} f(y: 1)"
     ].each do |input|
@@ -37,4 +37,129 @@ RSpec.describe Code::Object::Function do
       end
     end
   end
+
+  it "captures self for constructor-like functions that return self" do
+    result =
+      Code.evaluate(<<~CODE)
+        User = (given_name:, family_name:, birth_date:) => {
+          self.given_name = given_name.to_string.presence
+          self.family_name = family_name.to_string.presence
+          self.birth_date = birth_date.presence&.to_date
+          self.full_name = () => {
+            [self.given_name, self.family_name].compact.join(" ")
+          }
+          self.age = () => {
+            return unless(self.birth_date)
+
+            self.birth_date.year
+          }
+
+          return(self)
+        }
+
+        user = User(given_name: "Dorian", family_name: "Marie", birth_date: "1992-08-11")
+        [user.given_name, user.family_name, user.full_name, user.age]
+      CODE
+
+    expect(result).to eq(
+      Code::Object::List.new(
+        [
+          Code::Object::String.new("Dorian"),
+          Code::Object::String.new("Marie"),
+          Code::Object::String.new("Dorian Marie"),
+          Code::Object::Integer.new(1992)
+        ]
+      )
+    )
+  end
+
+  it "supports constructor methods on functions" do
+    result =
+      Code.evaluate(<<~CODE)
+        User = (given_name:, family_name:) => {
+          self.given_name = given_name
+          self.family_name = family_name
+          self.full_name = () => {
+            [self.given_name, self.family_name].join(" ")
+          }
+          return(self)
+        }
+
+        User.all = () => {
+          [
+            User(given_name: "Dorian", family_name: "Marie"),
+            User(given_name: "Ada", family_name: "Lovelace")
+          ]
+        }
+
+        User.first = () => {
+          User.all.first
+        }
+
+        User.first.full_name
+      CODE
+
+    expect(result).to eq(Code::Object::String.new("Dorian Marie"))
+  end
+
+  it "supports extending constructors and forwarding super arguments" do
+    result =
+      Code.evaluate(<<~CODE)
+        Person = (given_name:, family_name:) => {
+          self.given_name = given_name
+          self.family_name = family_name
+          self.full_name = () => {
+            [self.given_name, self.family_name].join(" ")
+          }
+          return(self)
+        }
+
+        Employee = Person.extend((employee_id:, given_name:, family_name:) => {
+          super
+          self.employee_id = employee_id
+          return(self)
+        })
+
+        employee = Employee(employee_id: "EMP-001", given_name: "Dorian", family_name: "Marie")
+        [employee.employee_id, employee.full_name]
+      CODE
+
+    expect(result).to eq(
+      Code::Object::List.new(
+        [
+          Code::Object::String.new("EMP-001"),
+          Code::Object::String.new("Dorian Marie")
+        ]
+      )
+    )
+  end
+
+  it "distinguishes super from super()" do
+    result =
+      Code.evaluate(<<~CODE)
+        Person = (given_name:, family_name:) => {
+          self.full_name = () => {
+            [given_name, family_name].join(" ")
+          }
+          return(self)
+        }
+
+        Anonymous = Person.extend(() => {
+          super()
+          self.full_name = () => { "anonymous" }
+          return(self)
+        })
+
+        [Anonymous().full_name, Person(given_name: "Ada", family_name: "Lovelace").full_name]
+      CODE
+
+    expect(result).to eq(
+      Code::Object::List.new(
+        [
+          Code::Object::String.new("anonymous"),
+          Code::Object::String.new("Ada Lovelace")
+        ]
+      )
+    )
+  end
 end

data/spec/code_spec.rb

@@ -239,6 +239,9 @@ RSpec.describe Code do
     %w[Class(Time) Time],
     %w[Class(nothing) Nothing],
     %w[Class(true) Boolean],
+    %w[String String],
+    %w[Time Time],
+    %w[Class Class],
     %w[Class.new Nothing],
     %w[Class.new Nothing],
     %w[Class.new(2.days.ago) Time],
@@ -331,20 +334,16 @@ RSpec.describe Code do
     ["a = 0 [1, 2, 3].each { |i| next if i == 2 a += i } a", "4"],
     ["a = 0\nb = 0\nwhile a < 4\n  a += 1\n  continue if a == 2\n  b += a\nend\nb", "8"],
     ["a = 0 loop a += 1 break end a", "1"],
-    ["a = 1\nbegin\n  a += 1\n  break if a > 3\n  retry\nend\na", "4"],
     ["x = loop break(42) end x", "42"],
-    ["a = 0 a += 1 retry if a < 3 a", "3"],
     ["a = 0\nuntil a > 10 a += 1 end a", "11"],
     ["a = 0\nwhile a < 10 a += 1 end a", "10"],
-    [
-      "a = 0\nretried = false\nwhile a < 2\n  a += 1\n  retry if a == 1 && !retried && (retried = true)\nend\na",
-      "2"
-    ],
     ["a = 1 3.times { a += 1 } a", "4"],
     ["a = 1 a *= 2 a", "2"],
     ["a = 1 a += 1 a", "2"],
     ["a = 1 a += 1 a", "2"],
     ["a = 1 a -= 1 a", "0"],
+    ["a = 3 a -= 1 if false a", "3"],
+    ["a = 3\n(a -= 1) if false\na", "3"],
     ["a = 1 a /= 2 a", "0.5"],
     ["a = 1 a <<= 1 a", "2"],
     ["a = 1 a >>= 1 a", "0"],
@@ -375,7 +374,6 @@ RSpec.describe Code do
     ["next(7)", "7"],
     ["not not false", "false"],
     ["not true", "false"],
-    ["retry(8)", "8"],
     ["return(9)", "9"],
     ["f = () => { return(3) 4 } f()", "3"],
     ["a = 1 orirginal = 2 orirginal", "2"],
@@ -486,6 +484,7 @@ RSpec.describe Code do
     ["", ""]
   ].each do |input, expected|
     it "#{input} == #{expected}" do
+      puts input
       formatted = format_input(input)
 
       output = StringIO.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 1.9.12
+  version: 2.0.1
 platform: ruby
 authors:
 - Dorian Marié
@@ -285,6 +285,7 @@ files:
 - lib/code/object/range.rb
 - lib/code/object/smtp.rb
 - lib/code/object/string.rb
+- lib/code/object/super.rb
 - lib/code/object/time.rb
 - lib/code/object/url.rb
 - lib/code/parser.rb
@@ -345,7 +346,6 @@ files:
 - spec/code/object/decimal_spec.rb
 - spec/code/object/dictionary_spec.rb
 - spec/code/object/function_spec.rb
-- spec/code/object/http_spec.rb
 - spec/code/object/identifier_list_spec.rb
 - spec/code/object/integer_spec.rb
 - spec/code/object/list_spec.rb

data/spec/code/object/http_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Code::Object::Http do
-  def self.verbs
-    %w[get head post put delete options trace patch]
-  end
-
-  def self.response_codes
-    {
-      continue: 100,
-      switching_protocols: 101,
-      processing: 102,
-      early_hints: 103,
-      ok: 200,
-      created: 201,
-      accepted: 202,
-      non_authoritative_information: 203,
-      no_content: 204,
-      reset_content: 205,
-      partial_content: 206,
-      multi_status: 207,
-      already_reported: 208,
-      im_used: 226,
-      multiple_choices: 300,
-      moved_permanently: 301,
-      found: 302,
-      see_other: 303,
-      not_modified: 304,
-      use_proxy: 305,
-      reserved: 306,
-      temporary_redirect: 307,
-      permanent_redirect: 308,
-      bad_request: 400,
-      unauthorized: 401,
-      payment_required: 402,
-      forbidden: 403,
-      not_found: 404,
-      method_not_allowed: 405,
-      not_acceptable: 406,
-      proxy_authentication_required: 407,
-      request_timeout: 408,
-      conflict: 409,
-      gone: 410,
-      length_required: 411,
-      precondition_failed: 412,
-      request_entity_too_large: 413,
-      request_uri_too_long: 414,
-      unsupported_media_type: 415,
-      requested_range_not_satisfiable: 416,
-      expectation_failed: 417,
-      misdirected_request: 421,
-      unprocessable_entity: 422,
-      locked: 423,
-      failed_dependency: 424,
-      too_early: 425,
-      upgrade_required: 426,
-      precondition_required: 428,
-      too_many_requests: 429,
-      request_header_fields_too_large: 431,
-      unavailable_for_legal_reasons: 451,
-      internal_server_error: 500,
-      not_implemented: 501,
-      bad_gateway: 502,
-      service_unavailable: 503,
-      gateway_timeout: 504,
-      http_version_not_supported: 505,
-      variant_also_negotiates: 506,
-      insufficient_storage: 507,
-      loop_detected: 508,
-      bandwidth_limit_exceeded: 509,
-      not_extended: 510,
-      network_authentication_required: 511
-    }
-  end
-
-  verbs.each do |verb|
-    describe ".#{verb}" do
-      response_codes.each do |status, code|
-        it "returns #{code} as code and #{status} as status" do
-          expect(Code.evaluate(<<~INPUT)).to eq(Code.evaluate(<<~OUTPUT))
-            response = Http.#{verb}("https://httpbin.org/status/#{code}")
-            [response.code, response.status]
-          INPUT
-            [#{code}, "#{status}"]
-          OUTPUT
-
-          expect(Code.evaluate(<<~INPUT)).to eq(Code.evaluate(<<~OUTPUT))
-            response = Http.fetch("#{verb}", "https://httpbin.org/status/#{code}")
-            [response.code, response.status]
-          INPUT
-            [#{code}, "#{status}"]
-          OUTPUT
-        end
-      end
-    end
-  end
-end