code-ruby 1.2.7 → 1.4.0

data/lib/code/object.rb

@@ -12,21 +12,12 @@ class Code
       ::BigDecimal
     ].freeze
 
-    attr_reader :raw
-
-    delegate :to_s, :inspect, to: :raw
+    include Concerns::Shared
+    extend Concerns::Shared
 
     def initialize(...)
     end
 
-    def self.nothing?
-      false
-    end
-
-    def nothing?
-      false
-    end
-
     def self.maybe
       Type::Maybe.new(self)
     end
@@ -39,445 +30,16 @@ class Code
       Type::Or.new(self, other)
     end
 
-    def self.call(**args)
-      code_operator = args.fetch(:operator, nil).to_code
-      code_arguments = args.fetch(:arguments, []).to_code
-      code_value = code_arguments.code_first
-
-      case code_operator.to_s
-      when "new"
-        sig(args) { Object.repeat }
-        code_new(*code_arguments.raw)
-      when "!", "not"
-        sig(args)
-        code_exclamation_point
-      when "!=", "different"
-        sig(args) { Object }
-        code_different(code_value)
-      when "&&", "and"
-        sig(args) { Object }
-        code_and_operator(code_value)
-      when "+", "self"
-        sig(args)
-        code_self
-      when "..", "inclusive_range"
-        sig(args) { Object }
-        code_inclusive_range(code_value)
-      when "...", "exclusive_range"
-        sig(args) { Object }
-        code_exclusive_range(code_value)
-      when "==", "equal"
-        sig(args) { Object }
-        code_equal_equal(code_value)
-      when "===", "strict_equal"
-        sig(args) { Object }
-        code_equal_equal_equal(code_value)
-      when "falsy?"
-        sig(args)
-        Boolean.new(falsy?)
-      when "truthy?"
-        sig(args)
-        Boolean.new(truthy?)
-      when "||", "or"
-        sig(args) { Object }
-        code_or_operator(code_value)
-      when "to_boolean"
-        sig(args)
-        Boolean.new(self)
-      when "to_class"
-        sig(args)
-        Class.new(self)
-      when "to_date"
-        sig(args)
-        Date.new(self)
-      when "to_decimal"
-        sig(args)
-        Decimal.new(self)
-      when "to_dictionary"
-        sig(args)
-        Dictionary.new(self)
-      when "to_duration"
-        sig(args)
-        Duration.new(self)
-      when "to_integer"
-        sig(args)
-        Integer.new(self)
-      when "to_list"
-        sig(args)
-        List.new(self)
-      when "to_nothing"
-        sig(args)
-        Nothing.new(self)
-      when "to_range"
-        sig(args)
-        Range.new(self)
-      when "to_string"
-        sig(args)
-        String.new(self)
-      when "to_time"
-        sig(args)
-        Time.new(self)
-      when "as_json"
-        sig(args)
-        code_as_json
-      when "to_json"
-        sig(args) { { pretty: Boolean.maybe } }
-
-        if code_arguments.any?
-          code_to_json(pretty: code_value.code_get(:pretty))
-        else
-          code_to_json
-        end
-      when /=$/
-        sig(args) { Object }
-
-        if code_operator.to_s == "="
-          code_context = args.fetch(:context)
-          code_context.code_set(self, value)
-        else
-          code_context = args.fetch(:context).code_lookup!(self)
-          code_context.code_set(
-            self,
-            code_context.code_fetch(self).call(
-              **args,
-              operator: operator.to_s.chop,
-              arguments: List.new([code_value])
-            )
-          )
-        end
-
-        context.code_fetch(self)
-      else
-        raise(Error, "#{code_operator.inspect} not defined on #{inspect}:Class")
-      end
-    end
-
-    def self.code_new(*arguments)
-      code_arguments = arguments.to_code
-
-      new(*code_arguments.raw)
-    end
-
-    def self.code_and_operator(other)
-      code_other = other.to_code
-
-      truthy? ? code_other : self
-    end
-
-    def self.code_different(other)
-      code_other = other.to_code
-
-      Boolean.new(self != code_other)
-    end
-
-    def self.code_equal_equal(other)
-      code_other = other.to_code
-
-      Boolean.new(self == code_other)
-    end
-
-    def self.code_exclamation_point
-      Boolean.new(falsy?)
-    end
-
-    def self.code_exclusive_range(value)
-      code_value = value.to_code
-
-      Range.new(self, code_value, exclude_end: true)
-    end
-
-    def self.code_inclusive_range(value)
-      code_value = value.to_code
-
-      Range.new(self, code_value, exclude_end: false)
-    end
-
-    def self.code_or_operator(other)
-      code_other = other.to_code
-
-      truthy? ? self : code_other
-    end
-
-    def self.code_self
-      self
-    end
-
-    def self.code_equal_equal_equal(other)
-      code_other = other.to_code
-
-      Boolean.new(self === code_other)
-    end
-
-    def self.falsy?
-      !truthy?
-    end
-
-    def self.multi_fetch(hash, *keys)
-      keys.to_h { |key| [key, hash.fetch(key)] }
-    end
-
-    def self.sig(args, &)
-      Type::Sig.sig(args, object: self, &)
-
-      Nothing.new
-    end
-
-    def self.to_s
-      name
-    end
-
-    def self.inspect
-      name
-    end
-
-    def self.truthy?
-      true
-    end
-
-    def self.to_json(...)
-      as_json(...).to_json(...)
-    end
-
-    def self.as_json(...)
-      name.as_json(...)
-    end
-
-    def self.code_to_json(pretty: nil)
-      if Boolean.new(pretty).truthy?
-        String.new(::JSON.pretty_generate(self))
-      else
-        String.new(to_json)
-      end
-    end
-
-    def self.code_as_json
-      to_ruby.as_json.to_code
-    end
-
-    def <=>(other)
-      code_other = other.to_code
-
-      raw <=> code_other.raw
-    end
-
-    def ==(other)
-      code_other = other.to_code
-
-      raw == code_other.raw
-    end
-    alias eql? ==
-
-    def call(**args)
-      code_operator = args.fetch(:operator, nil).to_code
-      code_arguments = args.fetch(:arguments, []).to_code
-      code_value = code_arguments.code_first
-
-      case code_operator.to_s
-      when "!", "not"
-        sig(args)
-        code_exclamation_point
-      when "!=", "different"
-        sig(args) { Object }
-        code_different(code_value)
-      when "&&", "and"
-        sig(args) { Object }
-        code_and_operator(code_value)
-      when "+", "self"
-        sig(args)
-        code_self
-      when "..", "inclusive_range"
-        sig(args) { Object }
-        code_inclusive_range(code_value)
-      when "...", "exclusive_range"
-        sig(args) { Object }
-        code_exclusive_range(code_value)
-      when "==", "equal"
-        sig(args) { Object }
-        code_equal_equal(code_value)
-      when "===", "strict_equal"
-        sig(args) { Object }
-        code_equal_equal_equal(code_value)
-      when "falsy?"
-        sig(args)
-        Boolean.new(falsy?)
-      when "truthy?"
-        sig(args)
-        Boolean.new(truthy?)
-      when "||", "or"
-        sig(args) { Object }
-        code_or_operator(code_value)
-      when "to_boolean"
-        sig(args)
-        Boolean.new(self)
-      when "to_class"
-        sig(args)
-        Class.new(self)
-      when "to_date"
-        sig(args)
-        Date.new(self)
-      when "to_decimal"
-        sig(args)
-        Decimal.new(self)
-      when "to_duration"
-        sig(args)
-        Duration.new(self)
-      when "to_dictionary"
-        sig(args)
-        Dictionary.new(self)
-      when "to_integer"
-        sig(args)
-        Integer.new(self)
-      when "to_list"
-        sig(args)
-        List.new(self)
-      when "to_nothing"
-        sig(args)
-        Nothing.new(self)
-      when "to_range"
-        sig(args)
-        Range.new(self)
-      when "to_string"
-        sig(args)
-        String.new(self)
-      when "to_time"
-        sig(args)
-        Time.new(self)
-      when "as_json"
-        sig(args)
-        code_as_json
-      when "to_json"
-        sig(args) { { pretty: Boolean.maybe } }
-
-        if code_arguments.any?
-          code_to_json(pretty: code_value.code_get(:pretty))
-        else
-          code_to_json
-        end
-      when /=$/
-        sig(args) { Object }
-
-        if code_operator.to_s == "="
-          code_context = args.fetch(:context)
-          code_context.code_set(self, code_value)
-        else
-          code_context = args.fetch(:context).code_lookup!(self)
-          code_context.code_set(
-            self,
-            code_context.code_fetch(self).call(
-              **args,
-              operator: code_operator.to_s.chop,
-              arguments: List.new([code_value])
-            )
-          )
-        end
-
-        code_context.code_fetch(self)
-      else
-        raise(
-          Error,
-          "#{code_operator.inspect} not defined on #{inspect}:#{self.class.name}"
-        )
-      end
-    end
-
-    def code_and_operator(other)
-      code_other = other.to_code
-
-      truthy? ? code_other : self
-    end
-
-    def code_different(other)
-      code_other = other.to_code
-
-      Boolean.new(self != code_other)
-    end
-
-    def code_equal_equal(other)
-      code_other = other.to_code
-
-      Boolean.new(self == code_other)
-    end
-
-    def code_exclamation_point
-      Boolean.new(falsy?)
-    end
-
-    def code_exclusive_range(value)
-      code_value = value.to_code
-
-      Range.new(self, code_value, exclude_end: true)
-    end
-
-    def code_inclusive_range(value)
-      code_value = value.to_code
-
-      Range.new(self, code_value, exclude_end: false)
-    end
-
-    def code_or_operator(other)
-      code_other = other.to_code
-
-      truthy? ? self : code_other
-    end
-
-    def code_self
-      self
-    end
-
-    def code_equal_equal_equal(other)
-      code_other = other.to_code
-
-      Boolean.new(self === code_other)
-    end
-
-    def falsy?
-      !truthy?
-    end
-
-    def hash
-      [self.class, raw].hash
-    end
-
-    def multi_fetch(hash, *keys)
-      keys.to_h { |key| [key, hash.fetch(key)] }
-    end
-
-    def sig(args, &)
-      Type::Sig.sig(args, object: self, &)
-
-      Nothing.new
-    end
-
-    def truthy?
-      true
-    end
-
-    def to_json(...)
-      as_json(...).to_json(...)
-    end
-
-    def as_json(...)
-      raw.as_json(...)
-    end
-
-    def code_to_json(pretty: nil)
-      if Boolean.new(pretty).truthy?
-        String.new(::JSON.pretty_generate(self))
-      else
-        String.new(to_json)
-      end
-    end
-
-    def code_as_json
-      as_json.to_code
+    def self.code_new(*)
+      new(*)
     end
 
