code-ruby 3.1.2 → 4.0.1

data/lib/code/object/nothing.rb

@@ -3,10 +3,59 @@
 class Code
   class Object
     class Nothing < Object
+      CLASS_DOCUMENTATION = {
+        name: "Nothing",
+        description: "represents no value.",
+        examples: %w[nothing Nothing.new Nothing.new(1)]
+      }.freeze
+      INSTANCE_FUNCTIONS = {
+        "empty?" => {
+          name: "empty?",
+          description: "returns true because nothing has no contents.",
+          examples: %w[nothing.empty? Nothing.new.empty? Nothing.new(1).empty?]
+        },
+        "to_string" => {
+          name: "to_string",
+          description: "returns an empty string for nothing.",
+          examples: %w[
+            nothing.to_string
+            Nothing.new.to_string
+            Nothing.new(1).to_string
+          ]
+        },
+        "inspect" => {
+          name: "inspect",
+          description: "returns the source string for nothing.",
+          examples: %w[
+            nothing.inspect
+            Nothing.new.inspect
+            Nothing.new(1).inspect
+          ]
+        }
+      }.freeze
+
+      def self.function_documentation(scope)
+        return INSTANCE_FUNCTIONS if scope == :instance
+
+        {}
+      end
+
       def initialize(*_args, **_kargs, &_block)
         self.raw = nil
       end
 
+      def call(**args)
+        code_operator = args.fetch(:operator, nil).to_code
+
+        case code_operator.to_s
+        when "empty?"
+          sig(args)
+          code_empty?
+        else
+          super
+        end
+      end
+
       def truthy?
         false
       end
@@ -19,6 +68,10 @@ class Code
         true
       end
 
+      def code_empty?
+        Boolean.new(true)
+      end
+
       def code_to_string
         String.new
       end

data/lib/code/object/number.rb

@@ -3,6 +3,126 @@
 class Code
   class Object
     class Number < Object
+      CLASS_DOCUMENTATION = {
+        name: "Number",
+        description:
+          "represents numeric behavior shared by integers and decimals.",
+        examples: [
+          "Number.documentation.name",
+          "Number.instance_functions.keys.include?(:between?)",
+          "1.5.clamp(0, 1)"
+        ]
+      }.freeze
+      INSTANCE_FUNCTIONS = {
+        "between?" => {
+          name: "between?",
+          description: "returns whether the number is within inclusive bounds.",
+          examples: [
+            "2.between?(1, 3)",
+            "1.5.between?(1, 2)",
+            "4.between?(1, 3)"
+          ]
+        },
+        "clamp" => {
+          name: "clamp",
+          description: "returns the number limited to inclusive bounds.",
+          examples: ["5.clamp(1, 3)", "0.clamp(1, 3)", "2.5.clamp(1, 3)"]
+        },
+        "divide" => {
+          name: "divide",
+          description:
+            "returns floor division of the number by another number.",
+          examples: %w[5.divide(2) 10.divide(3) 9.5.divide(2)]
+        },
+        "divide_modulo" => {
+          name: "divide_modulo",
+          description: "returns floor division and modulo as a list.",
+          examples: %w[
+            5.divide_modulo(2)
+            10.divide_modulo(3)
+            9.5.divide_modulo(2)
+          ]
+        },
+        "next" => {
+          name: "next",
+          description: "returns the number plus one.",
+          examples: %w[1.next 1.5.next -1.next]
+        },
+        "successor" => {
+          name: "successor",
+          description: "returns the number plus one, matching next.",
+          examples: %w[1.successor 1.5.successor -1.successor]
+        },
+        "previous" => {
+          name: "previous",
+          description: "returns the number minus one.",
+          examples: %w[1.previous 1.5.previous -1.previous]
+        },
+        "predecessor" => {
+          name: "predecessor",
+          description: "returns the number minus one, matching previous.",
+          examples: %w[1.predecessor 1.5.predecessor -1.predecessor]
+        },
+        "remainder" => {
+          name: "remainder",
+          description: "returns the remainder from division by another number.",
+          examples: %w[5.remainder(2) 10.remainder(3) 9.5.remainder(2)]
+        }
+      }.freeze
+
+      def self.function_documentation(scope)
+        return INSTANCE_FUNCTIONS if scope == :instance
+
+        {}
+      end
+
+      def code_between?(min, max)
+        code_min = min.to_code
+        code_max = max.to_code
+
+        Boolean.new(raw.between?(code_min.raw, code_max.raw))
+      end
+
+      def code_clamp(min, max)
+        code_min = min.to_code
+        code_max = max.to_code
+
+        self.class.new(raw.clamp(code_min.raw, code_max.raw))
+      end
+
+      def code_divide(other)
+        code_other = other.to_code
+
+        Integer.new(raw.div(code_other.raw))
+      end
+
+      def code_divide_modulo(other)
+        code_other = other.to_code
+
+        List.new(raw.divmod(code_other.raw))
+      end
+
+      def code_next
+        code_plus(Integer.new(1))
+      end
+
+      def code_previous
+        code_minus(Integer.new(1))
+      end
+
+      def code_remainder(other)
+        code_other = other.to_code
+
+        self.class.new(raw.remainder(code_other.raw))
+      end
+
+      def code_successor
+        code_next
+      end
+
+      def code_predecessor
+        code_previous
+      end
     end
   end
 end

