code-ruby 5.0.0 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cf58797cc85a08488f3a8b34e55f03f2a6d76172b1af5acd440985b84652dda
-  data.tar.gz: 721c6ee890033cb5e174837b5fae19ff6fde3275a60cd4131c3feff1055eacc8
+  metadata.gz: f87766e8837d19a0644c29508a53840df32e22e5b46802d08e135ea2dd9ad873
+  data.tar.gz: ec59cc05b2c71146e356bb86ec51fb08001538a3274a67421cdaa2f3f1de8d66
 SHA512:
-  metadata.gz: 0a29ba0ce27a4fa35b5ca789bef6b27f4d92d8a0338d4560b423984ad98ad82b62f19238622f17c0ce68851aa8e105e04dbb712ec26e986220b526f67ed51913
-  data.tar.gz: 4d39906874334a806ce488dce62966a299e1bc382317d793cecc759affa4e7514392f8a1f007bd1e2379e2e855f5c0752abc98cf07ab2f1ab0ee4876fb77b527
+  metadata.gz: 56a77245fcc70a40ce249348540a936d814e1894b78d67bfab3d878ac0f7576c43be6d50433a8b3251fd90cac41656f36a39b8b87ca643aec1598926f4c03291
+  data.tar.gz: 5b841dcfdeb008bbf8fc80e7e6cf538c64a02e97f1aabe7271e94df76cbf480cdb575b87ea120632cfacdbd645d765c1eaba1a23d852d34f51ef5d2b8b8c65db

data/VERSION

@@ -1 +1 @@
-5.0.0
+5.0.1

data/lib/code/extensions/regexp.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Regexp
+  def to_code
+    Code::Object::Regex.new(self)
+  end
+end

data/lib/code/object/global.rb

@@ -227,6 +227,16 @@ class Code
             "returns the Parameter class when called without arguments, otherwise calls Parameter.new.",
           examples: %w[Parameter Parameter.new Parameter.new(nothing)]
         },
+        "Regex" => {
+          name: "Regex",
+          description:
+            "returns the Regex class when called without arguments, otherwise calls Regex.new.",
+          examples: [
+            "Regex",
+            "Regex.new(\"a|b|c\")",
+            "Regex(\"^hello\", ignore_case: true)"
+          ]
+        },
         "Range" => {
           name: "Range",
           description:
@@ -417,6 +427,7 @@ class Code
           "Number" => Number,
           "Object" => Object,
           "Parameter" => Parameter,
+          "Regex" => Regex,
           "Range" => Range,
           "Smtp" => Smtp,
           "String" => String,
@@ -550,6 +561,13 @@ class Code
           else
             Class.new(Range)
           end
+        when "Regex"
+          sig(args) { Object.repeat }
+          if code_arguments.any?
+            Regex.new(*code_arguments.raw)
+          else
+            Class.new(Regex)
+          end
         when "String"
           sig(args) { Object.repeat }
           if code_arguments.any?

data/lib/code/object/list.rb

@@ -724,6 +724,24 @@ class Code
             "[].filter((x) => { x })"
           ]
         },
