code-ruby 0.2.4

data/lib/code/object/integer.rb

@@ -0,0 +1,116 @@
+class Code
+  class Object
+    class Integer < ::Code::Object::Number
+      attr_reader :raw
+
+      def initialize(whole, exponent: nil)
+        @raw = whole.to_i
+
+        if exponent
+          if exponent.is_a?(::Code::Object::Number)
+            @raw = @raw * 10**exponent.raw
+          else
+            raise ::Code::Error::TypeError.new("exponent is not a number")
+          end
+        end
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+
+        if operator == "even?"
+          even?(arguments)
+        elsif operator == "to_string"
+          code_to_s(arguments)
+        elsif operator == "*"
+          multiplication(arguments)
+        elsif operator == "/"
+          division(arguments)
+        elsif %w[% - + **].detect { |o| operator == o }
+          integer_or_decimal_operation(operator.to_sym, arguments)
+        elsif %w[> >= < <=].detect { |o| operator == o }
+          comparaison(operator.to_sym, arguments)
+        elsif %w[<< >> & | ^].detect { |o| operator == o }
+          integer_operation(operator.to_sym, arguments)
+        else
+          super
+        end
+      end
+
+      def +(other)
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw + other.raw)
+        elsif other.is_a?(::Code::Object::Decimal)
+          ::Code::Object::Decimal.new(raw + other.raw)
+        else
+          raise ::Code::Error::TypeError
+        end
+      end
+
+      def succ
+        ::Code::Object::Integer.new(raw + 1)
+      end
+
+      def to_s
+        raw.to_s
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def even?(arguments)
+        sig(arguments)
+        ::Code::Object::Boolean.new(raw.even?)
+      end
+
+      def code_to_s(arguments)
+        sig(arguments)
+        ::Code::Object::String.new(raw.to_s)
+      end
+
+      def multiplication(arguments)
+        sig(arguments, [::Code::Object::Number, ::Code::Object::String])
+        other = arguments.first.value
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw * other.raw)
+        elsif other.is_a?(::Code::Object::Decimal)
+          ::Code::Object::Decimal.new(raw * other.raw)
+        else
+          ::Code::Object::String.new(other.raw * raw)
+        end
+      end
+
+      def division(arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::Decimal.new(BigDecimal(raw) / other.raw)
+      end
+
+      def integer_or_decimal_operation(operator, arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw.public_send(operator, other.raw))
+        else
+          ::Code::Object::Decimal.new(raw.public_send(operator, other.raw))
+        end
+      end
+
+      def integer_operation(operator, arguments)
+        sig(arguments, ::Code::Object::Integer)
+        other = arguments.first.value
+        ::Code::Object::Integer.new(raw.public_send(operator, other.raw))
+      end
+
+      def comparaison(operator, arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::Boolean.new(raw.public_send(operator, other.raw))
+      end
+    end
+  end
+end

data/lib/code/object/list.rb

@@ -0,0 +1,217 @@
+class Code
+  class Object
+    class List < ::Code::Object
+      attr_reader :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
+
+      def inspect
+        to_s
+      end
+
+      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 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 reverse(arguments)
+        sig(arguments)
+        ::Code::Object::List.new(raw.reverse)
+      end
+
+      def last(arguments)
+        sig(arguments)
+        raw.last
+      end
+    end
+  end
+end

data/lib/code/object/nothing.rb

@@ -0,0 +1,23 @@
+class Code
+  class Object
+    class Nothing < ::Code::Object
+      attr_reader :raw
+
+      def initialize
+        @raw = nil
+      end
+
+      def truthy?
+        false
+      end
+
+      def to_s
+        ""
+      end
+
+      def inspect
+        "nothing"
+      end
+    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
+          while (element = element + argument) < @right
+            list << element
+          end
+        else
+          while (element = element + argument) <= @right
+            list << element
+          end
+        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

@@ -0,0 +1,68 @@
+class Code
+  class Object
+    class String < ::Code::Object
+      attr_reader :raw
+
+      def initialize(string)
+        @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 == "*"
+          multiplication(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
+
+      def inspect
+        raw.inspect
+      end
+
+      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
+
+      def multiplication(arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::String.new(raw * other.raw)
+      end
+
+      def reverse(arguments)
+        sig(arguments)
+        ::Code::Object::String.new(raw.reverse)
+      end
+    end
+  end
+end

data/lib/code/object.rb

@@ -0,0 +1,130 @@
+class Code
+  class Object
+    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)
+        other.respond_to?(:raw) ? raw <=> other.raw : raw <=> other
+      else
+        other <=> self
+      end
+    end
+
+    def ==(other)
+      if respond_to?(:raw)
+        other.respond_to?(:raw) ? raw == other.raw : raw == other
+      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