data/lib/code/object/parameter.rb

@@ -3,6 +3,147 @@
 class Code
   class Object
     class Parameter < Dictionary
+      CLASS_DOCUMENTATION = {
+        name: "Parameter",
+        description:
+          "describes one function parameter with its name, kind flags, and default value.",
+        examples: [
+          "((name) => { name }).parameters.first",
+          "((name:) => { name }).parameters.first.keyword?",
+          "((name = :a) => { name }).parameters.first.default"
+        ]
+      }.freeze
+      INSTANCE_FUNCTIONS = {
+        "name" => {
+          name: "name",
+          description: "returns the parameter identifier name.",
+          examples: [
+            "((name) => { name }).parameters.first.name",
+            "((name = :a) => { name }).parameters.first.name",
+            "((...values) => { values }).parameters.first.name"
+          ]
+        },
+        "regular?" => {
+          name: "regular?",
+          description:
+            "returns whether the parameter is not a keyword parameter.",
+          examples: [
+            "((name) => { name }).parameters.first.regular?",
+            "((name:) => { name }).parameters.first.regular?",
+            "((...values) => { values }).parameters.first.regular?"
+          ]
+        },
+        "keyword?" => {
+          name: "keyword?",
+          description:
+            "returns whether the parameter is a named keyword parameter.",
+          examples: [
+            "((name:) => { name }).parameters.first.keyword?",
+            "((name) => { name }).parameters.first.keyword?",
+            "((**options) => { options }).parameters.first.keyword?"
+          ]
+        },
+        "regular_splat?" => {
+          name: "regular_splat?",
+          description:
+            "returns whether the parameter captures positional arguments with *.",
+          examples: [
+            "((...values) => { values }).parameters.first.regular_splat?",
+            "((*values) => { values }).parameters.first.regular_splat?",
+            "((name) => { name }).parameters.first.regular_splat?"
+          ]
+        },
+        "keyword_splat?" => {
+          name: "keyword_splat?",
+          description:
+            "returns whether the parameter captures keyword arguments with **.",
+          examples: [
+            "((**options) => { options }).parameters.first.keyword_splat?",
+            "((name:) => { name }).parameters.first.keyword_splat?",
+            "((name) => { name }).parameters.first.keyword_splat?"
+          ]
+        },
+        "block?" => {
+          name: "block?",
+          description:
+            "returns whether the parameter captures one function argument with &.",
+          examples: [
+            "((&block) => { block }).parameters.first.block?",
+            "((name) => { name }).parameters.first.block?",
+            "((&&blocks) => { blocks }).parameters.first.block?"
+          ]
+        },
+        "blocks?" => {
+          name: "blocks?",
+          description:
+            "returns whether the parameter captures remaining function arguments with &&.",
+          examples: [
+            "((&&blocks) => { blocks }).parameters.first.blocks?",
+            "((&block) => { block }).parameters.first.blocks?",
+            "((name) => { name }).parameters.first.blocks?"
+          ]
+        },
+        "spread?" => {
+          name: "spread?",
+          description:
+            "returns whether the parameter captures every provided argument with spread syntax.",
+          examples: [
+            "((...values) => { values }).parameters.first.spread?",
+            "((name) => { name }).parameters.first.spread?",
+            "((name:) => { name }).parameters.first.spread?"
+          ]
+        },
+        "required?" => {
+          name: "required?",
+          description: "returns whether the parameter has no default value.",
+          examples: [
+            "((name) => { name }).parameters.first.required?",
+            "((name = :a) => { name }).parameters.first.required?",
+            "((name:) => { name }).parameters.first.required?"
+          ]
+        },
+        "optional?" => {
+          name: "optional?",
+          description: "returns whether the parameter has a default value.",
+          examples: [
+            "((name = :a) => { name }).parameters.first.optional?",
+            "((name) => { name }).parameters.first.optional?",
+            "((name: :a) => { name }).parameters.first.optional?"
+          ]
+        },
+        "default" => {
+          name: "default",
+          description:
+            "returns the default value for the parameter, or nothing when none is set.",
+          examples: [
+            "((name = :a) => { name }).parameters.first.default",
+            "((name) => { name }).parameters.first.default",
+            "((name: :a) => { name }).parameters.first.default"
+          ]
+        }
+      }.freeze
+
+      def self.function_documentation(scope)
+        return INSTANCE_FUNCTIONS if scope == :instance
+
+        {}
+      end
+
+      def call(**args)
+        code_operator = args.fetch(:operator, nil).to_code
+
+        case code_operator.to_s
+        when "required?"
+          sig(args)
+          code_required?
+        when "optional?"
+          sig(args)
+          code_optional?
+        else
+          super
+        end
+      end
+
       def code_name
         String.new(code_get(:name))
       end
@@ -27,6 +168,10 @@ class Code
         Boolean.new(code_get(:block?))
       end
 
+      def code_blocks?
+        Boolean.new(code_get(:blocks?))
+      end
+
       def code_spread?
         Boolean.new(code_get(:spread?))
       end
@@ -74,6 +219,10 @@ class Code
       def block?
         code_block?.truthy?
       end
+
+      def blocks?
+        code_blocks?.truthy?
+      end
     end
   end
 end