+        "grep" => {
+          name: "grep",
+          description: "returns string items matched by a regex.",
+          examples: [
+            "[\"ant\", \"bat\", \"cat\"].grep(Regex.new(\"a\"))",
+            "[\"ant\", \"bat\"].grep(Regex.new(\"^b\"))",
+            "[\"ant\", \"bat\"].grep(Regex.new(\"z\"))"
+          ]
+        },
+        "grep_not" => {
+          name: "grep_not",
+          description: "returns string items not matched by a regex.",
+          examples: [
+            "[\"ant\", \"bat\", \"cat\"].grep_not(Regex.new(\"a\"))",
+            "[\"ant\", \"bat\"].grep_not(Regex.new(\"^b\"))",
+            "[\"ant\", \"bat\"].grep_not(Regex.new(\"z\"))"
+          ]
+        },
         "select!" => {
           name: "select!",
           description:
@@ -3218,6 +3236,12 @@ class Code
         when "select", "filter"
           sig(args) { (Function | Class).maybe }
           code_select(code_value, **globals)
+        when "grep"
+          sig(args) { [Regex, (Function | Class).maybe] }
+          code_grep(*code_arguments.raw, **globals)
+        when "grep_not"
+          sig(args) { [Regex, (Function | Class).maybe] }
+          code_grep_not(*code_arguments.raw, **globals)
         when "select!", "filter!"
           sig(args) { (Function | Class).maybe }
           code_select!(code_value, **globals)
@@ -4889,6 +4913,62 @@ class Code
         e.code_value
       end
 
+      def code_grep(regex, argument = nil, **globals)
+        code_regex = regex.to_code
+        code_argument = argument.to_code
+        results = []
+
+        raw.each.with_index do |code_element, index|
+          next unless code_element.is_a?(String) &&
+            code_regex.raw.match?(code_element.raw)
+
+          results << if code_argument.is_a?(Function)
+            code_argument.call(
+              arguments: List.new([code_element, Integer.new(index), self]),
+              **globals
+            )
+          elsif code_argument.is_a?(Class)
+            code_argument.raw.new(code_element)
+          else
+            code_element
+          end
+        rescue Error::Next => e
+          results << e.code_value
+        end
+
+        List.new(results)
+      rescue Error::Break => e
+        e.code_value
+      end
+
+      def code_grep_not(regex, argument = nil, **globals)
+        code_regex = regex.to_code
+        code_argument = argument.to_code
+        results = []
+
+        raw.each.with_index do |code_element, index|
+          next if code_element.is_a?(String) &&
+            code_regex.raw.match?(code_element.raw)
+
+          results << if code_argument.is_a?(Function)
+            code_argument.call(
+              arguments: List.new([code_element, Integer.new(index), self]),
+              **globals
+            )
+          elsif code_argument.is_a?(Class)
+            code_argument.raw.new(code_element)
+          else
+            code_element
+          end
+        rescue Error::Next => e
+          results << e.code_value
+        end
+
+        List.new(results)
+      rescue Error::Break => e
+        e.code_value
+      end
+
       def code_reject(argument = nil, **globals)
         code_argument = argument.to_code
 

data/lib/code/object/regex.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class Regex < Object
+      CLASS_DOCUMENTATION = {
+        name: "Regex",
+        description:
+          "represents a regular expression pattern with explicit matching options.",
+        examples: [
+          "Regex",
+          "Regex.new(\"a|b|c\")",
+          "Regex.new(\"^hello\", ignore_case: true)"
+        ]
+      }.freeze
+      INSTANCE_FUNCTIONS = {
+        "match?" => {
+          name: "match?",
+          description: "returns whether the regex matches a string.",
+          examples: [
+            "Regex.new(\"a|b|c\").match?(\"b\")",
+            "Regex.new(\"^hello\").match?(\"hello world\")",
+            "Regex.new(\"^hello\").match?(\"say hello\")"
+          ]
+        },
+        "source" => {
+          name: "source",
+          description: "returns the regex pattern source.",
+          examples: [
+            "Regex.new(\"a|b|c\").source",
+            "Regex.new(\"^hello\").source",
+            "Regex.new(\"hello\", ignore_case: true).source"
+          ]
+        },
+        "options" => {
+          name: "options",
+          description: "returns the enabled regex options.",
+          examples: [
+            "Regex.new(\"hello\").options",
+            "Regex.new(\"hello\", ignore_case: true).options.ignore_case",
+            "Regex.new(\"hello\", multiple_lines: true).options.multiple_lines"
+          ]
+        },
+        "ignore_case?" => {
+          name: "ignore_case?",
+          description: "returns whether the regex ignores case.",
+          examples: [
+            "Regex.new(\"hello\").ignore_case?",
+            "Regex.new(\"hello\", ignore_case: true).ignore_case?",
+            "Regex.new(\"hello\", ignore_case: false).ignore_case?"
+          ]
+        },
+        "extended?" => {
+          name: "extended?",
+          description: "returns whether the regex ignores whitespace and comments.",
+          examples: [
+            "Regex.new(\"hello\").extended?",
+            "Regex.new(\"hello\", extended: true).extended?",
+            "Regex.new(\"hello\", extended: false).extended?"
+          ]
+        },
+        "multiple_lines?" => {
+          name: "multiple_lines?",
+          description: "returns whether the regex matches across multiple lines.",
+          examples: [
+            "Regex.new(\"hello\").multiple_lines?",
+            "Regex.new(\"hello\", multiple_lines: true).multiple_lines?",
+            "Regex.new(\"hello\", multiple_lines: false).multiple_lines?"
+          ]
+        },
+        "fixed_encoding?" => {
+          name: "fixed_encoding?",
+          description: "returns whether the regex has fixed encoding.",
+          examples: [
+            "Regex.new(\"hello\").fixed_encoding?",
+            "Regex.new(\"hello\", fixed_encoding: true).fixed_encoding?",
+            "Regex.new(\"hello\", fixed_encoding: false).fixed_encoding?"
+          ]
+        },
+        "no_encoding?" => {
+          name: "no_encoding?",
+          description: "returns whether the regex has no encoding.",
+          examples: [
+            "Regex.new(\"hello\").no_encoding?",
+            "Regex.new(\"hello\", no_encoding: true).no_encoding?",
+            "Regex.new(\"hello\", no_encoding: false).no_encoding?"
+          ]
+        }
+      }.freeze
+      OPTION_FLAGS = {
+        "ignore_case" => ::Regexp::IGNORECASE,
+        "extended" => ::Regexp::EXTENDED,
+        "multiple_lines" => ::Regexp::MULTILINE,
+        "fixed_encoding" => ::Regexp::FIXEDENCODING,
+        "no_encoding" => ::Regexp::NOENCODING
+      }.freeze
+
+      def self.function_documentation(scope)
+        return INSTANCE_FUNCTIONS if scope == :instance
+
+        {}
+      end
+
+      def initialize(*args, **kargs, &_block)
+        raise Error, "Regex.new: pattern is required" if args.empty?
+        raise Error, "Regex.new: expected 1-2 arguments" if args.size > 2
+
+        pattern = args.first
+        option_values = {}
+
+        if args[1]
+          case args[1]
+          when Dictionary
+            args[1].raw.each do |key, value|
+              option_values[key.to_s] =
+                value.is_an?(Object) ? value.truthy? : !!value
+            end
+          when ::Hash
+            args[1].each do |key, value|
+              option_values[key.to_s] =
+                value.is_an?(Object) ? value.truthy? : !!value
+            end
+          else
+            raise Error, "Regex.new: options must be a dictionary"
+          end
+        end
+
+        kargs.each do |key, value|
+          option_values[key.to_s] =
+            value.is_an?(Object) ? value.truthy? : !!value
+        end
+
+        options =
+          option_values.reduce(0) do |flags, (name, enabled)|
+            flag = OPTION_FLAGS[name]
+            raise Error, "unknown regex option: #{name}" unless flag
+
+            enabled ? flags | flag : flags
+          end
+
+        self.raw =
+          if pattern.is_a?(Regex)
+            ::Regexp.new(pattern.raw.source, pattern.raw.options | options)
+          elsif pattern.is_a?(::Regexp)
+            ::Regexp.new(pattern.source, pattern.options | options)
+          else
+            ::Regexp.new(pattern.to_s, options)
+          end
+      rescue ::RegexpError => e
+        raise Error, "invalid regex: #{e.message}"
+      end
+
+      def call(**args)
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, List.new).to_code
+        code_value = code_arguments.code_first
+
+        case code_operator.to_s
+        when "match?"
+          sig(args) { String }
+          code_match?(code_value)
+        when "source"
+          sig(args)
+          code_source
+        when "options"
+          sig(args)
+          code_options
+        when "ignore_case?"
+          sig(args)
+          code_ignore_case?
+        when "extended?"
+          sig(args)
+          code_extended?
+        when "multiple_lines?"
+          sig(args)
+          code_multiple_lines?
+        when "fixed_encoding?"
+          sig(args)
+          code_fixed_encoding?
+        when "no_encoding?"
+          sig(args)
+          code_no_encoding?
+        else
+          super
+        end
+      end
+
+      def code_match?(string)
+        Boolean.new(raw.match?(string.to_s))
+      end
+
+      def code_source
+        String.new(raw.source)
+      end
+
+      def code_options
+        Dictionary.new(
+          OPTION_FLAGS.transform_values { |flag| (raw.options & flag) == flag }
+        )
+      end
+
+      def code_ignore_case?
+        Boolean.new((raw.options & ::Regexp::IGNORECASE) == ::Regexp::IGNORECASE)
+      end
+
+      def code_extended?
+        Boolean.new((raw.options & ::Regexp::EXTENDED) == ::Regexp::EXTENDED)
+      end
+
+      def code_multiple_lines?
+        Boolean.new((raw.options & ::Regexp::MULTILINE) == ::Regexp::MULTILINE)
+      end
+
+      def code_fixed_encoding?
+        Boolean.new(
+          (raw.options & ::Regexp::FIXEDENCODING) == ::Regexp::FIXEDENCODING
+        )
+      end
+
+      def code_no_encoding?
+        Boolean.new((raw.options & ::Regexp::NOENCODING) == ::Regexp::NOENCODING)
+      end
+
+      def code_to_string
+        code_source
+      end
+
+      def code_inspect
+        String.new(raw.inspect)
+      end
+
+    end
+  end
+end

