code-ruby 0.5.5 → 0.6.0

data/lib/code/parser/range.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Range < Operation
+    class Range < LeftOperation
       def statement
-        ::Code::Parser::OrOperator
+        OrOperator
       end
 
       def dot

data/lib/code/parser/rescue.rb

@@ -1,38 +1,18 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Rescue < Language
+    class Rescue < RightOperation
       def statement
-        ::Code::Parser::Ternary
-      end
-
-      def rescue_class
-        ::Code::Parser::Rescue
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
+        Ternary
       end
 
       def rescue_keyword
         str("rescue")
       end
 
-      def root
-        (
-          statement.aka(:left) <<
-            (
-              whitespace? << rescue_keyword << whitespace? <<
-                rescue_class.aka(:right)
-            ).maybe
-        )
-          .aka(:rescue)
-          .then do |output|
-            output[:rescue][:right] ? output : output[:rescue][:left]
-          end
+      def operator
+        rescue_keyword
       end
     end
   end

data/lib/code/parser/right_operation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Code
+  class Parser
+    class RightOperation < Language
+      def statement
+        raise NotImplementedError
+      end
+
+      def whitespace
+        Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def operator
+        raise NotImplementedError
+      end
+
+      def root
+        (
+          statement.aka(:left) << (
+            whitespace? << operator.aka(:operator) << whitespace? <<
+              self.class.aka(:right)
+          ).maybe
+        )
+          .aka(:right_operation)
+          .then do |output|
+            if output[:right_operation][:right]
+              output
+            else
+              output[:right_operation][:left]
+            end
+          end
+      end
+    end
+  end
+end

data/lib/code/parser/shift.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
-    class Shift < Operation
+    class Shift < LeftOperation
       def statement
-        ::Code::Parser::Addition
+        Addition
       end
 
       def greater

data/lib/code/parser/splat.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Splat < Language
       def statement
-        ::Code::Parser::Class
+        Class
       end
 
       def splat
-        ::Code::Parser::Splat
+        Splat
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?

data/lib/code/parser/square_bracket.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Code
+  class Parser
+    class SquareBracket < Language
+      def statement
+        UnaryMinus
+      end
+
+      def square_bracket
+        SquareBracket
+      end
+
+      def whitespace
+        Whitespace
+      end
+
+      def whitespace?
+        whitespace.maybe
+      end
+
+      def left_square_bracket
+        str("[")
+      end
+
+      def right_square_bracket
+        str("]")
+      end
+
+      def root
+        (
+          statement.aka(:left) << (
+            left_square_bracket << whitespace? << square_bracket <<
+              (whitespace? << right_square_bracket).maybe
+          ).repeat(1).aka(:statements).maybe
+        )
+          .aka(:square_bracket)
+          .then do |output|
+            if output[:square_bracket][:statements]
+              output
+            else
+              output[:square_bracket][:left]
+            end
+          end
+      end
+    end
+  end
+end

data/lib/code/parser/statement.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Statement < Language
       def root
-        ::Code::Parser::Equality
+        Splat
       end
     end
   end

data/lib/code/parser/string.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class String < Language
       def code
-        ::Code::Parser::Code
+        Code
       end
 
       def name
-        ::Code::Parser::Name
+        Name
       end
 
       def single_quote
@@ -18,7 +20,7 @@ class Code
       end
 
       def backslash
-        str("\\")
+        str('\\')
       end
 
       def opening_curly_bracket
@@ -54,15 +56,15 @@ class Code
       end
 
       def single_quoted_string
-        single_quote.ignore <<
-          (code_part.aka(:code) | single_quoted_text_part.aka(:text)).repeat <<
-          single_quote.ignore.maybe
+        single_quote.ignore << (
+          code_part.aka(:code) | single_quoted_text_part.aka(:text)
+        ).repeat << single_quote.ignore.maybe
       end
 
       def double_quoted_string
-        double_quote.ignore <<
-          (code_part.aka(:code) | double_quoted_text_part.aka(:text)).repeat <<
-          double_quote.ignore.maybe
+        double_quote.ignore << (
+          code_part.aka(:code) | double_quoted_text_part.aka(:text)
+        ).repeat << double_quote.ignore.maybe
       end
 
       def symbol
@@ -71,7 +73,7 @@ class Code
 
       def root
         (single_quoted_string | double_quoted_string | symbol).aka(:string) |
-          ::Code::Parser::Number
+          Number
       end
     end
   end

data/lib/code/parser/ternary.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Ternary < Language
       def statement
