template-ruby 0.1.0 → 0.2.0

data/lib/code/object/list.rb

@@ -3,10 +3,66 @@ class Code
     class List < ::Code::Object
       attr_reader :raw
 
-      def initialize(raw)
+      def initialize(raw = [])
         @raw = raw
       end
 
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        context = args.fetch(:context)
+        io = args.fetch(:io)
+
+        if operator == "any?"
+          any?(arguments, context: context, io: io)
+        elsif operator == "none?"
+          none?(arguments, context: context, io: io)
+        elsif operator == "detect"
+          detect(arguments, context: context, io: io)
+        elsif operator == "reduce"
+          reduce(arguments, context: context, io: io)
+        elsif operator == "each"
+          each(arguments, context: context, io: io)
+        elsif operator == "select"
+          select(arguments, context: context, io: io)
+        elsif operator == "map"
+          map(arguments, context: context, io: io)
+        elsif operator == "max"
+          max(arguments)
+        elsif operator == "flatten"
+          flatten(arguments)
+        elsif operator == "reverse"
+          reverse(arguments)
+        elsif operator == "first"
+          first(arguments)
+        elsif operator == "last"
+          last(arguments)
+        elsif operator == "max_by"
+          max_by(arguments, context: context, io: io)
+        elsif operator == "<<"
+          append(arguments)
+        else
+          super
+        end
+      end
+
+      def <<(element)
+        raw << element
+      end
+
+      def flatten(arguments)
+        sig(arguments)
+        ::Code::Object::List.new(
+          raw.reduce([]) do |acc, element|
+            if element.is_a?(::Code::Object::List)
+              acc + element.flatten(arguments).raw
+            else
+              acc + [element]
+            end
+          end
+        )
+      end
+
       def to_s
         "[#{raw.map(&:inspect).join(", ")}]"
       end
@@ -15,22 +71,146 @@ class Code
         to_s
       end
 