data/lib/code/object/string.rb

@@ -70,6 +70,24 @@ class Code
             "\":name\".member?(\":\")"
           ]
         },
+        "match?" => {
+          name: "match?",
+          description: "returns whether the string matches a regex.",
+          examples: [
+            "\"hello\".match?(Regex.new(\"ell\"))",
+            "\"hello\".match?(Regex.new(\"^he\"))",
+            "\"hello\".match?(Regex.new(\"world\"))"
+          ]
+        },
+        "matches?" => {
+          name: "matches?",
+          description: "returns whether the string matches a regex.",
+          examples: [
+            "\"hello\".matches?(Regex.new(\"ell\"))",
+            "\"hello\".matches?(Regex.new(\"^he\"))",
+            "\"hello\".matches?(Regex.new(\"world\"))"
+          ]
+        },
         "starts_with?" => {
           name: "starts_with?",
           description: "returns whether the string starts with another string.",
@@ -273,10 +291,10 @@ class Code
         },
         "index" => {
           name: "index",
-          description: "returns the index of a matching substring.",
+          description: "returns the index of a matching substring or regex.",
           examples: [
             "\"hello\".index(\"l\")",
-            "\"hello\".index(\"x\")",
+            "\"hello\".index(Regex.new(\"l+\"))",
             "\"banana\".index(\"na\")"
           ]
         },
