code-ruby 3.1.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2495002bb8e1d284386f2a90ff600370cfe0490a356688426682ec106727fbb3
-  data.tar.gz: e8dffdf7d8d0c0e62a091d2a7d305eae48dc74d024aa26c5a8dc393763147f13
+  metadata.gz: 79da8875ffac10dd65ca8098ec782caac2822a70f261e2902dd652dfd87da312
+  data.tar.gz: 8120dd6eeaf76dd5b1d1e5ffe9114050ddf99a037b3506487e94814b7a39b794
 SHA512:
-  metadata.gz: 55ceb13028c588110d3adec5539995ddd1f2dc4fd7173fd067a8e009a8093610adb150de78be46dfc57e605dbad0f03dd89e5693820be31c6d61c3440fb129ea
-  data.tar.gz: 6ae82061c1a129f1607eb348e18917e75c7d23accf7dca589da00ed3ae34eccf76af79826e430f5267b4a2011ce7c9df8a1709069f95f660c8dff22d16c0c37a
+  metadata.gz: c7a12d5824757713528707a89ba8680e005502e83d22fd946d6a9bb45b67dca6b73d6ce684c737e8225c1feb761ac40b7feb3b8d308fc6c008e20b425ab945b3
+  data.tar.gz: d3d3e80c38fc4eec30b929947e59d12a463ad40ceb03fd1122fbbfdc7056f33d054eb240d94472264957ea2a8a71ef8e8685a11a5da4e73f29480959239daf11

data/VERSION

@@ -1 +1 @@
-3.1.2
+4.0.0

data/bin/code

@@ -37,51 +37,128 @@ parsed =
 abort Code::Version.to_s if parsed.options.version
 abort parsed.help if parsed.options.help
 
+MAX_ARGUMENT_FILES = 1000
+
 def glob_pattern?(value)
   value.match?(/[*?\[\]{]/)
 end
 
-expanded_argument_files = []
-remaining_arguments = []
+def timeout
+  @timeout ||= @parsed_timeout
+end
+
+def with_timeout(&)
+  Timeout.timeout(timeout, &)
+rescue Timeout::Error
+  raise Code::Error, "timeout"
+end
+
+def append_limited(buffer, value, label: "input")
+  value = value.to_s
+  if buffer.bytesize + value.bytesize > Code::MAX_INPUT_BYTES
+    raise Code::Error, "#{label} is too large"
+  end
+
+  buffer << value
+end
+
+def read_file(path)
+  raise Code::Error, "#{path} is not a regular file" unless File.file?(path)
+
+  File.open(path, "rb") do |file|
+    data = file.read(Code::MAX_INPUT_BYTES + 1).to_s
+    Code.ensure_input_size!(data, label: path)
+    data
+  end
+end
+
+def read_stdin
+  data = $stdin.read(Code::MAX_INPUT_BYTES + 1).to_s
+  Code.ensure_input_size!(data, label: "stdin")
+  data
+end
+
+def expand_arguments(arguments)
+  expanded_files = []
+  remaining_arguments = []
 
-parsed.arguments.each do |argument|
-  if glob_pattern?(argument)
-    matches = Dir.glob(argument).select { |path| File.file?(path) }
+  arguments.each do |argument|
+    if glob_pattern?(argument)
+      matches = Dir.glob(argument).select { |path| File.file?(path) }
 
-    if matches.any?
-      expanded_argument_files.concat(matches)
+      if matches.any?
+        expanded_files.concat(matches)
+      else
+        remaining_arguments << argument
+      end
     else
       remaining_arguments << argument
     end
-  else
-    remaining_arguments << argument
+
+    raise Code::Error, "too many input files" if expanded_files.size > MAX_ARGUMENT_FILES
   end
+
+  [expanded_files, remaining_arguments]
 end
 
-input = parsed.options.input.to_s
-input += File.read(input) if File.exist?(input)
-input += remaining_arguments.join(" ")
-input +=
-  (parsed.files + expanded_argument_files)
-    .map { |file| File.read(file) }
-    .join("\n\n")
+begin
+  @parsed_timeout = Code.normalize_timeout!(
+    parsed.options.timeout || Code::DEFAULT_TIMEOUT
+  )
+rescue Code::Error => e
+  abort "#{e.class}: #{e.message}"
+end
+
+begin
+  input =
+    with_timeout do
+      buffer = +""
+      option_input = parsed.options.input.to_s
+      expanded_argument_files, remaining_arguments =
+        expand_arguments(parsed.arguments)
+
+      if option_input.present? && File.exist?(option_input)
+        append_limited(buffer, read_file(option_input))
+      else
+        append_limited(buffer, option_input)
+      end
+
+      append_limited(buffer, remaining_arguments.join(" "))
+
+      input_files = parsed.files + expanded_argument_files
+      raise Code::Error, "too many input files" if input_files.size > MAX_ARGUMENT_FILES
+
+      input_files.each.with_index do |file, index|
+        append_limited(buffer, "\n\n") if index.positive?
+        append_limited(buffer, read_file(file), label: file)
+      end
+
+      buffer
+    end
+rescue Code::Error => e
+  abort "#{e.class}: #{e.message}"
+end
 
 profile = parsed.options.profile || parsed.options.profiler
 require "ruby-prof" if profile
 
 RubyProf.start if profile
 
-input = $stdin.each_line.to_a.join if input.empty?
+begin
+  input = with_timeout { read_stdin } if input.empty?
+rescue Code::Error => e
+  abort "#{e.class}: #{e.message}"
+end
 
 if parsed.options.parse
   begin
-    pp Code::Parser.parse(input).to_raw
+    pp Code.parse(input, timeout: timeout)
   rescue StandardError => e
     warn e.message
   end
 elsif parsed.options.format
   begin
-    print(Code.format(input, timeout: parsed.options.timeout))
+    print(Code.format(input, timeout: timeout))
   rescue Code::Error => e
     warn "#{e.class}: #{e.message}"
   end
@@ -93,7 +170,7 @@ else
         output: $stdout,
         error: $stderr,
         input: $stdin,
-        timeout: parsed.options.timeout
+        timeout: timeout
       )
     )
   rescue Code::Error => e

