content_spinning 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c13ac04efa5b45c6a59cf3bbea6a47ea9bace674
-  data.tar.gz: 32b6b31adbc605a54d3b7673250f3a307c3cc167
+  metadata.gz: 725d38ecb0875c5f125823a80e16105d65875327
+  data.tar.gz: feaff568e498f301547e05d5472e7ff4dd9ea4f0
 SHA512:
-  metadata.gz: f91381ee1a24e4218b403be1ce88cb2201e456077d110e7db07157af5163783d66a46906c13bdff0fb24badce6b3347809e0da338615c3fe7b03a8babb2827d7
-  data.tar.gz: e95ff3c4eb4435172f871ad9ce119c3fb915bb0cc1cdb0141d81a339475008046aac51042a37ed36e2d9f53e0fabb1a7475fc982b1f53883d440ac0bcd0c2036
+  metadata.gz: 1a1c3bfcd8dc80d0690326333d197e6f4ddae3f19e09abad7d318dddcece9c42be5e4d1448bef2eec17ac59335b6ae2de892fa548ea2bc89107952641d2ebd36
+  data.tar.gz: 51550db06f73c46870dfaedc4e90bf913b5cd8f4fbb0b2064d3b6e3bca77b7bf8480633a51f12325d3b4d5d12f2d774a9314a8afebf6966c4d5c52b69715dc57

data/README.md

@@ -8,7 +8,7 @@ It manages nested spinning.
 ```ruby
 "Hi {there|you}! I'm {efficient|productive}.".spin
 # or
-ContentSpinning.spin "Hi {there|you}! I'm {efficient|productive}."
+ContentSpinning.spin("Hi {there|you}! I'm {efficient|productive}.")
 ```
 
 returns this array :
