language-ruby 0.5.5 → 0.6.0

data/lib/code/object/list.rb

@@ -1,207 +0,0 @@
-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, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
-        value = arguments.first&.value
-
-        if operator == "any?"
-          sig(arguments) { ::Code::Object::Function }
-          any?(value, **globals)
-        elsif operator == "none?"
-          sig(arguments) { ::Code::Object::Function }
-          none?(value, **globals)
-        elsif operator == "detect"
-          sig(arguments) { ::Code::Object::Function }
-          detect(value, **globals)
-        elsif operator == "reduce"
-          sig(arguments) { ::Code::Object::Function }
-          reduce(value, **globals)
-        elsif operator == "each"
-          sig(arguments) { ::Code::Object::Function }
-          each(value, **globals)
-        elsif operator == "select"
-          sig(arguments) { ::Code::Object::Function }
-          select(value, **globals)
-        elsif operator == "map"
-          sig(arguments) { ::Code::Object::Function }
-          map(value, **globals)
-        elsif operator == "max_by"
-          sig(arguments) { ::Code::Object::Function }
-          max_by(value, **globals)
-        elsif operator == "max"
-          sig(arguments)
-          max
-        elsif operator == "flatten"
-          sig(arguments)
-          flatten
-        elsif operator == "reverse"
-          sig(arguments)
-          reverse
-        elsif operator == "first"
-          sig(arguments)
-          first
-        elsif operator == "last"
-          sig(arguments)
-          last
-        elsif operator == "<<"
-          sig(arguments) { ::Code::Object }
-          append(value)
-        elsif operator == "include?"
-          sig(arguments) { ::Code::Object }
-          include?(value)
-        else
-          super
-        end
-      end
-
-      def flatten
-        ::Code::Object::List.new(
-          raw.reduce([]) do |acc, element|
-            if element.is_a?(::Code::Object::List)
-              acc + element.flatten.raw
-            else
-              acc + [element]
-            end
-          end
-        )
-      end
-
-      def deep_dup
-        ::Code::Object::List.new(raw.deep_dup)
-      end
-
-      def <<(other)
-        raw << other
-        self
-      end
-
-      def to_s
-        "[#{raw.map(&:inspect).join(", ")}]"
-      end
-
-      def inspect
-        to_s
-      end
-
-      private
-
-      def any?(argument, **globals)
-        ::Code::Object::Boolean.new(
-          raw.any? do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
-          end
-        )
-      end
-
-      def none?(argument, **globals)
-        ::Code::Object::Boolean.new(
-          raw.none? do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
-          end
-        )
-      end
-
-      def max_by(argument, **globals)
-        raw.max_by do |element|
-          argument.call(
-            arguments: [::Code::Object::Argument.new(element)],
-            **globals
-          )
-        end || ::Code::Object::Nothing.new
-      end
-
-      def detect(argument, **globals)
-        raw.detect do |element|
-          argument.call(
-            arguments: [::Code::Object::Argument.new(element)],
-            **globals
-          ).truthy?
-        end || ::Code::Object::Nothing.new
-      end
-
-      def reduce(argument, **globals)
-        raw.reduce do |acc, element|
-          argument.call(
-            arguments: [
-              ::Code::Object::Argument.new(acc),
-              ::Code::Object::Argument.new(element)
-            ],
-            **globals
-          )
-        end || ::Code::Object::Nothing.new
-      end
-
-      def each(argument, **globals)
-        raw.each do |element|
-          argument.call(
-            arguments: [::Code::Object::Argument.new(element)],
-            **globals
-          )
-        end
-        self
-      end
-
-      def select(argument, **globals)
-        ::Code::Object::List.new(
-          raw.select do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
-          end
-        )
-      end
-
-      def map(argument, **globals)
-        ::Code::Object::List.new(
-          raw.map do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            )
-          end
-        )
-      end
-
-      def append(other)
-        raw << other
-        self
-      end
-
-      def include?(other)
-        ::Code::Object::Boolean.new(raw.include?(other))
-      end
-
-      def first
-        raw.first || ::Code::Object::Nothing.new
-      end
-
-      def max
-        raw.max || ::Code::Object::Nothing.new
-      end
-
-      def reverse
-        ::Code::Object::List.new(raw.reverse)
-      end
-
-      def last
-        raw.last || ::Code::Object::Nothing.new
-      end
-    end
-  end
-end

