content_spinning 0.0.2 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79295ec814e234e885f05f6a026177cc49384acf
+  data.tar.gz: b0cee4376b527d0b7a1d1ef0373ff51e385fb8b4
+SHA512:
+  metadata.gz: 3b44c72fddeafdd9fda092eb44c38f2a30547f974be9771ebf7fe2e92085ebdaaf6ba25991ce213bd4eb1e1c9db4f619d787ff5986b9e2b26528fce5dd5b0381
+  data.tar.gz: 22b09a4e78ccc4686a9387fe5b4313f35abf5d92bf7fe8ff490b2d6569424db83dac152770d66f05c7719ad518a027fc846bd10df7006656abad6e54787036bf

data/lib/content_spinning/core_ext/string.rb

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

data/lib/content_spinning/version.rb

@@ -1,6 +1,9 @@
 module ContentSpinning
+
   module Version
-    STRING = '0.0.2'
+
+    STRING = "0.1.0".freeze
+
   end
-end
 
+end

data/lib/content_spinning.rb

@@ -1,7 +1,11 @@
+require "content_spinning/core_ext/string"
+
 module ContentSpinning
+
   class << self
 
     def spin(text)
+      text = text.dup
       text = clean(text)
       result = parse(text)
 
@@ -9,22 +13,23 @@ module ContentSpinning
     end
 
     def clean(text)
-      begin
-        text_before_run = text.clone
+      loop do
+        text_before_run = text.dup
 
         # Strip empty spin
-        text.gsub!(/\{\|*\}/, '')
+        text.gsub!(/\{\|*\}/, "")
 
         # Remove spin with only one choice
         text.gsub!(/\{([^\{\}\|]+)\}/, '\1')
 
-      end while (text != text_before_run)
+        break if text == text_before_run
+      end
 
       text
     end
 
     def parse(text, level = 1)
-      return {:parsed => text, :max_level => level - 1} unless text.include? "{"
+      return { parsed: text, max_level: level - 1 } unless text.include?("{")
 
       text.gsub!(/\{([^\{\}]+)\}/) do |match|
         match.gsub!(/\{/, "__SPIN_BEGIN_#{level}__")
@@ -32,7 +37,7 @@ module ContentSpinning
         match.gsub!(/\|/, "__SPIN_OR_#{level}__")
       end
 
-      parse(text, level+1)
+      parse(text, level + 1)
     end
 
     def spin_a_level(text_or_array, level)
@@ -43,16 +48,16 @@ module ContentSpinning
       spin_or = "__SPIN_OR_#{level}__"
 
       content_array.map! do |text|
-        if text.include? spin_begin
+        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), '')
+          before, vary, after = text.partition(Regexp.new(spin_begin + ".+?" + spin_end))
+          vary.gsub!(Regexp.union(spin_begin, spin_end), "")
 
           varies = vary.split(Regexp.new(spin_or), -1)
-          varies.map! { |vary| before + vary + after }
+          varies.map! { |choice| before + choice + after }
 
           # Continue spinning the level if there are other same level spin or just return
-          if after.include? spin_begin
+          if after.include?(spin_begin)
             spin_a_level(varies, level).flatten
           else
             varies
@@ -78,11 +83,5 @@ module ContentSpinning
     end
 
   end
-end
 
-String.class_eval do
-  def spin
-    ContentSpinning.spin(self)
-  end
 end
-

data/spec/content_spinning/core_ext/string_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe String do
+  describe "#spin" do
+    it "is defined" do
+      expect("").to respond_to(:spin)
+    end
+
+    it "calls the spin function of ContentSpinning module with the string in argument" do
+      expect(ContentSpinning).to receive(:spin).with("AaBb")
+      "AaBb".spin
+    end
+
+    it "does not modify the source string" do
+      source = "{a|b}"
+      expect {
+        source.spin
+      }.not_to change { source }
+    end
+  end
+end

data/spec/content_spinning_spec.rb

@@ -1,152 +1,141 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe String do
-
-  describe "spin" do
-    it "should be defined" do
-      String.new.respond_to?(:spin).should be_true
-    end
-    it "should call the spin function of ContentSpinning module with the string in argument" do
-      ContentSpinning.should_receive(:spin).with("AaBb")
-      "AaBb".spin
-    end
-  end
-
-end
+require "spec_helper"
 
 describe ContentSpinning do
-
-  describe "clean" do
-    it "should return the string if there is no spin" do
-      ContentSpinning.clean("AaBb").should eq "AaBb"
+  describe "#clean" do
+    it "returns the string if there is no spin" do
+      expect(ContentSpinning.clean("AaBb")).to eq("AaBb")
     end
 
