code-ruby 0.5.6 → 0.6.1

data/lib/code/object/dictionary.rb

@@ -0,0 +1,641 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class Dictionary < ::Code::Object
+      attr_reader :raw
+
+      def initialize(raw = {})
+        @raw = raw
+      end
+
+      def self.name
+        "Dictionary"
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        globals = multi_fetch(args, *GLOBALS)
+        value = arguments.first&.value
+
+        case operator.to_s
+        when "<", "inferior"
+          sig(args) { Dictionary }
+          code_inferior(value)
+        when "<=", "inferior_or_equal"
+          sig(args) { Dictionary }
+          code_inferior_or_equal(value)
+        when "<=>", "compare"
+          sig(args) { Dictionary }
+          code_compare(value)
+        when ">", "superior"
+          sig(args) { Dictionary }
+          code_superior(value)
+        when ">=", "superior_or_equal"
+          sig(args) { Dictionary }
+          code_superior_or_equal(value)
+        when "[]", "at", "get"
+          sig(args) { Object }
+          code_get(value)
+        when "any?"
+          sig(args) { Function | Class }
+          code_any?(value, **globals)
+        when "clear"
+          sig(args)
+          code_clear
+        when "compact!"
+          sig(args)
+          code_compact!
+        when "compact"
+          sig(args)
+          code_compact
+        when "delete"
+          sig(args) { Object.repeat(1) }
+          code_delete(*arguments.map(&:value), **globals)
+        when "delete_if"
+          sig(args) { Function | Class }
+          code_delete_if(value, **globals)
+        when "delete_unless"
+          sig(args) { Function | Class }
+          code_delete_unless(value, **globals)
+        when "dig"
+          sig(args) { Object.repeat(1) }
+          code_dig(*arguments.map(&:value))
+        when "each"
+          sig(args) { Function }
+          code_each(value, **globals)
+        when "eight?"
+          sig(args)
+          code_eight?
+        when "empty?"
+          sig(args)
+          code_empty?
+        when "except"
+          sig(args) { Object.repeat(1) }
+          code_except(*arguments.map(&:value))
+        when "fetch"
+          sig(args) { Object.repeat(1) }
+          code_fetch(*arguments.map(&:value), **globals)
+        when "fetch_values"
+          sig(args) { Object.repeat(1) }
+          code_fetch_values(*arguments.map(&:value))
+        when "five?"
+          sig(args)
+          code_five?
+        when "flatten"
+          sig(args) { Integer.maybe }
+          code_flatten(value)
+        when "four?"
+          sig(args)
+          code_four?
+        when "has_key?"
+          sig(args) { Object }
+          code_has_key?(value)
+        when "has_value?"
+          sig(args) { Object }
+          code_has_value?(value)
+        when "invert"
+          sig(args)
+          code_invert
+        when "keep_if"
+          sig(args) { Function | Class }
+          code_keep_if(value, **globals)
+        when "keep_unless"
+          sig(args) { Function | Class }
+          code_keep_unless(value, **globals)
+        when "key"
+          sig(args) { [Object, Function.maybe] }
+          code_key(*arguments.map(&:value), **globals)
+        when "keys"
+          sig(args)
+          code_keys
+        when "merge"
+          sig(args) { [Dictionary.repeat, Function.maybe] }
+          code_merge(*arguments.map(&:value), **globals)
+        when "nine?"
+          sig(args)
+          code_nine?
+        when "one?"
+          sig(args)
+          code_one?
+        when "select!", "filter!"
+          sig(args) { Function | Class }
+          code_select!(value, **globals)
+        when "select", "filter"
+          sig(args) { Function | Class }
+          code_select(value, **globals)
+        when "seven?"
+          sig(args)
+          code_seven?
+        when "six?"
+          sig(args)
+          code_six?
+        when "size"
+          sig(args)
+          code_size
+        when "ten?"
+          sig(args)
+          code_ten?
+        when "three?"
+          sig(args)
+          code_three?
+        when "to_list"
+          sig(args)
+          code_to_list
+        when "transform_values"
+          sig(args) { Function }
+          code_transform_values(value, **globals)
+        when "two?"
+          sig(args)
+          code_two?
+        when "values"
+          sig(args)
+          code_values
+        when "zero?"
+          sig(args)
+          code_zero?
+        when ->(operator) { code_has_key?(String.new(operator)).truthy? }
+          result = code_fetch(operator)
+
+          if result.is_a?(Function)
+            result.call(**args.merge(operator: nil))
+          else
+            sig(args)
+            result
+          end
+        else
+          super
+        end
+      end
+
+      def code_any?(argument, **globals)
+        if argument.is_a?(Class)
+          Boolean.new(raw.any? { |_, value| value.is_a?(argument.raw) })
+        else
+          index = 0
+
+          Boolean.new(
+            raw.any? do |key, value|
+              argument
+                .call(
+                  arguments: [
+                    Argument.new(key),
+                    Argument.new(value),
+                    Argument.new(self),
+                    Argument.new(Integer.new(index))
+                  ],
+                  **globals
+                )
+                .truthy?
+                .tap { index += 1 }
+            end
+          )
+        end
+      end
+
+      def code_clear
+        @raw = {}
+        self
+      end
+
+      def code_compact
+        self.class.new(raw.dup.delete_if { |_, value| value.falsy? })
+      end
+
+      def code_compact!
+        raw.delete_if { |_, value| value.falsy? }
+        self
+      end
+
+      def code_compare(other)
+        Integer.new(raw <=> other.raw)
+      end
+
+      def code_delete(*arguments, index: Integer.new(0), **globals)
+        default =
+          (arguments.last if arguments.last.is_a?(Function) && arguments.size > 1)
+
+        arguments = arguments[..-2] if default
+
+        if arguments.one?
+          raw.delete(arguments.first) do
+            if default
+              default.call(
+                arguments: [
+                  Argument.new(arguments.first),
+                  Argument.new(self),
+                  Argument.new(index)
+                ],
+                **globals
+              )
+            else
+              raise(
+                Code::Error::KeyNotFound,
+                "#{arguments.first.inspect} not found on #{inspect}"
+              )
+            end
+          end
+        else
+          self.class.new(
+            arguments
+              .map
+              .with_index do |argument, index|
+                if default
+                  [
+                    argument,
+                    code_delete(
+                      argument,
+                      default,
+                      index: Integer.new(index),
+                      **globals
+                    )
+                  ]
+                else
+                  [
+                    argument,
+                    code_delete(argument, index: Integer.new(index), **globals)
+                  ]
+                end
+              end
+              .to_h
+          )
+        end
+      end
+
+      def code_delete_if(argument, **globals)
+        if argument.is_a?(Class)
+          raw.delete_if { |_, value| value.is_a?(argument.raw) }
+        else
+          raw.delete_if.with_index do |(key, value), index|
+            argument.call(
+              arguments: [
+                Argument.new(key),
+                Argument.new(value),
+                Argument.new(self),
+                Argument.new(Integer.new(index))
+              ],
+              **globals
+            ).truthy?
+          end
+        end
+
+        self
+      end
+
+      def code_delete_unless(argument, **globals)
+        if argument.is_a?(Class)
+          raw.delete_if { |_, value| !value.is_a?(argument.raw) }
+        else
+          raw.delete_if.with_index do |(key, value), index|
+            argument.call(
+              arguments: [
+                Argument.new(key),
+                Argument.new(value),
+                Argument.new(self),
+                Argument.new(Integer.new(index))
+              ],
+              **globals
+            ).falsy?
+          end
+        end
+
+        self
+      end
+
+      def code_dig(*arguments)
+        raw.dig(*arguments) || Nothing.new
+      end
+
+      def code_each(argument, **globals)
+        raw.each.with_index do |(key, value), index|
+          argument.call(
+            arguments: [
+              Argument.new(key),
+              Argument.new(value),
+              Argument.new(self),
+              Argument.new(Integer.new(index))
+            ],
+            **globals
+          )
+        end
+
+        self
+      end
+
+      def code_eight?
+        code_size.code_eight?
+      end
+
+      def code_empty?
+        Boolean.new(raw.empty?)
+      end
+
+      def code_except(*arguments)
+        self.class.new(raw.except(*arguments))
+      end
+
+      def code_fetch(*arguments, index: Integer.new(0), **globals)
+        default =
+          (arguments.last if arguments.last.is_a?(Function) && arguments.size > 1)
+
+        arguments = arguments[..-2] if default
+
+        if arguments.one?
+          raw.fetch(arguments.first) do
+            if default
+              default.call(
+                arguments: [
+                  Argument.new(arguments.first),
+                  Argument.new(self),
+                  Argument.new(index)
+                ],
+                **globals
+              )
+            else
+              raise(
+                Code::Error::KeyNotFound,
+                "#{arguments.first.inspect} not found on #{inspect}"
+              )
+            end
+          end
+        else
+          self.class.new(
+            arguments
+              .map
+              .with_index do |argument, index|
+                if default
+                  [
+                    argument,
+                    code_fetch(
+                      argument,
+                      default,
+                      index: Integer.new(index),
+                      **globals
+                    )
+                  ]
+                else
+                  [
+                    argument,
+                    code_fetch(argument, index: Integer.new(index), **globals)
+                  ]
+                end
+              end
+              .to_h
+          )
+        end
+      end
+
+      def code_fetch_values(*arguments)
+        List.new(raw.fetch_values(*arguments))
+      end
+
+      def code_five?
+        code_size.code_five?
+      end
+
+      def code_flatten(level = nil)
+        level ||= Integer.new(-1)
+        code_to_list.code_flatten(level)
+      end
+
+      def code_four?
+        code_size.code_four?
+      end
+
+      def code_get(key)
+        raw[key] || Nothing.new
+      end
+
+      def code_has_key?(key)
+        Boolean.new(raw.key?(key))
+      end
+
+      def code_has_value?(key)
+        Boolean.new(raw.value?(key))
+      end
+
+      def code_inferior(other)
+        Boolean.new(raw < other.raw)
+      end
+
+      def code_inferior_or_equal(other)
+        Boolean.new(raw <= other.raw)
+      end
+
+      def code_invert
+        self.class.new(raw.invert)
+      end
+
+      def code_keep_if(argument, **globals)
+        if argument.is_a?(Class)
+          raw.keep_if { |_, value| value.is_a?(argument.raw) }
+        else
+          raw.keep_if.with_index do |(key, value), index|
+            argument.call(
+              arguments: [
+                Argument.new(key),
+                Argument.new(value),
+                Argument.new(self),
+                Argument.new(Integer.new(index))
+              ],
+              **globals
+            ).truthy?
+          end
+        end
+
+        self
+      end
+
+      def code_keep_unless(argument, **globals)
+        if argument.is_a?(Class)
+          raw.keep_if { |_, value| !value.is_a?(argument.raw) }
+        else
+          raw.keep_if.with_index do |(key, value), index|
+            argument.call(
+              arguments: [
+                Argument.new(key),
+                Argument.new(value),
+                Argument.new(self),
+                Argument.new(Integer.new(index))
+              ],
+              **globals
+            ).falsy?
+          end
+        end
+
+        self
+      end
+
+      def code_key(value, function = nil, **globals)
+        if function
+          raw.key(value) ||
+            function.call(
+              arguments: [Argument.new(value), Argument.new(self)],
+              **globals
+            )
+        else
+          raw.key(value) || Nothing.new
+        end
+      end
+
+      def code_keys
+        List.new(raw.keys)
+      end
+
+      def code_merge(*arguments, **globals)
+        conflict =
+          (arguments.last if arguments.last.is_a?(Function) && arguments.size > 1)
+
+        arguments = arguments[..-2] if conflict
+
+        index = 0
+
+        self.class.new(
+          raw.merge(*arguments.map(&:raw)) do |key, old_value, new_value|
+            if conflict
+              conflict
+                .call(
+                  arguments: [
+                    Argument.new(key),
+                    Argument.new(old_value),
+                    Argument.new(new_value),
+                    Argument.new(self),
+                    Argument.new(Integer.new(index))
+                  ],
+                  **globals
+                )
+                .tap { index += 1 }
+            else
+              new_value.tap { index += 1 }
+            end
+          end
+        )
+      end
+
+      def code_nine?
+        code_size.code_nine?
+      end
+
+      def code_one?
+        code_size.code_one?
+      end
+
+      def code_select!(argument, **globals)
+        if argument.is_a?(Class)
+          raw.select! { |_, value| value.is_a?(argument.raw) }
+        else
+          raw.select!.with_index do |(key, value), index|
+            argument.call(
+              arguments: [
+                Argument.new(key),
+                Argument.new(value),
+                Argument.new(self),
+                Argument.new(Integer.new(index))
+              ],
+              **globals
+            ).truthy?
+          end
+        end
+
+        self
+      end
+
+      def code_select(argument, **globals)
+        if argument.is_a?(Class)
+          self.class.new(raw.select { |_, value| value.is_a?(argument.raw) })
+        else
+          self.class.new(
+            raw.select.with_index do |(key, value), index|
+              argument.call(
+                arguments: [
+                  Argument.new(key),
+                  Argument.new(value),
+                  Argument.new(self),
+                  Argument.new(Integer.new(index))
+                ],
+                **globals
+              ).truthy?
+            end
+          )
+        end
+      end
+
+      def code_set(key, value)
+        raw[key] = value
+        value
+      end
+
+      def code_seven?
+        code_size.code_seven?
+      end
+
+      def code_six?
+        code_size.code_six?
+      end
+
+      def code_size
+        Integer.new(raw.size)
+      end
+
+      def code_superior(other)
+        Boolean.new(raw > other.raw)
+      end
+
+      def code_superior_or_equal(other)
+        Boolean.new(raw >= other.raw)
+      end
+
+      def code_ten?
+        code_size.code_ten?
+      end
+
+      def code_three?
+        code_size.code_three?
+      end
+
+      def code_to_context
+        Context.new(raw)
+      end
+
+      def code_to_list
+        List.new(raw.to_a.map { |key_value| List.new(key_value) })
+      end
+
+      def code_transform_values(function, **globals)
+        self.class.new(
+          raw.transform_values.with_index do |value, index|
+            function.call(
+              arguments: [
+                Argument.new(value),
+                Argument.new(self),
+                Argument.new(Integer.new(index))
+              ],
+              **globals
+            )
+          end
+        )
+      end
+
+      def code_two?
+        code_size.code_two?
+      end
+
+      def code_values
+        List.new(raw.values)
+      end
+
+      def code_zero?
+        code_size.code_zero?
+      end
+
+      def inspect
+        to_s
+      end
+
+      def to_s
+        "{#{raw.map { |key, value| "#{key.inspect} => #{value.inspect}" }.join(", ")}}"
+      end
+    end
+  end
+end