code-ruby 0.5.6 → 0.6.0

data/lib/code/object/list.rb

@@ -1,206 +1,208 @@
+# frozen_string_literal: true
+
 class Code
   class Object
     class List < ::Code::Object
       attr_reader :raw
 
       def initialize(raw = [])
-        @raw = raw
+        @raw = raw.to_a
+      end
+
+      def self.name
+        "List"
       end
 
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
+        globals = multi_fetch(args, *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)
+        case operator.to_s
+        when "sort"
+          sig(args)
+          code_sort
+        when "<<", "append"
+          sig(args) { Object }
+          code_append(value)
+        when "any?"
+          sig(args) { Function }
+          code_any?(value, **globals)
+        when "detect"
+          sig(args) { Function }
+          code_detect(value, **globals)
+        when "each"
+          sig(args) { Function }
+          code_each(value, **globals)
+        when "first"
+          sig(args)
+          code_first
+        when "flatten"
+          sig(args) { Integer.maybe }
+          code_flatten
+        when "include?"
+          sig(args) { Object }
+          code_include?(value)
+        when "last"
+          sig(args)
+          code_last
+        when "map"
+          sig(args) { Function }
+          code_map(value, **globals)
+        when "max"
+          sig(args)
+          code_max
+        when "max_by"
+          sig(args) { Function }
+          code_max_by(value, **globals)
+        when "none?"
+          sig(args) { Function }
+          code_none?(value, **globals)
+        when "reduce"
+          sig(args) { Function }
+          code_reduce(value, **globals)
+        when "reverse"
+          sig(args)
+          code_reverse
+        when "select"
+          sig(args) { Function }
+          code_select(value, **globals)
+        when "size"
+          sig(args)
+          code_size
+        when "uniq"
+          sig(args)
+          code_uniq
         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
+      def code_any?(argument, **globals)
+        Boolean.new(
+          raw.any? do |element|
+            argument.call(arguments: [Argument.new(element)], **globals).truthy?
           end
         )
       end
 
-      def deep_dup
-        ::Code::Object::List.new(raw.deep_dup)
-      end
-
-      def <<(other)
+      def code_append(other)
         raw << other
         self
       end
 
-      def to_s
-        "[#{raw.map(&:inspect).join(", ")}]"
+      def code_detect(argument, **globals)
+        raw.detect do |element|
+          argument.call(arguments: [Argument.new(element)], **globals).truthy?
+        end || Nothing.new
       end
 
-      def inspect
-        to_s
+      def code_each(argument, **globals)
+        raw.each do |element|
+          argument.call(arguments: [Argument.new(element)], **globals)
+        end
+        self
       end
 
-      private
+      def code_first
+        raw.first || Nothing.new
+      end
 