-    def to_code
-      self
+    def name
+      self.class.name
     end
 
-    def succ
-      self.class.new(raw.succ)
+    def code_new(*)
+      self.class.code_new(*)
     end
   end
 end

data/lib/code/parser/call.rb

@@ -59,6 +59,10 @@ class Code
         str("do")
       end
 
+      def begin_keyword
+        str("do")
+      end
+
       def end_keyword
         str("end")
       end
@@ -107,8 +111,9 @@ class Code
 
       def block
         (
-          do_keyword << whitespace? << parameters.aka(:parameters).maybe <<
-            code.aka(:body) << end_keyword.maybe
+          (do_keyword | begin_keyword) << whitespace? <<
+            parameters.aka(:parameters).maybe << code.aka(:body) <<
+            end_keyword.maybe
         ) |
           (
             opening_curly_bracket << whitespace? <<

data/lib/code/parser/class.rb

@@ -7,41 +7,8 @@ class Code
         While
       end
 
-      def name
-        Name
-      end
-
-      def code
-        Code
-      end
-
-      def whitespace
-        Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      def class_keyword
-        str("class")
-      end
-
-      def end_keyword
-        str("end")
-      end
-
-      def lesser
-        str("<")
-      end
-
       def root
-        (
-          class_keyword << whitespace? << name.aka(:name) <<
-            (
-              whitespace? << lesser << whitespace? << name.aka(:superclass)
-            ).maybe << code.aka(:body) << end_keyword.maybe
-        ).aka(:class) | statement
+        statement
       end
     end
   end

data/lib/code/parser/function.rb

@@ -23,6 +23,18 @@ class Code
         whitespace.maybe
       end
 
+      def do_keyword
+        str("do")
+      end
+
+      def begin_keyword
+        str("begin")
+      end
+
+      def end_keyword
+        str("end")
+      end
+
       def opening_parenthesis
         str("(")
       end
@@ -88,11 +100,15 @@ class Code
           (whitespace? << closing_parenthesis.ignore).maybe
       end
 
+      def body
+        ((begin_keyword | do_keyword) << code << end_keyword.maybe) |
+          (opening_curly_bracket << code << closing_curly_bracket.maybe) | code
+      end
+
       def root
         (
           parameters.aka(:parameters) << whitespace? << equal << greater <<
-            whitespace? << opening_curly_bracket << code.aka(:body) <<
-            closing_curly_bracket.maybe
+            whitespace? << body.aka(:body)
         ).aka(:function) | Dictionary
       end
     end

data/lib/code/parser/group.rb

@@ -15,8 +15,22 @@ class Code
         str(")")
       end
 
+      def end_keyword
+        str("end")
+      end
+
+      def do_keyword
+        str("do")
+      end
+
+      def begin_keyword
+        str("begin")
+      end
+
       def root
         (opening_parenthesis << code << closing_parenthesis.maybe).aka(:group) |
+          (begin_keyword << code << end_keyword.maybe).aka(:group) |
+          (do_keyword << code << end_keyword.maybe).aka(:group) |
           Call
       end
     end

data/lib/code/parser/if.rb

@@ -23,6 +23,22 @@ class Code
         whitespace.maybe
       end
 
+      def do_keyword
+        str("do")
+      end
+
+      def begin_keyword
+        str("begin")
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      def closing_curly_bracket
+        str("{")
+      end
+
       def if_keyword
         str("if")
       end
@@ -43,20 +59,25 @@ class Code
         str("end")
       end
 
+      def body
+        ((begin_keyword | do_keyword) << code << end_keyword.maybe) |
+          (opening_curly_bracket << code << closing_curly_bracket.maybe) | code
+      end
+
       def root
         (
           (if_keyword | unless_keyword).aka(:first_operator) << whitespace <<
-            statement.aka(:first_statement) << code.aka(:first_body) <<
+            statement.aka(:first_statement) << body.aka(:first_body) <<
             (
               (
                 elsif_keyword.aka(:operator) << whitespace <<
-                  statement.aka(:statement) << code.aka(:body)
+                  statement.aka(:statement) << body.aka(:body)
               ) |
                 (
                   else_keyword << whitespace <<
                     (if_keyword | unless_keyword).aka(:operator) <<
-                    whitespace << statement.aka(:statement) << code.aka(:body)
-                ) | (else_keyword.aka(:operator) << code.aka(:body))
+                    whitespace << statement.aka(:statement) << body.aka(:body)
+                ) | (else_keyword.aka(:operator) << body.aka(:body))
             ).repeat(1).aka(:elses).maybe << end_keyword.maybe
         ).aka(:if) | statement
       end

data/lib/code/parser/name.rb

@@ -91,10 +91,18 @@ class Code
         str("elsif")
       end
 
+      def begin_keyword
+        str("begin")
+      end
+
       def else_keyword
         str("else")
       end
 
+      def begin_keyword
+        str("begin")
+      end
+
       def special_character
         ampersand | equal | pipe | dot | colon | comma | space | newline |
           opening_curly_bracket | closing_curly_bracket | opening_parenthesis |
@@ -113,8 +121,9 @@ class Code
 
       def root
         (do_keyword << separator).absent << (
-          else_keyword << separator
-        ).absent << (elsif_keyword << separator).absent <<
+          begin_keyword << separator
+        ).absent << (else_keyword << separator).absent <<
+          (elsif_keyword << separator).absent <<
           (end_keyword << separator).absent << character.repeat(1)
       end
     end