code-ruby 3.1.2 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2495002bb8e1d284386f2a90ff600370cfe0490a356688426682ec106727fbb3
-  data.tar.gz: e8dffdf7d8d0c0e62a091d2a7d305eae48dc74d024aa26c5a8dc393763147f13
+  metadata.gz: 04a1a64dae9f86bb218f016da7f56a7d4358d4dc63c620132ce58dd0a8d96b7d
+  data.tar.gz: 3735d10e82af9370ed1c4cff86e5c3965678a7b22e3a5ea709f11eda601d49b7
 SHA512:
-  metadata.gz: 55ceb13028c588110d3adec5539995ddd1f2dc4fd7173fd067a8e009a8093610adb150de78be46dfc57e605dbad0f03dd89e5693820be31c6d61c3440fb129ea
-  data.tar.gz: 6ae82061c1a129f1607eb348e18917e75c7d23accf7dca589da00ed3ae34eccf76af79826e430f5267b4a2011ce7c9df8a1709069f95f660c8dff22d16c0c37a
+  metadata.gz: d3c2288da223c047a41c6f6f30eba9c22c4e3ec7e4b058390530c0036a20d42580ce4755620345c4ff2c8403c0ffd9381d3a4865f690aedc2e4483617c695852
+  data.tar.gz: f21b89e07ec4f156d8ed3eec697902da23cd6dc269a74eeee375a7cc06b83bd78f22d8dee9613a10e9546908379f1128d75f104549d5c16650d81849e08f94b0

data/VERSION

@@ -1 +1 @@
-3.1.2
+4.0.1

data/bin/code

@@ -37,51 +37,131 @@ 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
+
+    if expanded_files.size > MAX_ARGUMENT_FILES
+      raise Code::Error, "too many input files"
+    end
   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
+      if input_files.size > MAX_ARGUMENT_FILES
+        raise Code::Error, "too many input files"
+      end
+
+      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 +173,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 = %w[
+        +=
+        -=
+        *=
+        /=
+        %=
+        <<=
+        >>=
+        &=
+        |=
+        ^=
+        ||=
+        &&=
+      ].freeze
+      SHARED_OPERATORS = %w[
+        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_methods
+          code_functions
+        when "instance_functions"
+          sig(args)
+          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,32 @@ 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)
+        if stored_value.is_a?(Object::Function)
+          return stored_value.call(**args, operator: nil, bound_self: self)
+        end
+
+        sig(args)
+        stored_value
       end
 
       def code_to_parameter
@@ -404,6 +567,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 +631,84 @@ 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 +736,79 @@ 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