-      def map(&block)
-        @raw = raw.map(&block)
+      private
+
+      def any?(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first
+        ::Code::Object::Boolean.new(
+          raw.any? do |element|
+            argument
+              .value
+              .call(
+                arguments: [::Code::Object::Argument.new(element)],
+                context: context,
+                io: io,
+              )
+              .truthy?
+          end,
+        )
+      end
+
+      def none?(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first
+        ::Code::Object::Boolean.new(
+          raw.none? do |element|
+            argument
+              .value
+              .call(
+                arguments: [::Code::Object::Argument.new(element)],
+                context: context,
+                io: io,
+              )
+              .truthy?
+          end,
+        )
+      end
+
+      def max_by(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        raw.max_by do |element|
+          argument.call(
+            arguments: [::Code::Object::Argument.new(element)],
+            context: context,
+            io: io,
+          )
+        end || ::Code::Object::Nothing.new
+      end
+
+      def detect(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        raw.detect do |element|
+          argument.call(
+            arguments: [::Code::Object::Argument.new(element)],
+            context: context,
+            io: io,
+          ).truthy?
+        end || ::Code::Object::Nothing.new
+      end
+
+      def reduce(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        raw.reduce do |acc, element|
+          argument.call(
+            arguments: [
+              ::Code::Object::Argument.new(acc),
+              ::Code::Object::Argument.new(element)
+            ],
+            context: context,
+            io: io,
+          )
+        end || ::Code::Object::Nothing.new
+      end
+
+      def each(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        raw.each do |element|
+          argument.call(
+            arguments: [::Code::Object::Argument.new(element)],
+            context: context,
+            io: io,
+          )
+        end
         self
       end
 
-      def join
-        raw.join
+      def select(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        ::Code::Object::List.new(
+          raw.select do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              context: context,
+              io: io,
+            ).truthy?
+          end
+        )
+      end
+
+      def map(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        ::Code::Object::List.new(
+          raw.map do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              context: context,
+              io: io,
+            )
+          end
+        )
+      end
+
+      def append(arguments)
+        sig(arguments, ::Code::Object)
+        raw << arguments.first.value
+        self
+      end
+
+      def first(arguments)
+        sig(arguments)
+        raw.first
+      end
+
+      def max(arguments)
+        sig(arguments)
+        raw.max || ::Code::Object::Nothing.new
       end
 
-      def ==(other)
-        raw == other.raw
+      def reverse(arguments)
+        sig(arguments)
+        ::Code::Object::List.new(raw.reverse)
       end
-      alias_method :eql?, :==
 
-      def hash
-        [self.class, raw].hash
+      def last(arguments)
+        sig(arguments)
+        raw.last
       end
     end
   end

data/lib/code/object/nothing.rb

@@ -1,21 +1,22 @@
 class Code
   class Object
     class Nothing < ::Code::Object
-      def to_s
-        ""
+      attr_reader :raw
+
+      def initialize
+        @raw = nil
       end
 
-      def inspect
-        "nothing"
+      def truthy?
+        false
       end
 
-      def ==(other)
-        other.is_a?(::Code::Object::Nothing)
+      def to_s
+        ""
       end
-      alias_method :eql?, :==
 
-      def hash
-        [self.class, nil].hash
+      def inspect
+        "nothing"
       end
     end
   end

data/lib/code/object/number.rb

@@ -0,0 +1,6 @@
+class Code
+  class Object
+    class Number < ::Code::Object
+    end
+  end
+end

data/lib/code/object/range.rb

@@ -0,0 +1,158 @@
+class Code
+  class Object
+    class Range < ::Code::Object
+      attr_reader :raw
+
+      def initialize(left, right, exclude_end: false)
+        @left = left
+        @right = right
+        @exclude_end = exclude_end
+        @raw = ::Range.new(left, right, exclude_end)
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        context = args.fetch(:context)
+        io = args.fetch(:io)
+
+        if operator == "any?"
+          any?(arguments, context: context, io: io)
+        elsif operator == "all?"
+          all?(arguments, context: context, io: io)
+        elsif operator == "each"
+          each(arguments, context: context, io: io)
+        elsif operator == "select"
+          select(arguments, context: context, io: io)
+        elsif operator == "map"
+          map(arguments, context: context, io: io)
+        elsif operator == "step"
+          step(arguments)
+        elsif operator == "to_list"
+          to_list(arguments)
+        elsif operator == "first"
+          first(arguments)
+        elsif operator == "last"
+          last(arguments)
+        else
+          super
+        end
+      end
+
+      def to_s
+        raw.to_s
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def any?(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        ::Code::Object::Boolean.new(
+          raw.any? do |element|
+            argument
+              .call(
+                arguments: [::Code::Object::Argument.new(element)],
+                context: context,
+                io: io,
+              )
+              .truthy?
+          end,
+        )
+      end
+
+      def all?(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        ::Code::Object::Boolean.new(
+          raw.all? do |element|
+            argument
+              .call(
+                arguments: [::Code::Object::Argument.new(element)],
+                context: context,
+                io: io,
+              )
+              .truthy?
+          end,
+        )
+      end
+
+      def each(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        raw.each do |element|
+          argument.call(
+            arguments: [::Code::Object::Argument.new(element)],
+            context: context,
+            io: io,
+          )
+        end
+        self
+      end
+
+      def select(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        ::Code::Object::List.new(
+          raw.select do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              context: context,
+              io: io,
+            ).truthy?
+          end
+        )
+      end
+
+      def map(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        ::Code::Object::List.new(
+          raw.map do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              context: context,
+              io: io,
+            )
+          end
+        )
+      end
+
+      def step(arguments)
+        sig(arguments, ::Code::Object::Number)
+        argument = arguments.first.value
+
+        list = ::Code::Object::List.new
+        element = @left
+        list << element
+
+        if @exlucde_end
+          list << element while (element = element + argument) < @right
+        else
+          list << element while (element = element + argument) <= @right
+        end
+
+        list
+      end
+
+      def to_list(arguments)
+        sig(arguments)
+        ::Code::Object::List.new(raw.to_a)
+      end
+
+      def first(arguments)
+        sig(arguments)
+        raw.first
+      end
+
+      def last(arguments)
+        sig(arguments)
+        raw.last
+      end
+    end
+  end
+end

data/lib/code/object/string.rb

@@ -1,5 +1,3 @@
-require "bigdecimal"
-
 class Code
   class Object
     class String < ::Code::Object
@@ -9,6 +7,29 @@ class Code
         @raw = string
       end
 
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+
+        if operator == "to_function"
+          to_function(arguments)
+        elsif operator == "+"
+          plus(arguments)
+        elsif operator == "reverse"
+          reverse(arguments)
+        else
+          super
+        end
+      end
+
+      def succ
+        ::Code::Object::String.new(raw.succ)
+      end
+
+      def to_sym
+        raw.to_sym
+      end
+
       def to_s
         raw
       end
@@ -17,13 +38,22 @@ class Code
         raw.inspect
       end
 
-      def ==(other)
-        raw == other.raw
+      private
+
+      def to_function(arguments)
+        sig(arguments)
+        Code.evaluate("(_) => { _.#{raw} }")
+      end
+
+      def plus(arguments)
+        sig(arguments, ::Code::Object::String)
+        other = arguments.first.value
+        ::Code::Object::String.new(raw + other.raw)
       end
-      alias_method :eql?, :==
 
-      def hash
-        [self.class, raw].hash
+      def reverse(arguments)
+        sig(arguments)
+        ::Code::Object::String.new(raw.reverse)
       end
     end
   end

data/lib/code/object.rb

@@ -1,11 +1,138 @@
 class Code
   class Object
-    def fetch(_key, default = ::Code::Object::Nothing.new)
-      default
+    include Comparable
+
+    def call(**args)
+      operator = args.fetch(:operator, nil)
+      arguments = args.fetch(:arguments, [])
+      if %w[== === !=].detect { |o| operator == o }
+        comparaison(operator.to_sym, arguments)
+      elsif operator == "<=>"
+        compare(arguments)
+      elsif operator == "&&"
+        and_operator(arguments)
+      elsif operator == "||"
+        or_operator(arguments)
+      else
+        raise ::Code::Error::Undefined.new(
+                "#{operator} not defined on #{inspect}",
+              )
+      end
+    end
+
+    def []=(key, value)
+      @attributes ||= {}
+      @attributes[key] = value
+    end
+
+    def [](key)
+      @attributes ||= {}
+      @attributes[key]
+    end
+
+    def key?(key)
+      @attributes ||= {}
+      @attributes.key?(key)
+    end
+
+    def truthy?
+      true
+    end
+
+    def falsy?
+      !truthy?
+    end
+
+    def <=>(other)
+      if respond_to?(:raw)
+        if other.respond_to?(:raw)
+          raw <=> other.raw
+        else
+          raw <=> other
+        end
+      else
+        other <=> self
+      end
+    end
+
+    def ==(other)
+      if respond_to?(:raw)
+        if other.respond_to?(:raw)
+          raw == other.raw
+        else
+          raw == other
+        end
+      else
+        other == self
+      end
+    end
+    alias_method :eql?, :==
+
+    def hash
+      if respond_to?(:raw)
+        [self.class, raw].hash
+      else
+        raise NotImplementedError
+      end
     end
 
     def to_s
       raise NotImplementedError
     end
+
+    private
+
+    def sig(actual_arguments, *expected_arguments)
+      if actual_arguments.size != expected_arguments.size
+        raise ::Code::Error::ArgumentError.new(
+                "Expected #{expected_arguments.size} arguments, " \
+                  "got #{actual_arguments.size} arguments",
+              )
+      end
+
+      expected_arguments.each.with_index do |expected_argument, index|
+        actual_argument = actual_arguments[index].value
+
+        if expected_argument.is_a?(Array)
+          if expected_argument.none? { |expected_arg|
+               actual_argument.is_a?(expected_arg)
+             }
+            raise ::Code::Error::TypeError.new(
+                    "Expected #{expected_argument}, got #{actual_argument.class}",
+                  )
+          end
+        else
+          if !actual_argument.is_a?(expected_argument)
+            raise ::Code::Error::TypeError.new(
+                    "Expected #{expected_argument}, got #{actual_argument.class}",
+                  )
+          end
+        end
+      end
+    end
+
+    def comparaison(operator, arguments)
+      sig(arguments, ::Code::Object)
+      other = arguments.first.value
+      ::Code::Object::Boolean.new(public_send(operator, other))
+    end
+
+    def compare(arguments)
+      sig(arguments, ::Code::Object)
+      other = arguments.first.value
+      ::Code::Object::Integer.new(self <=> other)
+    end
+
+    def and_operator(arguments)
+      sig(arguments, ::Code::Object)
+      other = arguments.first.value
+      truthy? ? other : self
+    end
+
+    def or_operator(arguments)
+      sig(arguments, ::Code::Object)
+      other = arguments.first.value
+      truthy? ? self : other
+    end
   end
 end

data/lib/code/parser/addition.rb

@@ -0,0 +1,29 @@
+class Code
+  class Parser
+    class Addition < Parslet::Parser
+      rule(:multiplication) { ::Code::Parser::Multiplication.new }
+
+      rule(:plus) { str("+") }
+      rule(:minus) { str("-") }
+
+      rule(:operator) { plus | minus }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:addition) do
+        (
+          multiplication.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                multiplication.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:addition) | multiplication
+      end
+
+      root(:addition)
+    end
+  end
+end

data/lib/code/parser/and_operator.rb

@@ -0,0 +1,28 @@
+class Code
+  class Parser
+    class AndOperator < Parslet::Parser
+      rule(:equality) { ::Code::Parser::Equality.new }
+
+      rule(:ampersand) { str("&") }
+
+      rule(:operator) { ampersand >> ampersand }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:and_operator) do
+        (
+          equality.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                equality.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:and_operator) | equality
+      end
+
+      root(:and_operator)
+    end
+  end
+end

data/lib/code/parser/bitwise_and.rb

@@ -0,0 +1,28 @@
+class Code
+  class Parser
+    class BitwiseAnd < Parslet::Parser
+      rule(:shift) { ::Code::Parser::Shift.new }
+
+      rule(:ampersand) { str("&") }
+
+      rule(:operator) { ampersand }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:bitwise_and) do
+        (
+          shift.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                shift.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:bitwise_and) | shift
+      end
+
+      root(:bitwise_and)
+    end
+  end
+end