code-ruby 1.9.12 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a8c532c56c64f318cc116ef97c0bc587edde1f306d5f8e53d75be893bf38b1f
-  data.tar.gz: ffc94431ea3528b547ab9b76e03d4efea7f9e2281a30da04e7528ea881d2d308
+  metadata.gz: f52de5a641a1d879b4ac472d5f291a1c101a42797362019d6a2c3854e6bf90a2
+  data.tar.gz: 32645dbb24c34523d7848852f59a2de98786de33b8f1782ad514c8e8a317ebb7
 SHA512:
-  metadata.gz: 468c2777dab28cabbff2e918d5ee3a9a5a417063be54ad44026d20a096d0f234c6ee7fb633c17d707dbaf565eb61614ea4d6d67bc3888aa8895d9df092c37a50
-  data.tar.gz: 1f29b8a374565925fcbdf636bf7a1d60f45a5d5a23ba4bf24550c4f2964f695ac4691d0ea60d25825bd5e487c18e05feb14eab0b2df37c1c0c1f054c7d012b4b
+  metadata.gz: 1dc8fe275e70f5fdc948f082408ae64cb1ab8aaaa73d1f73fb9b8c9eccb180f987dc2d10d7ace3a94ecb85678a9c8ccd95b3c7737c95cd349d6ff3cdb35872a5
+  data.tar.gz: 6317f857f1c7984212ca971650dda29e5d9b6fff92d677c4b6c069041cbfda0f92a2bb78d1345c5f11e5eb51d0f9a9d2285bfb60423ef0dd94fb21344e9bec12

data/Gemfile.lock

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

data/VERSION

@@ -1 +1 @@
-1.9.12
+2.0.0

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/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/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 =
@@ -113,6 +154,54 @@ class Code
       def code_to_string
         String.new("<#{self.class.name} #{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
     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

@@ -345,6 +345,8 @@ RSpec.describe Code do
     ["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"],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 1.9.12
+  version: 2.0.0
 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