@@ -28,6 +28,56 @@ returns this array :
 gem install content_spinning
 ```
 
+## Usage
+
+### All spins
+
+Calculating the number of possibilities:
+
+```ruby
+> ContentSpinning.new("Hi {there|you}! I'm {efficient|productive}.").count
+
+4
+```
+
+Generating:
+
+```ruby
+> ContentSpinning.new("Hi {there|you}! I'm {efficient|productive}.").spin
+
+[
+  "Hi there! I'm efficient.",
+  "Hi there! I'm productive.",
+  "Hi you! I'm efficient.",
+  "Hi you! I'm productive."
+]
+```
+
+Beware, spins being combinatory, generating all the spins could be quite long.
+
+### Partial spins
+
+There is no guaranty of unicity among the results returned (this is random).
+If you ask for a limit greater than the number of possibilities, this returns all the possibilities.
+
+```ruby
+> ContentSpinning.new("Hi {there|you}! I'm {efficient|productive}.").spin(limit: 2)
+
+[
+  "Hi there! I'm efficient.",
+  "Hi you! I'm productive."
+]
+
+> ContentSpinning.new("Hi {there|you}! I'm {efficient|productive}.").spin(limit: 500)
+
+[
+  "Hi there! I'm efficient.",
+  "Hi there! I'm productive.",
+  "Hi you! I'm efficient.",
+  "Hi you! I'm productive."
+]
+```
+
 ## Todo
 
 A few things to do :

data/lib/content_spinning.rb

@@ -1,117 +1,88 @@
 require "content_spinning/core_ext/string"
+require "content_spinning/sentence"
+require "content_spinning/spinner"
+require "content_spinning/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 ContentSpinning
 
   class << self
 
-    def spin(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!
-
-      contents
+    def spin(source, limit: nil)
+      new(source).spin(limit: limit)
     end
 
-    EMPTY_SPIN_REGEXP = /\{\|*\}/
-    ONE_CHOICE_SPIN_REGEXP = /\{([^\{\}\|]+)\}/
-
-    def clean(text)
-      cleaned = text.dup
+  end
 
-      loop do
-        text_before_run = cleaned.dup
+  def initialize(source)
+    @source = source
+  end
 
-        # Strip empty spin
-        cleaned.gsub!(EMPTY_SPIN_REGEXP, "")
+  attr_reader :source
 
-        # Remove spin with only one choice
-        cleaned.gsub!(ONE_CHOICE_SPIN_REGEXP, '\1')
+  def count
+    parse.count
+  end
 
-        break if cleaned == text_before_run
+  SPIN_END = "}"
+  SPIN_OR = "|"
+  SPIN_START = "{"
+
+  def parse
+    return @root if defined?(@root)
+
+    heap = [Sentence.new]
+
+    source.scan(/ [{}|] | [^{}|]+ /x).each do |part|
+      current = heap.last
+
+      if part == SPIN_START
+        spinner = ::ContentSpinning::Spinner.new
+        current << spinner
+        heap << spinner
+
+        sentence = ::ContentSpinning::Sentence.new
+        spinner << sentence
+        heap << sentence
+      elsif part == SPIN_OR
+        heap.pop
+        spinner = heap.last
+        sentence = ::ContentSpinning::Sentence.new
+        spinner << sentence
+        heap << sentence
+      elsif part == SPIN_END
+        heap.pop
+        heap.pop
+      else
+        current << ::ContentSpinning::String.new(part)
       end
-
-      cleaned
     end
 
-    INNER_SPIN_REGEXP = /\{([^\{\}]+)\}/
-
-    def parse(text)
-      parsed = text.dup
-
-      level = 0
-      loop do
-        level += 1
-
-        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
-
-        break unless modification_happened
-      end
-
-      { parsed: parsed, max_level: level - 1 }
-    end
+    @root = heap.first.cleaned
+  end
 
-    def spin_a_level(contents, level:)
-      contents.flat_map do |text|
-        parts = extract_parts(text, level: level)
-
-        parts.map! do |part|
-          spin_a_level(part, level: level - 1)
-        end if level >= 2
-
-        if parts.length > 1
-          parts[0].product(*parts[1..-1]).tap do |products|
-            products.map!(&:join)
-          end
-        else
-          parts[0]
-        end
-      end
+  def spin(limit: nil)
+    if limit && limit < count
+      spin_with_limit(limit: limit)
+    else
+      spin_all
     end
+  end
 
-    private
-
-    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)
+  def spin_all
+    parse.spin
+  end
 
-        # After
-        text = after
-      end
+  def spin_with_limit(limit:)
+    parsed = parse
 
-      parts
+    results = Array.new(limit)
+    results.map! do
+      parsed.random
     end
+  end
 
+  def to_source
+    parse.to_source
   end
 
 end

data/lib/content_spinning/core_ext/string.rb

@@ -1,7 +1,7 @@
 class String
 
-  def spin
-    ContentSpinning.spin(self)
+  def spin(limit: nil)
+    ContentSpinning.spin(self, limit: limit)
   end
 
 end

data/lib/content_spinning/sentence.rb

@@ -0,0 +1,58 @@
+class ContentSpinning
+
+  class Sentence < ::Array
+
+    def initialize(*items)
+      push(*items)
+    end
+
+    def cleaned
+      map!(&:cleaned)
+
+      case length
+      when 0
+        ::ContentSpinning::String.new("")
+      when 1
+        first
+      else
+        self
+      end
+    end
+
+    def count
+      case length
+      when 0
+        1
+      else
+        map(&:count).inject(:*)
+      end
+    end
+
+    def inspect
+      "<Sentence [#{map(&:inspect).join(", ")}]>"
+    end
+
+    def random
+      map(&:random).join
+    end
+
+    def spin
+      spinned = map(&:spin)
+
+      case spinned.length
+      when 1
+        spinned[0]
+      else
+        spinned[0].product(*spinned[1..-1]).tap do |products|
+          products.map!(&:join)
+        end
+      end
+    end
+
+    def to_source
+      map(&:to_source).join
+    end
+
+  end
+
+end

data/lib/content_spinning/spinner.rb

@@ -0,0 +1,43 @@
+class ContentSpinning
+
+  class Spinner < ::Array
+
+    def initialize(*items)
+      push(*items)
+    end
+
+    def cleaned
+      map!(&:cleaned)
+
+      uniq!
+
+      if length == 1
+        first
+      else
+        self
+      end
+    end
+
+    def count
+      map(&:count).inject(:+)
+    end
+
+    def inspect
+      "<Spinner {#{map(&:inspect).join(" | ")}}>"
+    end
+
+    def random
+      sample.random
+    end
+
+    def spin
+      flat_map(&:spin)
+    end
+
+    def to_source
+      "{#{map(&:to_source).join("|")}}"
+    end
+
+  end
+
+end

data/lib/content_spinning/string.rb

@@ -0,0 +1,35 @@
+class ContentSpinning
+
+  class String < ::String
+
+    def initialize(text)
+      self.<<(text)
+    end
+
+    def cleaned
+      self
+    end
+
+    def count
+      1
+    end
+
+    def inspect
+      "<String {#{inspect}}>"
+    end
+
+    def random
+      self
+    end
+
+    def spin
+      [self]
+    end
+
+    def to_source
+      self
+    end
+
+  end
+
+end

data/lib/content_spinning/version.rb

@@ -1,8 +1,8 @@
-module ContentSpinning
+class ContentSpinning
 
   module Version
 
-    STRING = "0.2.0".freeze
+    STRING = "0.3.0".freeze
 
   end
 

data/spec/content_spinning/core_ext/string_spec.rb

@@ -7,7 +7,7 @@ describe String do
     end
 
     it "calls the spin function of ContentSpinning module with the string in argument" do
-      expect(ContentSpinning).to receive(:spin).with("AaBb")
+      expect(ContentSpinning).to receive(:spin).with("AaBb", limit: nil)
       "AaBb".spin
     end
 

data/spec/content_spinning_spec.rb

@@ -1,76 +1,118 @@
 require "spec_helper"
 
 describe ContentSpinning do
-  describe "#clean" do
-    it "returns the string if there is no spin" do
-      expect(ContentSpinning.clean("AaBb")).to eq("AaBb")
+
+  describe "#count" do
+    it "returns an array" do
+      expect(ContentSpinning.new("AaBb").count).to eq(1)
     end
 
-    it "strips empty spin" do
-      expect(ContentSpinning.clean("a{}")).to eq("a")
-      expect(ContentSpinning.clean("a{|}")).to eq("a")
-      expect(ContentSpinning.clean("a{||}")).to eq("a")
-      expect(ContentSpinning.clean("{}a{}")).to eq("a")
-      expect(ContentSpinning.clean("{}a{|}")).to eq("a")
+    it "handles empty spin source" do
+      expect(ContentSpinning.new("").count).to eq(1)
+    end
+
+    it "strips empty choices" do
+      expect(ContentSpinning.new("a{}").count).to eq(1)
+      expect(ContentSpinning.new("a{|}").count).to eq(1)
+      expect(ContentSpinning.new("a{||}").count).to eq(1)
+      expect(ContentSpinning.new("{}a{}").count).to eq(1)
+      expect(ContentSpinning.new("{}a{|}").count).to eq(1)
+    end
+
+    it "keeps empty strings from the returned array" do
+      expect(ContentSpinning.new("{|a}").count).to eq(2)
+      expect(ContentSpinning.new("{a|}").count).to eq(2)
+    end
+
+    it "manages one spin" do
+      expect(ContentSpinning.new("{a}").count).to eq(1)
+      expect(ContentSpinning.new("a{b}").count).to eq(1)
+      expect(ContentSpinning.new("a{b}c").count).to eq(1)
+    end
+
+    it "manages two spin" do
+      expect(ContentSpinning.new("{a}{b}").count).to eq(1)
+      expect(ContentSpinning.new("a{b}{c}d").count).to eq(1)
+    end
 
-      expect(ContentSpinning.clean("a{{}}")).to eq("a")
-      expect(ContentSpinning.clean("a{{|}}")).to eq("a")
-      expect(ContentSpinning.clean("a{{}|}")).to eq("a")
+    it "manages spin with an empty choices" do
+      expect(ContentSpinning.new("{|a}").count).to eq(2)
+      expect(ContentSpinning.new("{|a}b").count).to eq(2)
+      expect(ContentSpinning.new("{a|}b").count).to eq(2)
+      expect(ContentSpinning.new("{a|}{b|}").count).to eq(4)
+      expect(ContentSpinning.new("a{b|}{c|}d").count).to eq(4)
+    end
 
-      expect(ContentSpinning.clean("a{a{}}")).to eq("aa")
+    it "manages spin with two choices" do
+      expect(ContentSpinning.new("{a|b}").count).to eq(2)
+      expect(ContentSpinning.new("{a|b}c").count).to eq(2)
+      expect(ContentSpinning.new("{a|b}{c|d}").count).to eq(4)
+      expect(ContentSpinning.new("{a|b}c{d|e}").count).to eq(4)
     end
 
-    it "remove spin with no choice" do
-      expect(ContentSpinning.clean("{a}")).to eq("a")
-      expect(ContentSpinning.clean("a{b}")).to eq("ab")
-      expect(ContentSpinning.clean("a{b}c")).to eq("abc")
-      expect(ContentSpinning.clean("a{b}c{d}e")).to eq("abcde")
+    it "manages spin with three choices" do
+      expect(ContentSpinning.new("{a|b|c}").count).to eq(3)
+      expect(ContentSpinning.new("{a|b|c}d").count).to eq(3)
+      expect(ContentSpinning.new("{a|b|c}{d|e}").count).to eq(6)
+    end
 
-      expect(ContentSpinning.clean("{{a}}")).to eq("a")
-      expect(ContentSpinning.clean("a{{b}}")).to eq("ab")
-      expect(ContentSpinning.clean("a{{b}}c")).to eq("abc")
-      expect(ContentSpinning.clean("a{{b}}c{{d}}e")).to eq("abcde")
+    it "manages recursive spin" do
+      expect(ContentSpinning.new("{a{b|c}|d}").count).to eq(3)
+      expect(ContentSpinning.new("{{a|b}|c}").count).to eq(3)
+      expect(ContentSpinning.new("{a|{b|c}}").count).to eq(3)
+      expect(ContentSpinning.new("{a|{b|c}}{d|e}").count).to eq(6)
+    end
 
-      expect(ContentSpinning.clean("{{{a}}}")).to eq("a")
+    it "manages recursive spin with empty choices" do
+      expect(ContentSpinning.new("{a|{b|{c|{d|e}}}}").count).to eq(5)
     end
 
-    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}")
+    it "manages duplicate choices" do
+      expect(ContentSpinning.new("{a|a}").count).to eq(1)
     end
   end
 
   describe "#parse" do
     it "returns the string if there is no spin" do
-      expect(ContentSpinning.parse("AaBb")).to eq(max_level: 0, parsed: "AaBb")
+      expect(ContentSpinning.new("AaBb").parse).to eq("AaBb")
     end
 
     it "parses simple spin" do
-      expect(ContentSpinning.parse("{a|b}")).to eq(max_level: 1, parsed: "__SPIN_BEGIN_1__a__SPIN_OR_1__b__SPIN_END_1__")
-      expect(ContentSpinning.parse("a{b|c}")).to eq(max_level: 1, parsed: "a__SPIN_BEGIN_1__b__SPIN_OR_1__c__SPIN_END_1__")
-      expect(ContentSpinning.parse("{a|b}c{d|e}")).to eq(max_level: 1, parsed: "__SPIN_BEGIN_1__a__SPIN_OR_1__b__SPIN_END_1__c__SPIN_BEGIN_1__d__SPIN_OR_1__e__SPIN_END_1__")
+      expect(ContentSpinning.new("{a|b}").parse).to eq(
+        ContentSpinning::Spinner.new("a", "b")
+      )
+      expect(ContentSpinning.new("a{b|c}").parse).to eq(
+        ContentSpinning::Sentence.new(
+          "a",
+          ContentSpinning::Spinner.new("b", "c")
+        )
+      )
+      expect(ContentSpinning.new("{a|b}c{d|e}").parse).to eq(
+        ContentSpinning::Sentence.new(
+          ContentSpinning::Spinner.new("a", "b"),
+          "c",
+          ContentSpinning::Spinner.new("d", "e")
+        )
+      )
     end
 
     it "manages recursive spin" do
-      expect(ContentSpinning.parse("{{a|b}|c}")).to eq(max_level: 2, parsed: "__SPIN_BEGIN_2____SPIN_BEGIN_1__a__SPIN_OR_1__b__SPIN_END_1____SPIN_OR_2__c__SPIN_END_2__")
-      expect(ContentSpinning.parse("{a|{b|c}}")).to eq(max_level: 2, parsed: "__SPIN_BEGIN_2__a__SPIN_OR_2____SPIN_BEGIN_1__b__SPIN_OR_1__c__SPIN_END_1____SPIN_END_2__")
+      expect(ContentSpinning.new("{{a|b}|c}").parse).to eq(
+        ContentSpinning::Spinner.new(ContentSpinning::Spinner.new("a", "b"), "c")
+      )
+      expect(ContentSpinning.new("{a|{b|c}}").parse).to eq(
+        ContentSpinning::Spinner.new("a", ContentSpinning::Spinner.new("b", "c"))
+      )
     end
   end
 
-  describe "#spin" do
-    it "calls the clean function of ContentSpinning module with the string in argument" do
-      expect(ContentSpinning).to receive(:clean).with("AaBb").and_return("AaBb")
-      ContentSpinning.spin("AaBb")
-    end
-
+  describe ".spin" do
     it "returns an array" do
       expect(ContentSpinning.spin("AaBb")).to eq(["AaBb"])
     end
 
-    it "returns an empty array if the string to spin is empty" do
-      expect(ContentSpinning.spin("")).to eq([])
+    it "handles empty spin source" do
+      expect(ContentSpinning.spin("")).to eq([""])
     end
 
     it "strips empty choices" do
@@ -81,9 +123,9 @@ describe ContentSpinning do
       expect(ContentSpinning.spin("{}a{|}")).to eq(["a"])
     end
 
-    it "strips empty strings from the returned array" do
-      expect(ContentSpinning.spin("{|a}")).to eq(["a"])
-      expect(ContentSpinning.spin("{a|}")).to eq(["a"])
+    it "keeps empty strings from the returned array" do
+      expect(ContentSpinning.spin("{|a}")).to eq(["", "a"])
+      expect(ContentSpinning.spin("{a|}")).to eq(["a", ""])
     end
 
     it "manages one spin" do
@@ -98,10 +140,10 @@ describe ContentSpinning do
     end
 
     it "manages spin with an empty choices" do
-      expect(ContentSpinning.spin("{|a}")).to eq(["a"])
+      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))
-      expect(ContentSpinning.spin("{a|}{b|}")).to eq(%w(ab a b))
+      expect(ContentSpinning.spin("{a|}{b|}")).to eq(%w(ab a b) + [""])
       expect(ContentSpinning.spin("a{b|}{c|}d")).to eq(%w(abcd abd acd ad))
     end
 
@@ -139,5 +181,65 @@ describe ContentSpinning do
         ContentSpinning.spin(source)
       }.not_to change { source }
     end
+
+    context 'with limit' do
+      before { @old_seed = Random.srand(2736) }
+      after { Random.srand(@old_seed) }
+
+      it "manages recursive spin with empty choices" do
+        expect(ContentSpinning.spin("{a|{b|{c|{d|e}}}}_z", limit: 2)).to eq(%w(d_z a_z))
+      end
+
+      it "manages recursive spin" do
+        expect(ContentSpinning.spin("{a|{b|c}}{d|e}_z", limit: 2)).to eq(%w(ce_z ad_z))
+      end
+    end
+  end
+
+  describe "#to_source" do
+    it "returns the string if there is no spin" do
+      expect(ContentSpinning.new("AaBb").to_source).to eq("AaBb")
+    end
+
+    it "strips empty spin" do
+      expect(ContentSpinning.new("a{}").to_source).to eq("a")
+      expect(ContentSpinning.new("a{|}").to_source).to eq("a")
+      expect(ContentSpinning.new("a{||}").to_source).to eq("a")
+      expect(ContentSpinning.new("{}a{}").to_source).to eq("a")
+      expect(ContentSpinning.new("{}a{|}").to_source).to eq("a")
+
+      expect(ContentSpinning.new("a{{}}").to_source).to eq("a")
+      expect(ContentSpinning.new("a{{|}}").to_source).to eq("a")
+      expect(ContentSpinning.new("a{{}|}").to_source).to eq("a")
+
+      expect(ContentSpinning.new("a{a{}}").to_source).to eq("aa")
+    end
+
+    it "removes spin with no choice" do
+      expect(ContentSpinning.new("{a}").to_source).to eq("a")
+      expect(ContentSpinning.new("a{b}").to_source).to eq("ab")
+      expect(ContentSpinning.new("a{b}c").to_source).to eq("abc")
+      expect(ContentSpinning.new("a{b}c{d}e").to_source).to eq("abcde")
+
+      expect(ContentSpinning.new("{{a}}").to_source).to eq("a")
+      expect(ContentSpinning.new("a{{b}}").to_source).to eq("ab")
+      expect(ContentSpinning.new("a{{b}}c").to_source).to eq("abc")
+      expect(ContentSpinning.new("a{{b}}c{{d}}e").to_source).to eq("abcde")
+
+      expect(ContentSpinning.new("{{{a}}}").to_source).to eq("a")
+    end
+
+    it "removes duplicate choices" do
+      expect(ContentSpinning.new("{a|a}").to_source).to eq("a")
+      expect(ContentSpinning.new("{a|a|b}").to_source).to eq("{a|b}")
+      expect(ContentSpinning.new("{a|b|a|b}").to_source).to eq("{a|b}")
+    end
+
+    it "keeps legitimate spin" do
+      expect(ContentSpinning.new("{a|b}").to_source).to eq("{a|b}")
+      expect(ContentSpinning.new("a{b|c}").to_source).to eq("a{b|c}")
+      expect(ContentSpinning.new("a{b|}").to_source).to eq("a{b|}")
+      expect(ContentSpinning.new("{{a|b}|c}").to_source).to eq("{{a|b}|c}")
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: content_spinning
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Maxime Garcia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-15 00:00:00.000000000 Z
+date: 2017-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -44,6 +44,9 @@ files:
 - README.md
 - lib/content_spinning.rb
 - lib/content_spinning/core_ext/string.rb
+- lib/content_spinning/sentence.rb
+- lib/content_spinning/spinner.rb
+- lib/content_spinning/string.rb
 - lib/content_spinning/version.rb
 - spec/content_spinning/core_ext/string_spec.rb
 - spec/content_spinning_spec.rb
@@ -68,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Content Spinning