-        ::Code::Parser::Range
+        Range
       end
 
       def ternary
-        ::Code::Parser::Ternary
+        Ternary
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?
@@ -27,14 +29,11 @@ class Code
 
       def root
         (
-          statement.aka(:left) <<
-            (
-              whitespace? << question_mark << whitespace? <<
-                ternary.aka(:middle) <<
-                (
-                  whitespace? << colon << whitespace? << ternary.aka(:right)
-                ).maybe
-            ).maybe
+          statement.aka(:left) << (
+            whitespace? << question_mark << whitespace? <<
+              ternary.aka(:middle) <<
+              (whitespace? << colon << whitespace? << ternary.aka(:right)).maybe
+          ).maybe
         )
           .aka(:ternary)
           .then do |output|

data/lib/code/parser/unary_minus.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class UnaryMinus < Language
       def unary_minus
-        ::Code::Parser::UnaryMinus
+        UnaryMinus
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def whitespace?
@@ -24,7 +26,7 @@ class Code
       def root
         (operator.aka(:operator) << whitespace? << unary_minus.aka(:right)).aka(
           :unary_minus
-        ) | ::Code::Parser::Power
+        ) | Power
       end
     end
   end

data/lib/code/parser/while.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class While < Language
       def statement
-        ::Code::Parser::If
+        If
       end
 
       def whitespace
-        ::Code::Parser::Whitespace
+        Whitespace
       end
 
       def code
-        ::Code::Parser::Code
+        Code
       end
 
       def while_keyword

data/lib/code/parser/whitespace.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
     class Whitespace < Language

data/lib/code/parser.rb

@@ -1,15 +1,22 @@
+# frozen_string_literal: true
+
 class Code
   class Parser
+    class Error < StandardError
+    end
+
     def initialize(input)
       @input = input
     end
 
-    def self.parse(input)
-      new(input).parse
+    def self.parse(...)
+      new(...).parse
     end
 
     def parse
-      ::Code::Parser::Code.parse(input)
+      Code.parse(input)
+    rescue Language::Parser::NotEndOfInput => e
+      raise Error, e.message
     end
 
     private

data/lib/code/ruby.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Ruby
     def initialize(raw = {})
@@ -32,7 +34,7 @@ class Code
       elsif big_decimal?
         ::Code::Object::Decimal.new(raw)
       elsif hash?
