content_spinning 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79295ec814e234e885f05f6a026177cc49384acf
-  data.tar.gz: b0cee4376b527d0b7a1d1ef0373ff51e385fb8b4
+  metadata.gz: c13ac04efa5b45c6a59cf3bbea6a47ea9bace674
+  data.tar.gz: 32b6b31adbc605a54d3b7673250f3a307c3cc167
 SHA512:
-  metadata.gz: 3b44c72fddeafdd9fda092eb44c38f2a30547f974be9771ebf7fe2e92085ebdaaf6ba25991ce213bd4eb1e1c9db4f619d787ff5986b9e2b26528fce5dd5b0381
-  data.tar.gz: 22b09a4e78ccc4686a9387fe5b4313f35abf5d92bf7fe8ff490b2d6569424db83dac152770d66f05c7719ad518a027fc846bd10df7006656abad6e54787036bf
+  metadata.gz: f91381ee1a24e4218b403be1ce88cb2201e456077d110e7db07157af5163783d66a46906c13bdff0fb24badce6b3347809e0da338615c3fe7b03a8babb2827d7
+  data.tar.gz: e95ff3c4eb4435172f871ad9ce119c3fb915bb0cc1cdb0141d81a339475008046aac51042a37ed36e2d9f53e0fabb1a7475fc982b1f53883d440ac0bcd0c2036

data/lib/content_spinning/version.rb

@@ -2,7 +2,7 @@ module ContentSpinning
 
   module Version
 
-    STRING = "0.1.0".freeze
+    STRING = "0.2.0".freeze
 
   end
 

data/lib/content_spinning.rb

@@ -2,84 +2,114 @@ require "content_spinning/core_ext/string"
 
 module ContentSpinning
 
+  SPIN_BEGIN_FOR_LEVEL = Hash.new { |h, level| h[level] = "__SPIN_BEGIN_#{level}__" }
+  SPIN_END_FOR_LEVEL = Hash.new { |h, level| h[level] = "__SPIN_END_#{level}__" }
+  SPIN_OR_FOR_LEVEL = Hash.new { |h, level| h[level] = "__SPIN_OR_#{level}__" }
+
+  PARTITIONNER_REGEXP_FOR_LEVEL = Hash.new do |h, level|
+    h[level] = /#{SPIN_BEGIN_FOR_LEVEL[level]}.+?#{SPIN_END_FOR_LEVEL[level]}/
+  end
+
   class << self
 
     def spin(text)
-      text = text.dup
-      text = clean(text)
-      result = parse(text)
+      result = parse(clean(text))
+
+      contents = if result[:max_level] == 0
+        [result[:parsed]]
+      else
+        spin_a_level([result[:parsed]], level: result[:max_level])
+      end
+
+      contents.reject!(&:empty?)
+      contents.uniq!
 
-      spin_all_level(result[:parsed], result[:max_level])
+      contents
     end
 
+    EMPTY_SPIN_REGEXP = /\{\|*\}/
+    ONE_CHOICE_SPIN_REGEXP = /\{([^\{\}\|]+)\}/
+
     def clean(text)
+      cleaned = text.dup
+
       loop do
-        text_before_run = text.dup
+        text_before_run = cleaned.dup
 
         # Strip empty spin
-        text.gsub!(/\{\|*\}/, "")
+        cleaned.gsub!(EMPTY_SPIN_REGEXP, "")
 
         # Remove spin with only one choice
-        text.gsub!(/\{([^\{\}\|]+)\}/, '\1')
+        cleaned.gsub!(ONE_CHOICE_SPIN_REGEXP, '\1')
 
-        break if text == text_before_run
+        break if cleaned == text_before_run
       end
 
-      text
+      cleaned
     end
 
-    def parse(text, level = 1)
-      return { parsed: text, max_level: level - 1 } unless text.include?("{")
+    INNER_SPIN_REGEXP = /\{([^\{\}]+)\}/
 
-      text.gsub!(/\{([^\{\}]+)\}/) do |match|
-        match.gsub!(/\{/, "__SPIN_BEGIN_#{level}__")
-        match.gsub!(/\}/, "__SPIN_END_#{level}__")
-        match.gsub!(/\|/, "__SPIN_OR_#{level}__")
-      end
+    def parse(text)
+      parsed = text.dup
 
-      parse(text, level + 1)
-    end
+      level = 0
+      loop do
+        level += 1
 
-    def spin_a_level(text_or_array, level)
-      content_array = text_or_array.is_a?(Array) ? text_or_array : [text_or_array]
+        modification_happened = parsed.gsub!(INNER_SPIN_REGEXP) do |match|
+          match.sub!("{", SPIN_BEGIN_FOR_LEVEL[level])
+          match.sub!("}", SPIN_END_FOR_LEVEL[level])
+          match.gsub!("|", SPIN_OR_FOR_LEVEL[level])
+        end
 
-      spin_begin = "__SPIN_BEGIN_#{level}__"
-      spin_end = "__SPIN_END_#{level}__"
-      spin_or = "__SPIN_OR_#{level}__"
+        break unless modification_happened
+      end
+
+      { parsed: parsed, max_level: level - 1 }
+    end
 
-      content_array.map! do |text|
-        if text.include?(spin_begin)
-          # Spin a first one
-          before, vary, after = text.partition(Regexp.new(spin_begin + ".+?" + spin_end))
-          vary.gsub!(Regexp.union(spin_begin, spin_end), "")
+    def spin_a_level(contents, level:)
+      contents.flat_map do |text|
+        parts = extract_parts(text, level: level)
 
