code-ruby 3.1.2 → 4.0.0

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: [
+          "nothing",
+          "Nothing.new",
+          "Nothing.new(1)"
+        ]
+      }.freeze
+      INSTANCE_FUNCTIONS = {
+        "empty?" => {
+          name: "empty?",
+          description: "returns true because nothing has no contents.",
+          examples: ["nothing.empty?", "Nothing.new.empty?", "Nothing.new(1).empty?"]
+        },
+        "to_string" => {
+          name: "to_string",
+          description: "returns an empty string for nothing.",
+          examples: [
+            "nothing.to_string",
+            "Nothing.new.to_string",
+            "Nothing.new(1).to_string"
+          ]
+        },
+        "inspect" => {
+          name: "inspect",
+          description: "returns the source string for nothing.",
+          examples: ["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,116 @@
 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: ["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: ["5.divide_modulo(2)", "10.divide_modulo(3)", "9.5.divide_modulo(2)"]
+        },
+        "next" => {
+          name: "next",
+          description: "returns the number plus one.",
+          examples: ["1.next", "1.5.next", "-1.next"]
+        },
+        "successor" => {
+          name: "successor",
+          description: "returns the number plus one, matching next.",
+          examples: ["1.successor", "1.5.successor", "-1.successor"]
+        },
+        "previous" => {
+          name: "previous",
+          description: "returns the number minus one.",
+          examples: ["1.previous", "1.5.previous", "-1.previous"]
+        },
+        "predecessor" => {
+          name: "predecessor",
+          description: "returns the number minus one, matching previous.",
+          examples: ["1.predecessor", "1.5.predecessor", "-1.predecessor"]
+        },
+        "remainder" => {
+          name: "remainder",
+          description: "returns the remainder from division by another number.",
+          examples: ["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,138 @@
 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 +159,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 +210,10 @@ class Code
       def block?
         code_block?.truthy?
       end
+
+      def blocks?
+        code_blocks?.truthy?
+      end
     end
   end
 end