data/lib/code/concerns/shared.rb

@@ -3,14 +3,122 @@
 class Code
   module Concerns
     module Shared
-      attr_accessor :raw, :methods
+      attr_accessor :raw, :functions
+
+      COMPOUND_ASSIGNMENT_OPERATORS = [
+        "+=",
+        "-=",
+        "*=",
+        "/=",
+        "%=",
+        "<<=",
+        ">>=",
+        "&=",
+        "|=",
+        "^=",
+        "||=",
+        "&&="
+      ].freeze
+      SHARED_OPERATORS = [
+        "documentation",
+        "present?",
+        "blank?",
+        "presence",
+        "presence_in",
+        "is_a?",
+        "is_an?",
+        "kind_of?",
+        "instance_of?",
+        "new",
+        "!",
+        "not",
+        "!=",
+        "different",
+        "&&",
+        "and",
+        "+",
+        "self",
+        "..",
+        "inclusive_range",
+        "...",
+        "exclusive_range",
+        "==",
+        "equal",
+        "equal?",
+        "same_object?",
+        ">",
+        "greater",
+        ">=",
+        "greater_or_equal",
+        "<=>",
+        "compare",
+        "<",
+        "less",
+        "<=",
+        "less_or_equal",
+        "===",
+        "strict_equal",
+        "!==",
+        "strict_different",
+        "falsy?",
+        "truthy?",
+        "true?",
+        "false?",
+        "||",
+        "or",
+        "to_boolean",
+        "to_class",
+        "to_date",
+        "to_decimal",
+        "to_dictionary",
+        "to_duration",
+        "to_integer",
+        "to_list",
+        "to_nothing",
+        "to_range",
+        "to_string",
+        "inspect",
+        "to_time",
+        "as_json",
+        "duplicate",
+        "deep_duplicate",
+        "to_parameter",
+        "to_json",
+        "functions",
+        "instance_functions",
+        "class_functions",
+        "respond_to?",
+        "send",
+        "itself",
+        "tap",
+        "then",
+        "name",
+        "nothing?",
+        "something?"
+      ].freeze
+      OPERATOR_METHOD_ALIASES = {
+        "[]" => "get",
+        "at" => "get",
+        "length" => "size",
+        "member?" => "include?",
+        "key?" => "has_key?",
+        "value?" => "has_value?",
+        "filter" => "select",
+        "filter!" => "select!"
+      }.freeze
 
       def call(**args)
         code_operator = args.fetch(:operator, nil).to_code
         code_arguments = args.fetch(:arguments, []).to_code
         code_value = code_arguments.code_first
 
+        dynamic_result = code_dynamic_call(code_operator, **args)
+        return dynamic_result if dynamic_result
+
         case code_operator.to_s
+        when "documentation"
+          sig(args)
+          code_documentation
         when "present?"
           sig(args)
           code_present?
@@ -23,6 +131,12 @@ class Code
         when "presence_in"
           sig(args) { Object::List }
           code_presence_in(code_value)
+        when "is_a?", "is_an?", "kind_of?"
+          sig(args) { Object::Class }
+          code_is_a?(code_value)
+        when "instance_of?"
+          sig(args) { Object::Class }
+          code_instance_of?(code_value)
         when "new"
           sig(args) { Object.repeat }
           code_new(*code_arguments.raw)
