hostlist_expression 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0992689ca6dd58441493afaf85a639388f17d265f2fd24a825ee618137190f5
-  data.tar.gz: 27f65117b4e7307ebf734c97caac3872d85b1b7ada0c1c07c697e21e687f4749
+  metadata.gz: b8ced6089230749389cf14d25a15b05432435942e3ff8b8011da3a0b9891659e
+  data.tar.gz: d613f8364b2cf83aa8beecf3a14566da30680353d305b5e9127a1c419d15f9b2
 SHA512:
-  metadata.gz: ed2e47a07fd75fcce47942774949c3a7461c73bf4b954639c5f80b3494ffa96ebfe33529683d68973517c42107c54d294085a3f3be6d65a286f8099713ca3052
-  data.tar.gz: 6646f9aa7bb1decd99e9deb296f5e4b194ec672d6eda80501770b4725651c445a2f2e8d4a6bd6baa6cfd2847078c9d98a78516b8a3d87e9e5e04440fdfdfbe44
+  metadata.gz: e8baf7b857a06fff1093c00f4113c3bebb2660c717f9a864c49fa25877b2dd32e856e5e95e54bf0f053ff9ac352d4b48b93a59bb531ea98a1b124d9cc5bb122f
+  data.tar.gz: 4ec08df27a097d36b323ca285bb93dd96c04c3a6bd26ab11aa2e4f6edc585db164911258bd8b3b62e52629dbb31dc854933725dfa7ace7e47b45750216c15df8

data/lib/hostlist_expression.rb

@@ -4,101 +4,76 @@
 # License: MIT
 # Home: https://github.com/udondan/hostlist_expression-ruby
 