data/lib/code/object/nothing.rb

@@ -1,23 +0,0 @@
-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

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

data/lib/code/object/range.rb

@@ -1,146 +0,0 @@
-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, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
-        value = arguments.first&.value
-
-        if operator == "any?"
-          sig(arguments) { ::Code::Object::Function }
-          any?(value, **globals)
-        elsif operator == "all?"
-          sig(arguments) { ::Code::Object::Function }
-          all?(value, **globals)
-        elsif operator == "each"
-          sig(arguments) { ::Code::Object::Function }
-          each(value, **globals)
-        elsif operator == "select"
-          sig(arguments) { ::Code::Object::Function }
-          select(value, **globals)
-        elsif operator == "map"
-          sig(arguments) { ::Code::Object::Function }
-          map(value, **globals)
-        elsif operator == "step"
-          sig(arguments) { ::Code::Object::Number }
-          step(value)
-        elsif operator == "to_list"
-          sig(arguments)
-          to_list
-        elsif operator == "first"
-          sig(arguments)
-          first
-        elsif operator == "last"
-          sig(arguments)
-          last
-        else
-          super
-        end
-      end
-
-      def to_s
-        raw.to_s
-      end
-
-      def inspect
-        to_s
-      end
-
-      private
-
-      def any?(argument, **globals)
-        ::Code::Object::Boolean.new(
-          raw.any? do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
-          end
-        )
-      end
-
-      def all?(argument, **globals)
-        ::Code::Object::Boolean.new(
-          raw.all? do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
-          end
-        )
-      end
-
-      def each(argument, **globals)
-        raw.each do |element|
-          argument.call(
-            arguments: [::Code::Object::Argument.new(element)],
-            **globals
-          )
-        end
-        self
-      end
-
-      def select(argument, **globals)
-        ::Code::Object::List.new(
-          raw.select do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
-          end
-        )
-      end
-
-      def map(argument, **globals)
-        ::Code::Object::List.new(
-          raw.map do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            )
-          end
-        )
-      end
-
-      def step(argument)
-        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
-        ::Code::Object::List.new(raw.to_a)
-      end
-
-      def first
-        raw.first
-      end
-
-      def last
-        raw.last
-      end
-    end
-  end
-end

data/lib/code/object/ruby_function.rb

@@ -1,31 +0,0 @@
-class Code
-  class Object
-    class RubyFunction < ::Code::Object::Function
-      attr_reader :raw
-
-      def initialize(raw)
-        @raw = raw
-      end
-
-      private
-
-      def call_function(args:, globals:)
-        regular_arguments =
-          args
-            .select(&:regular?)
-            .map(&:value)
-            .map { |argument| ::Code::Ruby.from_code(argument) }
-
-        keyword_arguments =
-          args
-            .select(&:keyword?)
-            .map do |argument|
-              [argument.name.to_sym, ::Code::Ruby.from_code(argument.value)]
-            end
-            .to_h
-
-        ::Code::Ruby.to_code(raw.call(*regular_arguments, **keyword_arguments))
-      end
-    end
-  end
-end

data/lib/code/object/string.rb

@@ -1,102 +0,0 @@
-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, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
-        value = arguments.first&.value
-
-        if operator == "&" || operator == "to_function"
-          sig(arguments)
-          to_function(**globals)
-        elsif operator == "+"
-          sig(arguments) { ::Code::Object }
-          plus(value)
-        elsif operator == "*"
-          sig(arguments) { ::Code::Object::Number }
-          multiplication(value)
-        elsif operator == "reverse"
-          sig(arguments)
-          reverse
-        elsif operator == "downcase"
-          sig(arguments)
-          downcase
-        elsif operator == "include?"
-          sig(arguments) { ::Code::Object::String }
-          include?(value)
-        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(**globals)
-        ::Code::Node::Code.new(
-          [
-            {
-              function: {
-                parameters: [{ name: "_" }],
-                body: [
-                  {
-                    chained_call: {
-                      first: {
-                        call: {
-                          name: "_"
-                        }
-                      },
-                      others: [{ call: { name: raw } }]
-                    }
-                  }
-                ]
-              }
-            }
-          ]
-        ).evaluate(**globals)
-      end
-
-      def plus(other)
-        ::Code::Object::String.new(raw + other.to_s)
-      end
-
-      def multiplication(other)
-        ::Code::Object::String.new(raw * other.raw)
-      end
-
-      def reverse
-        ::Code::Object::String.new(raw.reverse)
-      end
-
-      def downcase
-        ::Code::Object::String.new(raw.downcase)
-      end
-
-      def include?(value)
-        ::Code::Object::Boolean.new(raw.include?(value.raw))
-      end
-    end
-  end
-end