-          varies = vary.split(Regexp.new(spin_or), -1)
-          varies.map! { |choice| before + choice + after }
+        parts.map! do |part|
+          spin_a_level(part, level: level - 1)
+        end if level >= 2
 
-          # Continue spinning the level if there are other same level spin or just return
-          if after.include?(spin_begin)
-            spin_a_level(varies, level).flatten
-          else
-            varies
+        if parts.length > 1
+          parts[0].product(*parts[1..-1]).tap do |products|
+            products.map!(&:join)
           end
         else
-          text
+          parts[0]
         end
       end
-
-      content_array.flatten
     end
 
-    def spin_all_level(text_or_array, from_level)
-      content_array = text_or_array.is_a?(Array) ? text_or_array : [text_or_array]
+    private
 
-      if from_level > 0
-        (1..from_level).reverse_each do |level|
-          content_array = spin_a_level(content_array, level)
-        end
+    def extract_parts(text, level:)
+      parts = []
+
+      loop do
+        before, spin, after = text.partition(PARTITIONNER_REGEXP_FOR_LEVEL[level])
+
+        # Before
+        parts << [before] if before != ""
+
+        break if spin == ""
+
+        # Let's vary
+        spin.sub!(SPIN_BEGIN_FOR_LEVEL[level], "")
+        spin.sub!(SPIN_END_FOR_LEVEL[level], "")
+        parts << spin.split(SPIN_OR_FOR_LEVEL[level], -1)
+
+        # After
+        text = after
       end
 
-      content_array.delete_if(&:empty?).uniq
+      parts
     end
 
   end

data/spec/content_spinning_spec.rb

@@ -37,6 +37,7 @@ describe ContentSpinning do
     it "keep legitimate spin" do
       expect(ContentSpinning.clean("{a|b}")).to eq("{a|b}")
       expect(ContentSpinning.clean("a{b|c}")).to eq("a{b|c}")
+      expect(ContentSpinning.clean("a{b|}")).to eq("a{b|}")
       expect(ContentSpinning.clean("{{a|b}|c}")).to eq("{{a|b}|c}")
     end
   end
@@ -89,19 +90,14 @@ describe ContentSpinning do
       expect(ContentSpinning.spin("{a}")).to eq(["a"])
       expect(ContentSpinning.spin("a{b}")).to eq(["ab"])
       expect(ContentSpinning.spin("a{b}c")).to eq(["abc"])
-      expect(ContentSpinning.spin("{a}{b}")).to eq(["ab"])
-      expect(ContentSpinning.spin("a{b}{c}d")).to eq(["abcd"])
     end
 
     it "manages two spin" do
-      expect(ContentSpinning.spin("{a}")).to eq(["a"])
-      expect(ContentSpinning.spin("a{b}")).to eq(["ab"])
-      expect(ContentSpinning.spin("a{b}c")).to eq(["abc"])
       expect(ContentSpinning.spin("{a}{b}")).to eq(["ab"])
       expect(ContentSpinning.spin("a{b}{c}d")).to eq(["abcd"])
     end
 
-    it "manages spin with an empty choice" do
+    it "manages spin with an empty choices" do
       expect(ContentSpinning.spin("{|a}")).to eq(["a"])
       expect(ContentSpinning.spin("{|a}b")).to eq(%w(b ab))
       expect(ContentSpinning.spin("{a|}b")).to eq(%w(ab b))
@@ -109,13 +105,14 @@ describe ContentSpinning do
       expect(ContentSpinning.spin("a{b|}{c|}d")).to eq(%w(abcd abd acd ad))
     end
 
-    it "manages spin with two choice" do
+    it "manages spin with two choices" do
       expect(ContentSpinning.spin("{a|b}")).to eq(%w(a b))
       expect(ContentSpinning.spin("{a|b}c")).to eq(%w(ac bc))
       expect(ContentSpinning.spin("{a|b}{c|d}")).to eq(%w(ac ad bc bd))
+      expect(ContentSpinning.spin("{a|b}c{d|e}")).to eq(%w(acd ace bcd bce))
     end
 
-    it "manages spin with three choice" do
+    it "manages spin with three choices" do
       expect(ContentSpinning.spin("{a|b|c}")).to eq(%w(a b c))
       expect(ContentSpinning.spin("{a|b|c}d")).to eq(%w(ad bd cd))
       expect(ContentSpinning.spin("{a|b|c}{d|e}")).to eq(%w(ad ae bd be cd ce))
@@ -125,6 +122,11 @@ describe ContentSpinning do
       expect(ContentSpinning.spin("{a{b|c}|d}")).to eq(%w(ab ac d))
       expect(ContentSpinning.spin("{{a|b}|c}")).to eq(%w(a b c))
       expect(ContentSpinning.spin("{a|{b|c}}")).to eq(%w(a b c))
+      expect(ContentSpinning.spin("{a|{b|c}}{d|e}")).to eq(%w(ad ae bd be cd ce))
+    end
+
+    it "manages recursive spin with empty choices" do
+      expect(ContentSpinning.spin("{a|{b|{c|{d|e}}}}")).to eq(%w(a b c d e))
     end
 
     it "does not return twice the same result" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: content_spinning
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Maxime Garcia