-# Expand hostlist expression
-#
-# @param [ String ] expression A host list expression.
-# @param [ String, Array<String> ] separator - Character(s) for separating ranges.
-#
-# @example
-#   hostlist_expression("your-host-[1-3].com")
-#   # => ["your-host-1.com", "your-host-2.com", "your-host-3.com"]
-#
-# @return [ Array<String> ] A list of expanded hosts.
-#
-# @since 0.1.0
-def hostlist_expression(expression, separator = [":", "-"])
-  # Validate range separator
-  separator = separator.join if separator.is_a?(Array)
-  if !separator.is_a?(String)
-    raise "Error: Range separator must be either of type String or Array. given: #{separator.class}"
-  elsif separator.empty?
-    raise "Error: Range separator is empty"
-  end
-
-  # Prepare separator for use in regular expressions
-  separator = Regexp.escape(separator)
+# Expansion logic behind {#hostlist_expression}.
+module HostlistExpression
+  class << self
+    # Expand hostlist expression. See {#hostlist_expression}.
+    def expand(expression, separator = [":", "-"])
+      separator = separator_pattern(separator)
+
+      # Return input as single host, if this is not a hostlist expression
+      return [expression] unless expression.match?(/\[(?:[\da-z]+(?:[#{separator}][\da-z]+)?,?)+\]/i)
+
+      # Replace each bracket group, e.g. [0:10] or [A,C-E], in every partial host
+      expression.scan(/\[([\da-z#{separator},]+)\]/i).reduce([expression]) do |hosts, (group)|
+        replacements = group.split(",").flat_map { |range| expand_range(range, separator, expression) }
+        hosts.flat_map { |host| replacements.map { |replacement| host.sub("[#{group}]", replacement) } }
+      end.uniq
+    end
 
-  # Return input as single host, if this is not a hostlist expression
-  return [expression] unless expression.match(/\[(?:[\da-z]+(?:[#{separator}][\da-z]+)?,?)+\]/i)
+    private
 
-  # hosts array will hold all expanded results,
-  # it as well is the working array where partially resolved results are stored
-  hosts = [expression]
+    # Validate the separator and escape it for use in a regexp character class
+    def separator_pattern(separator)
+      separator = separator.join if separator.is_a?(Array)
+      unless separator.is_a?(String)
+        raise "Error: Range separator must be either of type String or Array. given: #{separator.class}"
+      end
+      raise "Error: Range separator is empty" if separator.empty?
 
-  # Iterate over all range definitions, e.g. [0:10] or [A:Z]
-  expression.scan(/\[([\da-z#{separator},]+)\]/i).each do |match|
-    # Will hold replacements for each match
-    replacements = []
+      Regexp.escape(separator)
+    end
 
-    # The pattern may be a sequence with multiple ranges. Split...
-    match[0].split(",").each do |range|
-      # Split ranges by range separator
-      range_items = range.split(/[#{separator}]/)
+    # Expand a single sequence item, e.g. "1-3" or "A", into its values
+    def expand_range(range, separator, expression)
+      items = range.split(/[#{separator}]/)
 
       # If it's not really a range, duplicate the single item
-      range_items.push(range_items[0]) if range_items.length == 1
-
-      # Numeric range
-      if range_items.all? { |item| item.match(/^[0-9]+$/) }
-        isnum = true
-        from, to = range_items.map(&:to_i).sort
-
-      # Uppercase alphabetic range
-      elsif range_items.all? { |item| item.match(/^[A-Z]$/) }
-        alphabet = ("A".."Z").to_a
-        from, to = range_items.map { |item| alphabet.index(item) }.sort
-
-      # Lowercase alphabetic range
-      elsif range_items.all? { |item| item.match(/^[a-z]$/) }
-        alphabet = ("a".."z").to_a
-        from, to = range_items.map { |item| alphabet.index(item) }.sort
+      items.push(items[0]) if items.length == 1
 
+      if items.all?(/\A[0-9]+\z/)
+        numeric_range(items)
+      elsif items.all?(/\A[A-Z]\z/) || items.all?(/\A[a-z]\z/)
+        from, to = items.sort
+        (from..to).to_a
       else
         raise "Error: Invalid host range definition #{expression}"
       end
-
-      # Pad numbers only if a bound has leading zeros, to the width of the longest bound
-      padding = range_items.any? { |item| item.match(/^0[0-9]/) } ? range_items.map(&:length).max : 0
-
-      # Iterate over all hosts and store the resolved patterns in "replacements"
-      hosts.each do |_host|
-        # Iterate over the range
-        (from..to).each do |i|
-          if isnum
-            # Formatting number with leading zeros
-            replacements.push(i.to_s.rjust(padding, "0"))
-          else
-            # Select correct letter from alphabet
-            replacements.push(alphabet[i])
-          end
-        end
-      end
     end
 
-    # We clone the hosts array, because we can't modify it while iterating over its elements.
-    # So we iterate over the clone instead
-    hosts.clone.each do |host|
-      # Remove the original element
-      hosts.delete(host)
-
-      # Iterate over previously stored replacements
-      replacements.each do |replacement|
-        # Adding replacement to hosts array
-        hosts.push(host.sub(/\[#{match[0]}\]/, replacement))
-      end
+    # Pad numbers only if a bound has leading zeros, to the width of the longest bound
+    def numeric_range(items)
+      from, to = items.map(&:to_i).sort
+      padding = items.any?(/\A0[0-9]/) ? items.map(&:length).max : 0
+      (from..to).map { |i| i.to_s.rjust(padding, "0") }
     end
   end
+end
 
-  # Return unique results
-  hosts.uniq
+# Expand hostlist expression
+#
+# @param [ String ] expression A host list expression.
+# @param [ String, Array<String> ] separator - Character(s) for separating ranges.
+#
+# @example
+#   hostlist_expression("your-host-[1-3].com")
+#   # => ["your-host-1.com", "your-host-2.com", "your-host-3.com"]
+#
+# @return [ Array<String> ] A list of expanded hosts.
+#
+# @raise [ RuntimeError ] If the separator or a range definition is invalid.
+#
+# @since 0.1.0
+def hostlist_expression(expression, separator = [":", "-"])
+  HostlistExpression.expand(expression, separator)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hostlist_expression
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Daniel Schroeder