activecleaner 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Maxime Garcia
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,96 @@
+# ActiveCleaner
+
+`ActiveCleaner` is a set of helpers that helps you in cleaning user-typed content in your ActiveModel depending models (ActiveRecord, Mongoid...)
+
+Extra spaces mean extra storage. And it could ruin your indexes and your sortings.
+
+Tired of doing everywhere:
+
+```ruby
+before_validation :clean_title
+
+def clean_title
+  unless title.nil?
+    self.title = title.squish
+  end
+  self.title = nil if title.blank?
+
+  true
+end
+```
+
+### Cleaners included
+
+ * `:string` (StringCleaner, the default one) : cleans all the space characters. It turns `"   A  \n  \t title   \t  "` into `"A title"`.
+ * `:text` (TextCleaner) : like `:string`, but preserves new lines (with a max of 2 successive new lines). Usefull when the field is rendered with the `simple_format` Rails helper.
+ * `:markdown` (MarkdownCleaner) : like `:text`, but preserves spaces in the begining of lines (the indentation). Usefull for... markdown!
+
+
+
+## Installation
+
+Add the gem to your Gemfile:
+
+    gem 'activecleaner'
+
+Or install with RubyGems:
+
+    $ gem install activecleaner
+
+
+
+## Usage
+
+### Basic usage
+
+Add `include ActiveCleaner` in your model and also do:
+
+```ruby
+clean :field_1, :field_2 ... :field_n, options_1: :value, options_2: :value
+```
+
+### Options
+
+ * `:as` (default is `:string`) : the symbol name of the cleaner.
+ * `:nilify` (default is `false`) : set to `nil` when the field was or is cleaned to `""`.
+
+### Example
+
+```ruby
+class Post
+  include Mongoid::Document
+  include ActiveCleaner
+
+  field :title
+  field :subtitle
+  clean :title, :subtitle, nilify: true
+
+  field :body
+  clean :body, as: :text, nilify: true
+end
+```
+
+## Contributing
+
+Contributions and bug reports are welcome.
+
+Clone the repository and run `bundle install` to setup the development environment.
+
+Provide a case spec according to your changes/needs, taking example on existing ones (in `spec/cases`).
+
+To run the specs:
+
+    bundle exec rspec
+
+You can also use `guard` to run the specs during dev.
+
+
+
+## Credits
+
+*   Maxime Garcia [emaxime.com](http://emaxime.com) [@maximegarcia](http://twitter.com/maximegarcia)
+
+
+[License](https://github.com/maximeg/activecleaner/blob/master/LCENSE)
+\- [Report a bug](https://github.com/maximeg/activecleaner/issues)
+[![Continuous Integration status](https://secure.travis-ci.org/maximeg/activecleaner.png)](http://travis-ci.org/maximeg/activecleaner)

data/lib/active_cleaner/base_cleaner.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module ActiveCleaner
+  class BaseCleaner
+
+    attr_reader :attr_name, :options
+
+    # Accepts options that will be made available through the +options+ reader.
+    def initialize(attr_name, options = {})
+      @attr_name = attr_name
+      @options = {
+        :nilify => false,
+      }.merge(options).freeze
+    end
+
+    def self.kind
+      @kind ||= name.split('::').last.underscore.sub(/_cleaner$/, '').to_sym
+    end
+
+    def kind
+      self.class.kind
+    end
+
+    def clean(record)
+      value = record.read_attribute_for_cleaning(attr_name)
+
+      new_value = clean_value(value, record)
+
+      new_value = nil if @options[:nilify] && nilify_value?(new_value, record)
+
+      record.write_attribute_after_cleaning(attr_name, new_value) unless new_value == value
+    end
+
+    def clean_value(value, record=nil)
+      raise NotImplementedError, "Subclasses must implement a clean(value, record=nil) method."
+    end
+
+    # feel free to subclass for your custom cleaner
+    def nilify_value?(value, record=nil)
+      value == ""
+    end
+
+    def ==(other)
+      kind == other.kind && attr_name == other.attr_name && options == other.options
+    end
+
+  end
+end

data/lib/active_cleaner/helper_methods.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module ActiveCleaner
+  module HelperMethods
+
+    def clean(*attr_names)
+      options = attr_names.extract_options!.symbolize_keys
+      attr_names.flatten!
+
+      options[:as] ||= :string
+
+      cleaner = "active_cleaner/#{options.delete(:as)}_cleaner".camelize.constantize
+
+      attr_names.each do |attr_name|
+        clean_with cleaner.new(attr_name, options)
+      end
+    end
+
+    def clean_with(cleaner)
+      self._cleaners[cleaner.attr_name] << cleaner
+    end
+
+  end
+end

data/lib/active_cleaner/markdown_cleaner.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module ActiveCleaner
+  class MarkdownCleaner < BaseCleaner
+
+    def clean_value(old_value, record=nil)
+      unless old_value.nil?
+        value = old_value.dup
+
+        value.strip!
+
+        # clean the new lines mess among OS
+        value.gsub!(/\r\n|\r/, "\n")
+
+        # protect stuff to keep with a markup
+        value.gsub!(/\n/, "__NEW_LINE__")
+        value.gsub!(/(?<=__NEW_LINE__)\s+/) {|match| match.gsub(/\s/, "__SPACE__")}
+
+        value.gsub!(/\s+/, " ")
+        value.gsub!(/(__SPACE__|\s)*__NEW_LINE__\s*/, "__NEW_LINE__")
+        value.gsub!(/(__NEW_LINE__){3,}/, "__NEW_LINE____NEW_LINE__")
+
+        # reverse the safe markup
+        value.gsub!(/__NEW_LINE__/, "\n")
+        value.gsub!(/__SPACE__/, " ")
+
+        value
+      end
+    end
+
+  end
+end

data/lib/active_cleaner/string_cleaner.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module ActiveCleaner
+  class StringCleaner < BaseCleaner
+
+    def clean_value(old_value, record=nil)
+      unless old_value.nil?
+        value = old_value.dup
+
+        value.strip!
+        value.gsub!(/\s+/, " ")
+
+        value
+      end
+    end
+
+  end
+end

data/lib/active_cleaner/text_cleaner.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module ActiveCleaner
+  class TextCleaner < BaseCleaner
+
+    def clean_value(old_value, record=nil)
+      unless old_value.nil?
+        value = old_value.dup
+
+        value.strip!
+
+        # clean the new lines mess among OS
+        value.gsub!(/\r\n|\r/, "\n")
+
+        # protect stuff to keep with a markup
+        value.gsub!(/\n/, "__NEW_LINE__")
+
+        value.gsub!(/\s+/, " ")
+        value.gsub!(/ ?__NEW_LINE__ ?/, "__NEW_LINE__")
+        value.gsub!(/(__NEW_LINE__){3,}/, "__NEW_LINE____NEW_LINE__")
+
+        # reverse the safe markup
+        value.gsub!(/__NEW_LINE__/, "\n")
+
+        value
+      end
+    end
+
+  end
+end

data/lib/active_cleaner/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+module ActiveCleaner
+  module Version
+
+    STRING = '0.1.0'
+
+  end
+end

data/lib/active_cleaner.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'active_support'
+#require 'active_support/rails'
+require 'active_model'
+
+require 'active_cleaner/helper_methods'
+
+require 'active_cleaner/base_cleaner'
+require 'active_cleaner/string_cleaner'
+require 'active_cleaner/text_cleaner'
+require 'active_cleaner/markdown_cleaner'
+
+require 'active_cleaner/version'
+
+module ActiveCleaner
+  extend ActiveSupport::Concern
+
+  included do
+
+    include ActiveModel::Validations
+
+    extend HelperMethods
+    include HelperMethods
+
+    define_callbacks :cleaning, :scope => :name
+
+    class_attribute :_cleaners
+    self._cleaners = Hash.new { |h,k| h[k] = [] }
+
+    set_callback :validate, :before, :run_cleaners!
+
+  end # included
+
+
+  module ClassMethods
+
+    def inherited(base) #:nodoc:
+      dup = _cleaners.dup
+      base._cleaners = dup.each { |k, v| dup[k] = v.dup }
+      super
+    end
+
+  end # ClassMethods
+
+
+  def run_cleaners!
+    self._cleaners.each do |attr_name, cleaners|
+      cleaners.each do |cleaner|
+        cleaner.clean(self)
+      end
+    end
+
+    true
+  end
+
+  def read_attribute_for_cleaning(attr_name)
+    send(attr_name)
+  end
+  def write_attribute_after_cleaning(attr_name, value)
+    send(:"#{attr_name}=", value)
+  end
+
+end

data/lib/activecleaner.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require 'active_cleaner'

data/spec/cases/inherit_spec.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+require "spec_helper"
+
+#
+# The case
+#
+# This is to demonstrate when we want to clean some simple fields
+# in a common STI scenario.
+#
+class Ad
+  include ActiveCleaner
+
+  attr_accessor :title, :name
+
+  clean :title
+  clean :name, as: :string
+end
+
+class CarAd < Ad
+  attr_accessor :body
+
+  clean :body, as: :text
+end
+
+#
+# The specs
+#
+describe "Case: an ad and his inherited car ad" do
+
+  describe Ad, "._cleaners" do
+
+    subject { Ad._cleaners }
+
+    it { should have(2).fields_to_clean }
+
+    it "includes a StringCleaner for #title" do
+      subject[:title].first.should eq(ActiveCleaner::StringCleaner.new(:title))
+    end
+
+    it "includes a StringCleaner for #name" do
+      subject[:name].first.should eq(ActiveCleaner::StringCleaner.new(:name))
+    end
+
+  end # describe
+
+  describe CarAd, "._cleaners" do
+
+    subject { CarAd._cleaners }
+
+    it { should have(3).fields_to_clean }
+
+    it "includes a StringCleaner for #title" do
+      subject[:title].first.should eq(ActiveCleaner::StringCleaner.new(:title))
+    end
+
+    it "includes a StringCleaner for #name" do
+      subject[:name].first.should eq(ActiveCleaner::StringCleaner.new(:name))
+    end
+
+    it "includes a TextCleaner for #body" do
+      subject[:body].first.should eq(ActiveCleaner::TextCleaner.new(:body))
+    end
+
+  end # describe
+
+  context "considering a car ad" do
+
+    before do
+      @car_ad = CarAd.new
+    end
+
+    describe "#title, marked as to clean with no type" do
+
+      it "is untouched when legit" do
+        @car_ad.title = "A good title!"
+        @car_ad.valid?
+        @car_ad.title.should eq "A good title!"
+      end
+
+      it "is cleaned as a string" do
+        @car_ad.title = "  A  \n good  \t title!  "
+        @car_ad.valid?
+        @car_ad.title.should eq "A good title!"
+      end
+
+    end # describe
+
+    describe "#name, marked as to clean as a string" do
+
+      it "is untouched when legit" do
+        @car_ad.name = "John Doe"
+        @car_ad.valid?
+        @car_ad.name.should eq "John Doe"
+      end
+
+      it "is cleaned as a string" do
+        @car_ad.name = "  \t  John  \n  Doe     "
+        @car_ad.valid?
+        @car_ad.name.should eq "John Doe"
+      end
+
+    end # describe
+
+    describe "#body, marked as to clean as a text" do
+
+      it "is untouched when legit" do
+        @car_ad.body = "Lorem ipsum\ndolor sit amet.\n\nLorem."
+        @car_ad.valid?
+        @car_ad.body.should eq "Lorem ipsum\ndolor sit amet.\n\nLorem."
+      end
+
+      it "is cleaned as a text" do
+        @car_ad.body = "Lorem \t ipsum \t \n   dolor \t sit \t amet.\n\n\nLorem."
+        @car_ad.valid?
+        @car_ad.body.should eq "Lorem ipsum\ndolor sit amet.\n\nLorem."
+      end
+
+    end # describe
+
+  end # context
+
+end # describe

data/spec/cases/nilify_spec.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+require "spec_helper"
+
+#
+# The case
+#
+# This is to demonstrate when we want to clean some simple fields and nulify them
+#
+class OptimizedPost
+  include ActiveCleaner
+
+  attr_accessor :title, :name, :body
+
+  clean :title, nilify: true
+  clean :name, as: :string, nilify: true
+  clean :body, as: :text, nilify: true
+end
+
+
+#
+# The specs
+#
+describe "Case: a simple post with nulify" do
+
+  describe OptimizedPost, "._cleaners" do
+
+    subject { OptimizedPost._cleaners }
+
+    it { should have(3).fields_to_clean }
+
+    it "includes a StringCleaner for #title" do
+      subject[:title].first.should eq(ActiveCleaner::StringCleaner.new(:title, nilify: true))
+    end
+
+    it "includes a StringCleaner for #name" do
+      subject[:name].first.should eq(ActiveCleaner::StringCleaner.new(:name, nilify: true))
+    end
+
+    it "includes a TextCleaner for #body" do
+      subject[:body].first.should eq(ActiveCleaner::TextCleaner.new(:body, nilify: true))
+    end
+
+  end # describe
+
+  context "considering a post" do
+
+    before do
+      @post = OptimizedPost.new
+    end
+
+    describe "#title, marked as to clean with no type" do
+
+      it "is untouched when legit" do
+        @post.title = "A good title!"
+        @post.valid?
+        @post.title.should eq "A good title!"
+      end
+
+      it "is nulified" do
+        @post.title = " \n \t "
+        @post.valid?
+        @post.title.should be_nil
+      end
+
+    end # describe
+
+    describe "#name, marked as to clean as a string" do
+
+      it "is untouched when legit" do
+        @post.name = "John Doe"
+        @post.valid?
+        @post.name.should eq "John Doe"
+      end
+
+      it "is nulified" do
+        @post.title = " \n \t "
+        @post.valid?
+        @post.title.should be_nil
+      end
+
+    end # describe
+
+    describe "#body, marked as to clean as a text" do
+
+      it "is untouched when legit" do
+        @post.body = "Lorem ipsum\ndolor sit amet.\n\nLorem."
+        @post.valid?
+        @post.body.should eq "Lorem ipsum\ndolor sit amet.\n\nLorem."
+      end
+
+      it "is nulified" do
+        @post.title = " \n \t "
+        @post.valid?
+        @post.title.should be_nil
+      end
+
+    end # describe
+
+  end # context
+
+end # describe

data/spec/cases/simple_spec.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+require "spec_helper"
+
+#
+# The case
+#
+# This is to demonstrate when we want to clean some simple fields
+#
+class Post
+  include ActiveCleaner
+
+  attr_accessor :title, :name, :body
+
+  clean :title
+  clean :name, as: :string
+  clean :body, as: :text
+end
+
+
+#
+# The specs
+#
+describe "Case: a simple post" do
+
+  describe Post, "._cleaners" do
+
+    subject { Post._cleaners }
+
+    it { should have(3).fields_to_clean }
+
+    it "includes a StringCleaner for #title" do
+      subject[:title].first.should eq(ActiveCleaner::StringCleaner.new(:title))
+    end
+
+    it "includes a StringCleaner for #name" do
+      subject[:name].first.should eq(ActiveCleaner::StringCleaner.new(:name))
+    end
+
+    it "includes a TextCleaner for #body" do
+      subject[:body].first.should eq(ActiveCleaner::TextCleaner.new(:body))
+    end
+
+  end # describe
+
+  context "considering a post" do
+
+    before do
+      @post = Post.new
+    end
+
+    describe "#title, marked as to clean with no type" do
+
+      it "is untouched when legit" do
+        @post.title = "A good title!"
+        @post.valid?
+        @post.title.should eq "A good title!"
+      end
+
+      it "is cleaned as a string" do
+        @post.title = "  A  \n good  \t title!  "
+        @post.valid?
+        @post.title.should eq "A good title!"
+      end
+
+    end # describe
+
+    describe "#name, marked as to clean as a string" do
+
+      it "is untouched when legit" do
+        @post.name = "John Doe"
+        @post.valid?
+        @post.name.should eq "John Doe"
+      end
+
+      it "is cleaned as a string" do
+        @post.name = "  \t  John  \n  Doe     "
+        @post.valid?
+        @post.name.should eq "John Doe"
+      end
+
+    end # describe
+
+    describe "#body, marked as to clean as a text" do
+
+      it "is untouched when legit" do
+        @post.body = "Lorem ipsum\ndolor sit amet.\n\nLorem."
+        @post.valid?
+        @post.body.should eq "Lorem ipsum\ndolor sit amet.\n\nLorem."
+      end
+
+      it "is cleaned as a text" do
+        @post.body = "Lorem \t ipsum \t \n   dolor \t sit \t amet.\n\n\nLorem."
+        @post.valid?
+        @post.body.should eq "Lorem ipsum\ndolor sit amet.\n\nLorem."
+      end
+
+    end # describe
+
+  end # context
+
+end # describe

data/spec/lib/active_cleaner/markdown_cleaner_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ActiveCleaner::MarkdownCleaner do
+
+  before do
+    @cleaner = ActiveCleaner::MarkdownCleaner.new(:body)
+  end
+
+  describe "#clean_value" do
+
+    it "doesn't touch legit value" do
+      body = ""
+      body << "= Title =\n"
+      body << "\n"
+      body << "A first paragraph.\n"
+      body << "\n"
+      body << "A **second** one, with a\n"
+      body << "line break.\n"
+      body << "\n"
+      body << " * first item\n"
+      body << " * second item\n"
+      body << "\n"
+      body << "    <div id=\"test\">\n"
+      body << "      <p>Text</p>\n"
+      body << "    </div>\n"
+      body << "\n"
+      body << "A third paragraph."
+
+      @cleaner.clean_value(body).should eq body
+    end
+
+    it "empties string full of spaces" do
+      [
+        "",
+        " ",
+        "\t",
+        "\n",
+        " \t\n \t\n \t\n \t\n",
+      ].each do |title|
+        @cleaner.clean_value(title).should eq ""
+      end
+    end
+
+    it "cleans repeted spaces" do
+      @cleaner.clean_value("Lorem   ipsum   \ndolor   sit   amet.").should eq "Lorem ipsum\ndolor sit amet."
+      @cleaner.clean_value("Lorem \t ipsum \t \ndolor \t sit \t amet.").should eq "Lorem ipsum\ndolor sit amet."
+    end
+
+    context "considering the spaces in the beggining of lines" do
+      it "preserves them" do
+        @cleaner.clean_value("Lorem ipsum\n   dolor sit amet.").should eq "Lorem ipsum\n   dolor sit amet."
+      end
+      it "clears line full of spaces" do
+        @cleaner.clean_value("Lorem ipsum   \n   \n   dolor sit amet.").should eq "Lorem ipsum\n\n   dolor sit amet."
+      end
+    end
+
+    it "keeps two max succeeding new line" do
+      @cleaner.clean_value("Lorem ipsum\n\n\ndolor sit amet.").should eq "Lorem ipsum\n\ndolor sit amet."
+      @cleaner.clean_value("Lorem ipsum\n\n\n\ndolor sit amet.").should eq "Lorem ipsum\n\ndolor sit amet."
+      @cleaner.clean_value("Lorem ipsum\n  \n  \n  \ndolor sit amet.").should eq "Lorem ipsum\n\ndolor sit amet."
+    end
+
+  end
+
+end

data/spec/lib/active_cleaner/string_cleaner_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ActiveCleaner::StringCleaner do
+
+  before do
+    @cleaner = ActiveCleaner::StringCleaner.new(:title)
+  end
+
+  describe "#clean_value" do
+
+    it "doesn't touch legit value" do
+      @cleaner.clean_value("A good title!").should eq "A good title!"
+    end
+
+    it "empties string full of spaces" do
+      [
+        "",
+        " ",
+        "\t",
+        "\n",
+        " \t\n \t\n \t\n \t\n",
+      ].each do |title|
+        @cleaner.clean_value(title).should eq ""
+      end
+    end
+
+    it "cleans leading and trailing spaces" do
+      @cleaner.clean_value("  A good title!  ").should eq "A good title!"
+    end
+    it "cleans leading and trailing tabs" do
+      @cleaner.clean_value("\tA good title!\t").should eq "A good title!"
+    end
+    it "cleans leading and trailing lines" do
+      @cleaner.clean_value("\nA good title!\n").should eq "A good title!"
+    end
+
+    it "cleans repeted spaces" do
+      @cleaner.clean_value("A    good    title!").should eq "A good title!"
+      @cleaner.clean_value("A  \n good  \t title!").should eq "A good title!"
+    end
+
+  end
+
+end

data/spec/lib/active_cleaner/text_cleaner_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ActiveCleaner::TextCleaner do
+
+  before do
+    @cleaner = ActiveCleaner::TextCleaner.new(:text)
+  end
+
+  describe "#clean_value" do
+
+    it "doesn't touch legit value" do
+      [
+        "Lorem ipsum dolor sit amet.",
+        "Lorem ipsum\ndolor sit amet.",
+        "Lorem ipsum\n\ndolor sit amet.",
+      ].each do |text|
+        @cleaner.clean_value(text).should eq text
+      end
+    end
+
+    it "empties string full of spaces" do
+      [
+        "",
+        " ",
+        "\t",
+        "\n",
+        " \t\n \t\n \t\n \t\n",
+      ].each do |title|
+        @cleaner.clean_value(title).should eq ""
+      end
+    end
+
+    it "cleans leading and trailing spaces" do
+      @cleaner.clean_value(" Lorem ipsum\ndolor sit amet. ").should eq "Lorem ipsum\ndolor sit amet."
+    end
+    it "cleans leading and trailing tabs" do
+      @cleaner.clean_value("\tLorem ipsum\ndolor sit amet.\t").should eq "Lorem ipsum\ndolor sit amet."
+    end
+    it "cleans leading and trailing lines" do
+      @cleaner.clean_value("\nLorem ipsum\ndolor sit amet.\n").should eq "Lorem ipsum\ndolor sit amet."
+    end
+
+    it "cleans repeted spaces" do
+      @cleaner.clean_value("Lorem   ipsum   \n   dolor   sit   amet.").should eq "Lorem ipsum\ndolor sit amet."
+      @cleaner.clean_value("Lorem \t ipsum \t \n   dolor \t sit \t amet.").should eq "Lorem ipsum\ndolor sit amet."
+    end
+
+    it "keeps two max succeeding new line" do
+      @cleaner.clean_value("Lorem ipsum\n\n\ndolor sit amet.").should eq "Lorem ipsum\n\ndolor sit amet."
+      @cleaner.clean_value("Lorem ipsum\n\n\n\ndolor sit amet.").should eq "Lorem ipsum\n\ndolor sit amet."
+    end
+
+  end
+
+end

data/spec/lib/active_cleaner_spec.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require 'spec_helper'
+

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+require 'rubygems'
+require 'rspec'
+require 'active_cleaner'
+
+
+RSpec.configure do |config|
+
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: activecleaner
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors:
+- Maxime Garcia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  prerelease: false
+  type: :runtime
+  name: activemodel
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  prerelease: false
+  type: :runtime
+  name: activesupport
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+  name: rspec
+description: ! '    ActiveCleaner is a set of helpers that helps you in cleaning user-typed
+  content in your ActiveModel depending models (ActiveRecord, Mongoid...)
+
+'
+email:
+- maxime.garcia@free.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE
+- lib/active_cleaner.rb
+- lib/active_cleaner/markdown_cleaner.rb
+- lib/active_cleaner/version.rb
+- lib/active_cleaner/base_cleaner.rb
+- lib/active_cleaner/helper_methods.rb
+- lib/active_cleaner/string_cleaner.rb
+- lib/active_cleaner/text_cleaner.rb
+- lib/activecleaner.rb
+- spec/lib/active_cleaner/string_cleaner_spec.rb
+- spec/lib/active_cleaner/text_cleaner_spec.rb
+- spec/lib/active_cleaner/markdown_cleaner_spec.rb
+- spec/lib/active_cleaner_spec.rb
+- spec/spec_helper.rb
+- spec/cases/inherit_spec.rb
+- spec/cases/simple_spec.rb
+- spec/cases/nilify_spec.rb
+homepage: http://github.com/maximeg/activecleaner
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Clean the fields in your models
+test_files:
+- spec/lib/active_cleaner/string_cleaner_spec.rb
+- spec/lib/active_cleaner/text_cleaner_spec.rb
+- spec/lib/active_cleaner/markdown_cleaner_spec.rb
+- spec/lib/active_cleaner_spec.rb
+- spec/spec_helper.rb
+- spec/cases/inherit_spec.rb
+- spec/cases/simple_spec.rb
+- spec/cases/nilify_spec.rb