-      def any?(argument, **globals)
-        ::Code::Object::Boolean.new(
-          raw.any? do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
+      def code_flatten(level = nil)
+        level ||= Integer.new(-1)
+        level = level.raw if level.is_a?(Integer)
+
+        List.new(
+          raw.reduce([]) do |acc, element|
+            element = element.to_list if element.is_a?(Dictionary)
+
+            if element.is_a?(List) && level != 0
+              if level.positive?
+                acc + element.code_flatten(level - 1).raw
+              else
+                acc + element.code_flatten(level).raw
+              end
+            else
+              acc + [element]
+            end
           end
         )
       end
 
-      def none?(argument, **globals)
-        ::Code::Object::Boolean.new(
-          raw.none? do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
+      def code_include?(other)
+        Boolean.new(raw.include?(other))
+      end
+
+      def code_last
+        raw.last || Nothing.new
+      end
+
+      def code_map(argument, **globals)
+        List.new(
+          raw.map do |element|
+            argument.call(arguments: [Argument.new(element)], **globals)
           end
         )
       end
 
-      def max_by(argument, **globals)
+      def code_max
+        raw.max || Nothing.new
+      end
+
+      def code_max_by(argument, **globals)
         raw.max_by do |element|
-          argument.call(
-            arguments: [::Code::Object::Argument.new(element)],
-            **globals
-          )
-        end || ::Code::Object::Nothing.new
+          argument.call(arguments: [Argument.new(element)], **globals)
+        end || 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
+      def code_none?(argument, **globals)
+        Boolean.new(
+          raw.none? do |element|
+            argument.call(arguments: [Argument.new(element)], **globals).truthy?
+          end
+        )
       end
 
-      def reduce(argument, **globals)
+      def code_reduce(argument, **globals)
         raw.reduce do |acc, element|
           argument.call(
-            arguments: [
-              ::Code::Object::Argument.new(acc),
-              ::Code::Object::Argument.new(element)
-            ],
+            arguments: [Argument.new(acc), Argument.new(element)],
             **globals
           )
-        end || ::Code::Object::Nothing.new
+        end || Nothing.new
       end
 
-      def each(argument, **globals)
-        raw.each do |element|
-          argument.call(
-            arguments: [::Code::Object::Argument.new(element)],
-            **globals
-          )
-        end
-        self
+      def code_reverse
+        List.new(raw.reverse)
       end
 
-      def select(argument, **globals)
-        ::Code::Object::List.new(
+      def code_select(argument, **globals)
+        List.new(
           raw.select do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            ).truthy?
+            argument.call(arguments: [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
-        )
+      def code_sort
+        List.new(raw.sort)
       end
 
-      def append(other)
-        raw << other
-        self
+      def code_size
+        Integer.new(raw.size)
       end
 
-      def include?(other)
-        ::Code::Object::Boolean.new(raw.include?(other))
+      def code_uniq
+        List.new(raw.uniq)
       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)
+      def inspect
+        to_s
       end
 
-      def last
-        raw.last || ::Code::Object::Nothing.new
+      def to_s
+        "[#{raw.map(&:inspect).join(", ")}]"
       end
     end
   end

data/lib/code/object/nothing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   class Object
     class Nothing < ::Code::Object
@@ -7,16 +9,20 @@ class Code
         @raw = nil
       end
 
-      def truthy?
-        false
+      def self.name
+        "Nothing"
+      end
+
+      def inspect
+        "nothing"
       end
 
       def to_s
         ""
       end
 
-      def inspect
-        "nothing"
+      def truthy?
+        false
       end
     end
   end

data/lib/code/object/number.rb

@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
 class Code
   class Object
-    class Number < ::Code::Object
+    class Number < Object
+      def self.name
+        "Number"
+      end
     end
   end
 end

data/lib/code/object/range.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 class Code
   class Object
-    class Range < ::Code::Object
-      attr_reader :raw
+    class Range < Object
+      attr_reader :raw, :exclude_end, :left, :right
 
       def initialize(left, right, exclude_end: false)
         @left = left
@@ -10,136 +12,131 @@ class Code
         @raw = ::Range.new(left, right, exclude_end)
       end
 
+      def self.name
+        "Range"
+      end
+
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
+        globals = multi_fetch(args, *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
+        case operator.to_s
+        when "all?"
+          sig(args) { Function }
+          code_all?(value, **globals)
+        when "any?"
+          sig(args) { Function }
+          code_any?(value, **globals)
+        when "each"
+          sig(args) { Function }
+          code_each(value, **globals)
+        when "first"
+          sig(args)
+          code_first
+        when "last"
+          sig(args)
+          code_last
+        when "map"
+          sig(args) { Function }
+          code_map(value, **globals)
+        when "select"
+          sig(args) { Function }
+          code_select(value, **globals)
+        when "step"
+          sig(args) { Number }
+          code_step(value)
+        when "to_list"
+          sig(args)
+          code_to_list
         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?
+      def code_all?(argument, **globals)
+        Boolean.new(
+          raw.all? do |element|
+            argument.call(arguments: [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?
+      def code_any?(argument, **globals)
+        Boolean.new(
+          raw.any? do |element|
+            argument.call(arguments: [Argument.new(element)], **globals).truthy?
           end
         )
       end
 
-      def each(argument, **globals)
+      def code_each(argument, **globals)
         raw.each do |element|
-          argument.call(
-            arguments: [::Code::Object::Argument.new(element)],
-            **globals
-          )
+          argument.call(arguments: [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?
+      def code_first
+        raw.first || Nothing.new
+      end
+
+      def code_last
+        raw.last || Nothing.new
+      end
+
+      def code_map(argument, **globals)
+        List.new(
+          raw.map do |element|
+            argument.call(arguments: [Argument.new(element)], **globals)
           end
         )
       end
 
-      def map(argument, **globals)
-        ::Code::Object::List.new(
-          raw.map do |element|
-            argument.call(
-              arguments: [::Code::Object::Argument.new(element)],
-              **globals
-            )
+      def code_select(argument, **globals)
+        List.new(
+          raw.select do |element|
+            argument.call(arguments: [Argument.new(element)], **globals).truthy?
           end
         )
       end
 
-      def step(argument)
-        list = ::Code::Object::List.new
-        element = @left
-        list << element
+      def code_step(argument)
+        list = List.new
+        element = left
+        list.code_append(element)
 
-        if @exlucde_end
-          while (element = element + argument) < @right
-            list << element
+        element = element.code_plus(argument)
+        if exclude_end?
+          while element.code_inferior(right).truthy?
+            list.code_append(element)
+            element = element.code_plus(argument)
           end
         else
-          while (element = element + argument) <= @right
-            list << element
+          while element.code_inferior_or_equal(right).truthy?
+            list.code_append(element)
+            element = element.code_plus(argument)
           end
         end
 
         list
       end
 
-      def to_list
-        ::Code::Object::List.new(raw.to_a)
+      def code_to_list
+        List.new(raw.to_a)
       end
 
-      def first
-        raw.first
+      def exclude_end?
+        !!exclude_end
       end
 
-      def last
-        raw.last
+      def inspect
+        to_s
+      end
+
+      def to_s
+        raw.to_s
       end
     end
   end

data/lib/code/object/ruby_function.rb

@@ -1,30 +1,35 @@
+# frozen_string_literal: true
+
 class Code
   class Object
-    class RubyFunction < ::Code::Object::Function
+    class RubyFunction < Function
       attr_reader :raw
 
       def initialize(raw)
         @raw = raw
       end
 
-      private
+      def self.name
+        "RubyFunction"
+      end
 
-      def call_function(args:, globals:)
+      # TODO: fix / refactor
+      def code_call(args:, globals:)
         regular_arguments =
           args
             .select(&:regular?)
             .map(&:value)
-            .map { |argument| ::Code::Ruby.from_code(argument) }
+            .map { |argument| Ruby.from_code(argument) }
 
         keyword_arguments =
           args
             .select(&:keyword?)
             .map do |argument|
-              [argument.name.to_sym, ::Code::Ruby.from_code(argument.value)]
+              [argument.name.to_sym, Ruby.from_code(argument.value)]
             end
             .to_h
 
-        ::Code::Ruby.to_code(raw.call(*regular_arguments, **keyword_arguments))
+        Ruby.to_code(raw.call(*regular_arguments, **keyword_arguments))
       end
     end
   end