-    it "should strip empty spin" do
-      ContentSpinning.clean("a{}").should eq "a"
-      ContentSpinning.clean("a{|}").should eq "a"
-      ContentSpinning.clean("a{||}").should eq "a"
-      ContentSpinning.clean("{}a{}").should eq "a"
-      ContentSpinning.clean("{}a{|}").should eq "a"
+    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")
 
-      ContentSpinning.clean("a{{}}").should eq "a"
-      ContentSpinning.clean("a{{|}}").should eq "a"
-      ContentSpinning.clean("a{{}|}").should eq "a"
+      expect(ContentSpinning.clean("a{{}}")).to eq("a")
+      expect(ContentSpinning.clean("a{{|}}")).to eq("a")
+      expect(ContentSpinning.clean("a{{}|}")).to eq("a")
 
-      ContentSpinning.clean("a{a{}}").should eq "aa"
+      expect(ContentSpinning.clean("a{a{}}")).to eq("aa")
     end
 
-    it "should remove spin with no choice" do
-      ContentSpinning.clean("{a}").should eq "a"
-      ContentSpinning.clean("a{b}").should eq "ab"
-      ContentSpinning.clean("a{b}c").should eq "abc"
-      ContentSpinning.clean("a{b}c{d}e").should eq "abcde"
+    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")
 
-      ContentSpinning.clean("{{a}}").should eq "a"
-      ContentSpinning.clean("a{{b}}").should eq "ab"
-      ContentSpinning.clean("a{{b}}c").should eq "abc"
-      ContentSpinning.clean("a{{b}}c{{d}}e").should eq "abcde"
+      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")
 
-      ContentSpinning.clean("{{{a}}}").should eq "a"
+      expect(ContentSpinning.clean("{{{a}}}")).to eq("a")
     end
 
-    it "should keep legitimate spin" do
-      ContentSpinning.clean("{a|b}").should eq "{a|b}"
-      ContentSpinning.clean("a{b|c}").should eq "a{b|c}"
-      ContentSpinning.clean("{{a|b}|c}").should eq "{{a|b}|c}"
+    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}|c}")).to eq("{{a|b}|c}")
     end
   end
 
-  describe "parse" do
-    it "should return the string if there is no spin" do
-      ContentSpinning.parse("AaBb").should eq :max_level => 0, :parsed => "AaBb"
+  describe "#parse" do
+    it "returns the string if there is no spin" do
+      expect(ContentSpinning.parse("AaBb")).to eq(max_level: 0, parsed: "AaBb")
     end
 
-    it "should parse simple spin" do
-      ContentSpinning.parse("{a|b}").should eq :max_level => 1, :parsed => "__SPIN_BEGIN_1__a__SPIN_OR_1__b__SPIN_END_1__"
-      ContentSpinning.parse("a{b|c}").should eq :max_level => 1, :parsed => "a__SPIN_BEGIN_1__b__SPIN_OR_1__c__SPIN_END_1__"
-      ContentSpinning.parse("{a|b}c{d|e}").should 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__"
+    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__")
     end
 
-    it "should manage recursive spin" do
-      ContentSpinning.parse("{{a|b}|c}").should 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__"
-      ContentSpinning.parse("{a|{b|c}}").should 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__"
+    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__")
     end
   end
 
-  describe "spin" do
-    it "should call the clean function of ContentSpinning module with the string in argument" do
-      ContentSpinning.should_receive(:clean).with("AaBb").and_return("AaBb")
+  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
 
-    it "should return an array" do
-      "AaBb".spin.should eq ["AaBb"]
+    it "returns an array" do
+      expect(ContentSpinning.spin("AaBb")).to eq(["AaBb"])
     end
 
-    it "should return an empty array if the string to spin is empty" do
-      "".spin.should eq []
+    it "returns an empty array if the string to spin is empty" do
+      expect(ContentSpinning.spin("")).to eq([])
     end
 
-    it "should strip empty choices" do
-      "a{}".spin.should eq ["a"]
-      "a{|}".spin.should eq ["a"]
-      "a{||}".spin.should eq ["a"]
-      "{}a{}".spin.should eq ["a"]
-      "{}a{|}".spin.should eq ["a"]
+    it "strips empty choices" do
+      expect(ContentSpinning.spin("a{}")).to eq(["a"])
+      expect(ContentSpinning.spin("a{|}")).to eq(["a"])
+      expect(ContentSpinning.spin("a{||}")).to eq(["a"])
+      expect(ContentSpinning.spin("{}a{}")).to eq(["a"])
+      expect(ContentSpinning.spin("{}a{|}")).to eq(["a"])
     end
 
-    it "should strip empty strings from the returned array" do
-      "{|a}".spin.should eq ["a"]
-      "{a|}".spin.should eq ["a"]
+    it "strips empty strings from the returned array" do
+      expect(ContentSpinning.spin("{|a}")).to eq(["a"])
+      expect(ContentSpinning.spin("{a|}")).to eq(["a"])
     end
 