@@ -297,10 +315,11 @@ class Code
         },
         "right_index" => {
           name: "right_index",
-          description: "returns the last index of a matching substring.",
+          description:
+            "returns the last index of a matching substring or regex.",
           examples: [
             "\"hello\".right_index(\"l\")",
-            "\"hello\".right_index(\"x\")",
+            "\"hello\".right_index(Regex.new(\"l\"))",
             "\"banana\".right_index(\"na\")"
           ]
         },
@@ -527,7 +546,16 @@ class Code
           examples: [
             "\"a,b\".split(\",\")",
             "\"a b\".split",
-            "\"a--b\".split(\"--\")"
+            "\"a,b;c\".split(Regex.new(\"[,;]\"))"
+          ]
+        },
+        "scan" => {
+          name: "scan",
+          description: "returns every regex match in the string.",
+          examples: [
+            "\"a1 b22\".scan(Regex.new(\"[0-9]+\"))",
+            "\"abc\".scan(Regex.new(\"[a-z]\"))",
+            "\"abc\".scan(Regex.new(\"x\"))"
           ]
         },
         "words" => {
@@ -583,6 +611,9 @@ class Code
         when "include?", "member?"
           sig(args) { String }
           code_include?(code_value)
+        when "match?", "matches?"
+          sig(args) { Regex }
+          code_match?(code_value)
         when "starts_with?"
           sig(args) { String }
           code_starts_with?(code_value)
@@ -659,7 +690,7 @@ class Code
           sig(args) { Integer.maybe }
           code_first(code_value)
         when "index"
-          sig(args) { String }
+          sig(args) { String | Regex }
           code_index(code_value)
         when "last"
           sig(args) { Integer.maybe }
@@ -671,7 +702,7 @@ class Code
           sig(args)
           code_reverse
         when "right_index"
-          sig(args) { String }
+          sig(args) { String | Regex }
           code_right_index(code_value)
         when "parameterize"
           sig(args)
@@ -683,22 +714,22 @@ class Code
           sig(args) { String.repeat }
           code_squeeze(*code_arguments.raw)
         when "substitute"
-          sig(args) { [String, String.maybe] }
+          sig(args) { [String | Regex, String.maybe] }
           code_substitute(*code_arguments.raw)
         when "substitute!"
-          sig(args) { [String, String.maybe] }
+          sig(args) { [String | Regex, String.maybe] }
           code_substitute!(*code_arguments.raw)
         when "substitute_all"
-          sig(args) { [String, String.maybe] }
+          sig(args) { [String | Regex, String.maybe] }
           code_substitute_all(*code_arguments.raw)
         when "substitute_all!"
-          sig(args) { [String, String.maybe] }
+          sig(args) { [String | Regex, String.maybe] }
           code_substitute_all!(*code_arguments.raw)
         when "substitute_once"
-          sig(args) { [String, String.maybe] }
+          sig(args) { [String | Regex, String.maybe] }
           code_substitute_once(*code_arguments.raw)
         when "substitute_once!"
-          sig(args) { [String, String.maybe] }
+          sig(args) { [String | Regex, String.maybe] }
           code_substitute_once!(*code_arguments.raw)
         when "swapcase"
           sig(args)
@@ -749,8 +780,11 @@ class Code
           sig(args) { [Integer.maybe, Integer.maybe] }
           code_substring(*code_arguments.raw)
         when "split"
-          sig(args) { String.maybe }
+          sig(args) { (String | Regex).maybe }
           code_split(code_value)
+        when "scan"
+          sig(args) { Regex }
+          code_scan(code_value)
         when "words"
           sig(args)
           code_words
@@ -887,6 +921,11 @@ class Code
         Boolean.new(raw.include?(code_value.raw))
       end
 
+      def code_match?(value)
+        code_value = value.to_code
+        Boolean.new(code_value.raw.match?(raw))
+      end
+
       def code_index(value)
         code_value = value.to_code
         raw.index(code_value.raw).to_code
@@ -1000,8 +1039,9 @@ class Code
       def code_substitute_all(from = nil, to = nil)
         code_from = from.to_code
         code_to = to.to_code
+        from_value = code_from.is_a?(Regex) ? code_from.raw : code_from.to_s
 
-        String.new(raw.gsub(code_from.to_s, code_to.to_s))
+        String.new(raw.gsub(from_value, code_to.to_s))
       end
 
       def code_substitute_all!(from = nil, to = nil)
@@ -1012,8 +1052,9 @@ class Code
       def code_substitute_once(from = nil, to = nil)
         code_from = from.to_code
         code_to = to.to_code
+        from_value = code_from.is_a?(Regex) ? code_from.raw : code_from.to_s
 
-        String.new(raw.sub(code_from.to_s, code_to.to_s))
+        String.new(raw.sub(from_value, code_to.to_s))
       end
 
       def code_substitute_once!(from = nil, to = nil)
@@ -1132,10 +1173,22 @@ class Code
         if code_value.nothing?
           List.new(raw.split)
         else
-          List.new(raw.split(code_value.to_s))
+          separator = code_value.is_a?(Regex) ? code_value.raw : code_value.to_s
+
+          List.new(raw.split(separator))
         end
       end
 
+      def code_scan(value)
+        code_value = value.to_code
+
+        List.new(
+          raw.scan(code_value.raw).map do |match|
+            match.is_a?(::Array) ? List.new(match) : String.new(match)
+          end
+        )
+      end
+
       def code_words
         List.new(raw.split)
       end

data/lib/code-ruby.rb

@@ -33,6 +33,7 @@ require_relative "code/extensions/nil_class"
 require_relative "code/extensions/true_class"
 require_relative "code/extensions/false_class"
 require_relative "code/extensions/string"
+require_relative "code/extensions/regexp"
 require_relative "code/extensions/symbol"
 require_relative "code/extensions/integer"
 require_relative "code/extensions/float"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.0.1
 platform: ruby
 authors:
 - Dorian Marié
@@ -318,6 +318,7 @@ files:
 - lib/code/extensions/nil_class.rb
 - lib/code/extensions/nokogiri.rb
 - lib/code/extensions/object.rb
+- lib/code/extensions/regexp.rb
 - lib/code/extensions/string.rb
 - lib/code/extensions/symbol.rb
 - lib/code/extensions/true_class.rb
@@ -376,6 +377,7 @@ files:
 - lib/code/object/number.rb
 - lib/code/object/parameter.rb
 - lib/code/object/range.rb
+- lib/code/object/regex.rb
 - lib/code/object/smtp.rb
 - lib/code/object/string.rb
 - lib/code/object/super.rb