-        ::Code::Object::Dictionnary.new(
+        ::Code::Object::Dictionary.new(
           raw
             .map do |key, value|
               [::Code::Ruby.to_code(key), ::Code::Ruby.to_code(value)]
@@ -164,7 +166,7 @@ class Code
     end
 
     def code_dictionnary?
-      raw.is_a?(::Code::Object::Dictionnary)
+      raw.is_a?(::Code::Object::Dictionary)
     end
 
     def code_list?

data/lib/code/type/hash.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Code
+  class Type
+    class Hash < Type
+      attr_reader :hash
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def valid?(argument)
+        return false unless argument.is_a?(Object::Dictionary)
+        argument = argument.raw
+        (argument.keys + hash.keys).uniq.all? do |key|
+          next false unless hash[key] && argument[key]
+          valid_for?(expected: hash[key], actual: argument[key])
+        end
+      end
+
+      def min_arguments
+        hash.sum do |_, value|
+          min_arguments_of(value)
+        end
+      end
+
+      def max_arguments
+        hash.sum do |_, value|
+          max_arguments_of(value)
+        end
+      end
+
+      def name
+        "{#{hash.map { |key, value| "#{key.inspect} => #{value.name}" }.join(", ")}}"
+      end
+    end
+  end
+end

data/lib/code/type/maybe.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Code
+  class Type
+    class Maybe < Type
+      attr_reader :clazz
+
+      def initialize(clazz)
+        @clazz = clazz
+      end
+
+      def valid?(argument)
+        !argument || valid_for?(expected: clazz, actual: argument)
+      end
+
+      def min_arguments
+        0
+      end
+
+      def max_arguments
+        max_arguments_of(clazz)
+      end
+
+      def name
+        "#{clazz.name}.maybe"
+      end
+    end
+  end
+end

data/lib/code/type/or.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Code
+  class Type
+    class Or < Type
+      attr_reader :left, :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def valid?(argument)
+        valid_for?(expected: left, actual: argument) ||
+          valid_for?(expected: right, actual: argument)
+      end
+
+      def min_arguments
+        [min_arguments_of(left), min_arguments_of(right)].min
+      end
+
+      def max_arguments
+        left_max_arguments = max_arguments_of(left)
+        right_max_arguments = max_arguments_of(right)
+
+        if left_max_arguments.nil? || right_max_arguments.nil?
+          nil
+        else
+          [left_max_arguments, right_max_arguments].max
+        end
+      end
+
+      def name
+        "(#{left.name} | #{right.name})"
+      end
+    end
+  end
+end

data/lib/code/type/repeat.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Code
+  class Type
+    class Repeat < Type
+      attr_reader :clazz, :minimum, :maximum
+
+      def initialize(clazz, minimum: 0, maximum: nil)
+        @clazz = clazz
+        @minimum = minimum
+        @maximum = maximum
+      end
+
+      def valid?(argument)
+        valid_for?(expected: clazz, actual: argument)
+      end
+
+      def min_arguments
+        minimum * min_arguments_of(clazz)
+      end
+
+      def max_arguments
+        max_arguments = max_arguments_of(clazz)
+        max_arguments.nil? || maximum.nil? ? nil : maximum * max_arguments
+      end
+
+      def name
+        if minimum.zero? && maximum.nil?
+          "#{clazz.name}.repeat"
+        elsif maximum.nil?
+          "#{clazz.name}.repeat(#{minimum})"
+        else
+          "#{clazz.name}.repeaa(#{minimum}, #{maximum})"
+        end
+      end
+    end
+  end
+end

data/lib/code/type/sig.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+class Code
+  class Type
+    class Sig
+      def initialize(args, object:, &block)
+        @args = args
+        @block = block
+        @object = object
+      end
+
+      def self.sig(...)
+        new(...).sig
+      end
+
+      def sig
+        check_number_of_arguments!
+        check_types_of_arguments!
+      end
+
+      private
+
+      attr_reader :args, :block, :object
+
+      def expected_arguments
+        @expected_arguments ||= Array(block&.call || []).map do |clazz|
+          clazz.is_a?(::Hash) ? Hash.new(clazz) : clazz
+        end
+      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
+
+      def actual_arguments
+        args[:arguments].map(&:value)
+      end
+
+      def operator
+        args[:operator] || "call"
+      end
+
+      def function
+        "#{object.class.name}##{operator}"
+      end
+
+      def min_arguments
+        expected_arguments.sum { |clazz| min_arguments_of(clazz) }
+      end
+
+      def max_arguments
+        max_arguments = expected_arguments.map { |clazz| max_arguments_of(clazz) }
+        max_arguments.include?(nil) ? nil : max_arguments.sum
+      end
+
+      def actual_count
+        if actual_arguments.one?
+          "1 argument"
+        else
+          "#{actual_arguments.size} arguments"
+        end
+      end
+
+      def expected_count
+        if min_arguments == max_arguments
+          if min_arguments == 1
+            "1 argument"
+          else
+            "#{min_arguments} arguments"
+          end
+        elsif max_arguments.nil?
+          "#{min_arguments}+ arguments"
+        else
+          "#{min_arguments}-#{max_arguments} arguments"
+        end
+      end
+
+      def expected_range
+        max_arguments.nil? ? min_arguments.. : min_arguments..max_arguments
+      end
+
+      def check_number_of_arguments!
+        return if expected_range.include?(actual_arguments.size)
+
+        raise(
+          Error::ArityError,
+          "#{function}: Expected #{expected_count} but got #{actual_count}"
+        )
+      end
+
+      def valid_for?(expected:, actual:)
+        expected.is_a?(Type) ? expected.valid?(actual) : actual.is_a?(expected)
+      end
+
+      def check_types_of_arguments!
+        expected_index = 0
+        repeat_index = 0
+
+        actual_arguments.each do |actual|
+          expected = expected_arguments[expected_index]
+          if expected.is_a?(Repeat)
+            if valid_for?(expected:, actual:)
+              repeat_index += 1
+            elsif repeat_index >= expected.min_arguments
+              expected_index += 1
+              repeat_index = 0
+            else
+              raise(
+                Error::TypeError,
+                "#{function}: expected #{expected.name}, got #{actual.inspect}"
+              )
+            end
+          elsif valid_for?(expected:, actual:)
+            expected_index += 1
+            repeat_index = 0
+          else
+            raise(
+              Error::TypeError,
+              "#{function}: expected #{expected.name}, got #{actual.inspect}"
+            )
+          end
+        end
+      end
+    end
+  end
+end