-    it "should manage one spin" do
-      "{a}".spin.should eq ["a"]
-      "a{b}".spin.should eq ["ab"]
-      "a{b}c".spin.should eq ["abc"]
-      "{a}{b}".spin.should eq ["ab"]
-      "a{b}{c}d".spin.should eq ["abcd"]
+    it "manages one 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 "should manage two spin" do
-      "{a}".spin.should eq ["a"]
-      "a{b}".spin.should eq ["ab"]
-      "a{b}c".spin.should eq ["abc"]
-      "{a}{b}".spin.should eq ["ab"]
-      "a{b}{c}d".spin.should eq ["abcd"]
+    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 "should manage spin with an empty choice" do
-      "{|a}".spin.should eq ["a"]
-      "{|a}b".spin.should eq ["b", "ab"]
-      "{a|}b".spin.should eq ["ab", "b"]
-      "{a|}{b|}".spin.should eq ["ab", "a", "b"]
-      "a{b|}{c|}d".spin.should eq ["abcd", "abd", "acd", "ad"]
+    it "manages spin with an empty choice" 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))
+      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
 
-    it "should manage spin with two choice" do
-      "{a|b}".spin.should eq ["a", "b"]
-      "{a|b}c".spin.should eq ["ac", "bc"]
-      "{a|b}{c|d}".spin.should eq ["ac", "ad", "bc", "bd"]
+    it "manages spin with two choice" 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))
     end
 
-    it "should manage spin with three choice" do
-      "{a|b|c}".spin.should eq ["a", "b", "c"]
-      "{a|b|c}d".spin.should eq ["ad", "bd", "cd"]
-      "{a|b|c}{d|e}".spin.should eq ["ad", "ae", "bd", "be", "cd", "ce"]
+    it "manages spin with three choice" 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))
     end
 
-    it "should manage recursive spin" do
-      "{a{b|c}|d}".spin.should eq ["ab", "ac", "d"]
-      "{{a|b}|c}".spin.should eq ["a", "b", "c"]
-      "{a|{b|c}}".spin.should eq ["a", "b", "c"]
+    it "manages recursive spin" 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))
     end
 
-    it "should not return twice the same result" do
-      "{a|a}".spin.should eq ["a"]
+    it "does not return twice the same result" do
+      expect(ContentSpinning.spin("{a|a}")).to eq(["a"])
     end
-  end
 
+    it "does not modify the source string" do
+      source = "{a|b}"
+      expect {
+        ContentSpinning.spin(source)
+      }.not_to change { source }
+    end
+  end
 end
-

data/spec/spec_helper.rb

@@ -1,8 +1,5 @@
-require 'rspec'
-require 'content_spinning'
+require "rspec"
+require "content_spinning"
 
-RSpec.configure do |config|
-  config.color_enabled = true
-  config.formatter     = 'documentation'
+RSpec.configure do |_config|
 end
-

metadata

@@ -1,78 +1,78 @@
 --- !ruby/object:Gem::Specification
 name: content_spinning
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
 - Maxime Garcia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-03 00:00:00.000000000 Z
+date: 2016-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &11429000 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '3.4'
   type: :development
   prerelease: false
-  version_requirements: *11429000
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: &11428420 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *11428420
-description: ! "    To spin some text, mainly for SEO purpose.\n\n    Spinning the
-  string \"Hi {there|you}! I'm {efficient|productive}.\" gives\n    these four strings
-  :\n\n    * Hi there! I'm efficient.\n    * Hi there! I'm productive.\n    * Hi you!
-  I'm efficient.\n    * Hi you! I'm productive.\n"
+        version: '3.4'
+description: |
+  To spin some text, mainly for SEO purpose.
+
+  Spinning the string "Hi {there|you}! I'm {efficient|productive}." gives
+  these four strings :
+
+  * Hi there! I'm efficient.
+  * Hi there! I'm productive.
+  * Hi you! I'm efficient.
+  * Hi you! I'm productive.
 email:
-- maxime.garcia@maxbusiness.fr
+- maxime.garcia@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
 - LICENSE
-- lib/content_spinning/version.rb
+- README.md
 - lib/content_spinning.rb
+- lib/content_spinning/core_ext/string.rb
+- lib/content_spinning/version.rb
+- spec/content_spinning/core_ext/string_spec.rb
 - spec/content_spinning_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/maximeg/content_spinning
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 2.6.4
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Content Spinning
 test_files:
+- spec/content_spinning/core_ext/string_spec.rb
 - spec/content_spinning_spec.rb
 - spec/spec_helper.rb