data/lib/code/object.rb

@@ -1,197 +0,0 @@
-class Code
-  class Object
-    include Comparable
-
-    def call(**args)
-      operator = args.fetch(:operator, nil)
-      arguments = args.fetch(:arguments, [])
-      value = arguments.first&.value
-
-      if operator == "=="
-        sig(arguments) { ::Code::Object }
-        equal(value)
-      elsif operator == "==="
-        sig(arguments) { ::Code::Object }
-        strict_equal(value)
-      elsif operator == "!="
-        sig(arguments) { ::Code::Object }
-        different(value)
-      elsif operator == "<=>"
-        sig(arguments) { ::Code::Object }
-        compare(value)
-      elsif operator == "&&" || operator == "and"
-        sig(arguments) { ::Code::Object }
-        and_operator(value)
-      elsif operator == "||" || operator == "or"
-        sig(arguments) { ::Code::Object }
-        or_operator(value)
-      elsif operator == "!" || operator == "not"
-        sig(arguments)
-        exclamation_point
-      elsif operator == "+"
-        sig(arguments)
-        self
-      elsif operator == ".."
-        sig(arguments) { ::Code::Object }
-        inclusive_range(value)
-      elsif operator == "..."
-        sig(arguments) { ::Code::Object }
-        exclusive_range(value)
-      elsif operator == "to_string"
-        sig(arguments)
-        to_string
-      else
-        raise(
-          Code::Error::Undefined.new("#{operator} not defined on #{inspect}")
-        )
-      end
-    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.new(self.class.name)
-      end
-    end
-
-    def to_s
-      raise NotImplementedError.new(self.class.name)
-    end
-
-    private
-
-    def multi_fetch(hash, *keys)
-      keys.map { |key| [key, hash.fetch(key)] }.to_h
-    end
-
-    def deep_dup(object)
-      if object.is_a?(Array)
-        object.map { |element| deep_dup(o) }
-      elsif object.is_a?(Hash)
-        object.map { |key, value| [deep_dup(key), deep_dup(value)] }.to_h
-      elsif object.is_a?(::Code::Object::List)
-        ::Code::Object::List.new(object.raw.map { |element| deep_dup(o) })
-      elsif object.is_a?(::Code::Object::Dictionnary)
-        ::Code::Object::Dictionnary.new(
-          object.raw.map { |key, value| [deep_dup(key), deep_dup(value)] }.to_h
-        )
-      else
-        object.dup
-      end
-    end
-
-    def sig(actual_arguments, &block)
-      if block
-        expected_arguments = block.call
-        expected_arguments = [
-          expected_arguments
-        ] unless expected_arguments.is_a?(Array)
-      else
-        expected_arguments = []
-      end
-
-      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 equal(other)
-      ::Code::Object::Boolean.new(self == other)
-    end
-
-    def strict_equal(other)
-      ::Code::Object::Boolean.new(self === other)
-    end
-
-    def different(other)
-      ::Code::Object::Boolean.new(self != other)
-    end
-
-    def compare(other)
-      ::Code::Object::Integer.new(self <=> other)
-    end
-
-    def and_operator(other)
-      truthy? ? other : self
-    end
-
-    def or_operator(other)
-      truthy? ? self : other
-    end
-
-    def to_string
-      ::Code::Object::String.new(to_s)
-    end
-
-    def inclusive_range(value)
-      ::Code::Object::Range.new(self, value, exclude_end: false)
-    end
-
-    def exclusive_range(value)
-      ::Code::Object::Range.new(self, value, exclude_end: true)
-    end
-
-    def exclamation_point
-      if truthy?
-        ::Code::Object::Boolean.new(false)
-      else
-        ::Code::Object::Boolean.new(true)
-      end
-    end
-  end
-end