@@ -44,13 +158,16 @@ class Code
         when "...", "exclusive_range"
           sig(args) { Object }
           code_exclusive_range(code_value)
-        when "==", "equal"
+        when "==", "equal", "equal?"
           sig(args) { Object }
           code_equal(code_value)
-        when ">", "greater_or_equal"
+        when "same_object?"
+          sig(args) { Object }
+          code_same_object?(code_value)
+        when ">", "greater"
           sig(args) { Object }
           code_greater(code_value)
-        when ">=", "greater"
+        when ">=", "greater_or_equal"
           sig(args) { Object }
           code_greater_or_equal(code_value)
         when "<=>", "compare"
@@ -74,6 +191,12 @@ class Code
         when "truthy?"
           sig(args)
           code_truthy?
+        when "true?"
+          sig(args)
+          code_true?
+        when "false?"
+          sig(args)
+          code_false?
         when "||", "or"
           sig(args) { Object }
           code_or(code_value)
@@ -136,9 +259,30 @@ class Code
           else
             code_to_json
           end
-        when "methods"
+        when "functions"
+          sig(args)
+          code_functions
+        when "instance_functions"
           sig(args)
-          code_methods
+          code_instance_functions
+        when "class_functions"
+          sig(args)
+          code_class_functions
+        when "respond_to?"
+          sig(args) { Object }
+          code_respond_to?(code_value)
+        when "send"
+          sig(args) { [Object, Object.repeat] }
+          code_send(*code_arguments.raw, **args)
+        when "itself"
+          sig(args)
+          code_itself
+        when "tap"
+          sig(args) { Object::Function }
+          code_tap(code_value, **args)
+        when "then"
+          sig(args) { Object::Function }
+          code_then(code_value, **args)
         when "name"
           sig(args)
           code_name
@@ -154,6 +298,9 @@ class Code
           if code_operator.to_s == "="
             code_context = args.fetch(:context)
             code_context.code_set(self, code_value)
+          elsif setter_operator?(code_operator)
+            code_dynamic_functions.code_set(code_operator.to_s.chop, code_value)
+            return code_value
           else
             code_context = args.fetch(:context).code_lookup!(self)
             code_context.code_set(
@@ -336,7 +483,7 @@ class Code
         self.class.new(self)
       end
 
-      def code_deep_duplicate
+      def code_deep_duplicate(_seen = {})
         self.class.new(self)
       end
 
@@ -352,16 +499,30 @@ class Code
         Object::Nothing.new
       end
 
-      def code_fetch(...)
-        Object::Nothing.new
+      def code_fetch(key)
+        code_dynamic_functions.code_fetch(key)
       end
 
-      def code_set(...)
-        Object::Nothing.new
+      def code_set(key, value)
+        code_dynamic_functions.code_set(key, value)
       end
 
-      def code_get(...)
-        Object::Nothing.new
+      def code_get(key)
+        code_dynamic_functions.code_get(key)
+      end
+
+      def code_has_key?(key)
+        code_dynamic_functions.code_has_key?(key)
+      end
+
+      def code_dynamic_call(operator, **args)
+        return nil unless code_dynamic_functions.code_has_key?(operator).truthy?
+
+        stored_value = code_dynamic_functions.code_fetch(operator)
+        return stored_value.call(**args, operator: nil, bound_self: self) if stored_value.is_a?(Object::Function)
+
+        sig(args)
+        stored_value
       end
 
       def code_to_parameter
@@ -404,6 +565,14 @@ class Code
         Object::Boolean.new(truthy?)
       end
 
+      def code_true?
+        Object::Boolean.new(self == Object::Boolean.new(true))
+      end
+
+      def code_false?
+        Object::Boolean.new(self == Object::Boolean.new(false) || nothing?)
+      end
+
       def code_to_boolean
         Object::Boolean.new(self)
       end
@@ -460,8 +629,83 @@ class Code
         Object::String.new(name.to_s.split("::")[2..].join("::"))
       end
 
-      def code_methods
-        Object::List.new(methods)
+      def code_documentation
+        Object.documentation_for(self.class)
+      end
+
+      def code_functions
+        Object.sorted_dictionary(
+          code_instance_functions.code_merge(code_class_functions).raw
+        )
+      end
+
+      def code_instance_functions
+        Object.sorted_dictionary(
+          Object.documented_functions_for(self.class, :instance).code_merge(
+            dynamic_functions_documentation
+          ).raw
+        )
+      end
+
+      def code_class_functions
+        dynamic_functions_documentation
+      end
+
+      def code_respond_to?(operator)
+        code_operator = operator.to_code
+
+        Object::Boolean.new(code_respond_to_operator?(code_operator))
+      end
+
+      def code_is_a?(klass)
+        code_klass = klass.to_code
+
+        Object::Boolean.new(is_a?(code_klass.raw))
+      end
+
+      def code_instance_of?(klass)
+        code_klass = klass.to_code
+
+        Object::Boolean.new(instance_of?(code_klass.raw))
+      end
+
+      def code_same_object?(other)
+        code_other = other.to_code
+
+        Object::Boolean.new(equal?(code_other))
+      end
+
+      def code_itself
+        self
+      end
+
+      def code_send(operator, *arguments, **globals)
+        code_operator = operator.to_code
+
+        call(
+          **globals,
+          arguments: Object::List.new(arguments),
+          operator: code_operator
+        )
+      end
+
+      def code_tap(function, **globals)
+        code_function = function.to_code
+        code_function.call(
+          **globals,
+          arguments: Object::List.new([self]),
+          operator: nil
+        )
+        self
+      end
+
+      def code_then(function, **globals)
+        code_function = function.to_code
+        code_function.call(
+          **globals,
+          arguments: Object::List.new([self]),
+          operator: nil
+        )
       end
 
       def present?
@@ -489,6 +733,78 @@ class Code
 
         code_list.code_include?(self).truthy? ? self : Object::Nothing.new
       end
+
+      def code_documentable_functions
+        Object::Dictionary.new(
+          code_dynamic_functions.raw.merge(dictionary_attributes)
+        )
+      end
+
+      private
+
+      def setter_operator?(operator)
+        !COMPOUND_ASSIGNMENT_OPERATORS.include?(operator.to_s)
+      end
+
+      def code_respond_to_operator?(operator)
+        operator_name = operator.to_s
+
+        SHARED_OPERATORS.include?(operator_name) ||
+          code_operator_method_defined?(operator_name) ||
+          code_functions.code_has_key?(operator).truthy?
+      end
+
+      def code_operator_method_defined?(operator_name)
+        method_name = :"code_#{OPERATOR_METHOD_ALIASES.fetch(operator_name, operator_name)}"
+        return false unless respond_to?(method_name)
+
+        method(method_name).owner != Shared
+      end
+
+      def code_dynamic_functions
+        @functions = Object::Dictionary.new if @functions.blank?
+
+        @functions
+      end
+
+      def dynamic_functions_documentation
+        Object.sorted_dictionary(
+          code_documentable_functions.raw.to_h do |key, value|
+            name = key.to_s
+            [
+              name,
+              Object::Dictionary.new(
+                "name" => Object::String.new(name),
+                "description" => Object::String.new(
+                  dynamic_function_description(value)
+                ),
+                "examples" => Object::List.new(dynamic_function_examples(value)),
+                "function" => value
+              )
+            ]
+          end
+        )
+      end
+
+      def dictionary_attributes
+        return {} unless is_a?(Object::Dictionary)
+
+        raw
+      end
+
+      def dynamic_function_description(value)
+        code_value = value.to_code
+        return "" unless code_value.is_a?(Object::Function)
+
+        code_value.documentation.code_get("description").to_s
+      end
+
+      def dynamic_function_examples(value)
+        code_value = value.to_code
+        return [] unless code_value.is_a?(Object::Function)
+
+        code_value.documentation.code_get("examples").to_code.code_to_list.raw
+      end
     end
   end
 end

data/lib/code/format.rb

@@ -207,13 +207,17 @@ class Code
     end
 
     def escape_string_text(text)
-      text.gsub("\\", "\\\\").gsub('"', '\"').gsub("{", "\\{")
+      text
+        .gsub("\\", "\\\\")
+        .gsub('"', '\"')
+        .gsub("{", "\\{")
     end
 
     def format_string_literal(content, components:, indent:, allow_split:)
       literal = %("#{content}")
       return literal if literal.length <= string_inline_limit(indent)
       return literal unless allow_split
+      return literal if content.include?("\\")
 
       split_string_literal(components, indent: indent)
     end
@@ -380,6 +384,14 @@ class Code
         return format_code_inline(Array(argument), indent: 0)
       end
 
+      if argument.key?(:operator)
+        return argument[:operator].to_s unless argument.key?(:value)
+
+        value = format_code_inline(argument[:value], indent: 0)
+
+        return "#{argument[:operator]}#{value}"
+      end
+
       value = format_code_inline(argument[:value], indent: 0)
       return value unless argument.key?(:name)
 
@@ -423,6 +435,8 @@ class Code
           parameter[:spread]
         elsif parameter.key?(:block)
           parameter[:block]
+        elsif parameter.key?(:blocks)
+          parameter[:blocks]
         else
           ""
         end