acts_as_sanitiled 1.0.0

data/CHANGELOG

@@ -0,0 +1,2 @@
+1.0.0 (10-14-09)
+Initial butchering of defunkt's work.

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2006,2009 Chris Wanstrath, Gabe da Silveira
+
+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.rdoc

@@ -0,0 +1,141 @@
+= Acts as Sanitiled
+
+This plugin, based on Chris Wanstrath's venerable acts_as_textiled, extends the automatic textiling functionality to sanitization as well using as its basis Ryan Grove's powerful yet simple Sanitize gem.
+
+The reasoning behind this approach is simple.  Filtering input before it is saved to the database (as xss_terminate and many other popular plugins do) often fails to preserve user intent.  On the other hand, filtering output at the template level is error prone, and you are begging to get pwned.  Short of some sort of taint mode (which Rails 3 will have!), I believe the method employed by acts_as_textiled is the next best thing: you get safe output by default, but input is never corrupted.
+
+== Requirements
+
+* Sanitize >1.1.0 (prior versions had a whitespace issue)
+* RedCloth (for Textile support)
+* ActiveRecord (tested on 2.3.4)
+
+== Changes from acts_as_textiled
+
+acts_as_sanitiled mostly maintains the API, but one noticeable difference is that it needs to expose the Sanitize config.  Therefore acts_as_textiled use of a hash to provide per-column RedCloth configuration had to be replaced with Sanitize config. RedCloth options can still be passed as an array that applies to all fields listed.
+
+The other big change is that acts_as_sanitiled uses Sanitize which outputs utf8 rather than HTML entities.  For my own purposes this is preferable anyway, but it might give someone a few headaches getting encoding issues.  My advice: take your lumps now and figure out your encoding pipelines.
+
+== Usage
+
+  class Story < ActiveRecord::Base
+    acts_as_sanitiled :body_text, :description
+  end
+
+  >> story = Story.find(3)
+  => #<Story:0x245fed8 ... >
+
+  >> story.description
+  => "<p>This is <strong>cool</strong>.</p>"
+
+  >> story.description(:source)
+  => "This is *cool*."
+
+  >> story.description(:plain)
+  => "This is cool."
+
+  >> story.description = "I _know_!"
+  => "I _know_!"
+
+  >> story.save
+  => true
+
+  >> story.description
+  => "<p>I <em>know</em>!</p>"
+
+  >> story.textiled = false
+  => false
+
+  >> story.description
+  => "I _know_!"
+
+  >> story.textiled = true
+  => true
+
+  >> story.description
+  => "<p>I <em>know</em>!</p>"
+
+== Different Modes
+
+Sanitize supports a detailed configuration hash describing what HTML is allowed (among
+other things). This can be passed at the end of the declaration.  See the Sanitize docs
+for more information.
+
+  class Story < ActiveRecord::Base
+    acts_as_sanitiled :body_text, :elements => ['em','strong','div'], :attributes => {'div' => ['class','id']}
+  end
+
+RedCloth supports different modes, such as :lite_mode.  To use a mode on
+a specific attribute simply pass one or more options in an array after the field names.  Like so:
+
+  class Story < ActiveRecord::Base
+    acts_as_sanitiled :body_text, :description, [ :lite_mode ]
+  end
+
+Of course you can combine them as well:
+
+  class Story < ActiveRecord::Base
+    acts_as_sanitiled :body_text, :description, [ :lite_mode ], :elements => ['a'], :add_attributes => {'a' => {'rel' => 'nofollow'}}
+  end
+
+Suppose you want to sanitize but not textilize:
+
+  class Story < ActiveRecord::Base
+    acts_as_sanitized :body_text, :elements => ['br', 'p']
+  end
+
+Or vice-versa:
+
+  class Story < ActiveRecord::Base
+    acts_as_textilized :body_text, [ :lite_mode ]
+  end
+
+Get it?  Now let's say you have an admin tool and you want the text to be displayed
+in the text boxes / fields as plaintext.  Do you have to change all your views?
+
+Hell no.
+
+== form_for
+
+Are you using form_for?  If you are, you don't have to change any code at all.
+
+  <% form_for :story, @story do |f| %>
+    Description: <br/> <%= f.text_field :description %>
+  <% end %>
+
+You'll see the Textile plaintext in the text field.  It Just Works.
+
+== form tags
+
+If you're being a bit unconvential, no worries.  You can still get at your
+raw Textile like so:
+
+  Description: <br/> <%= text_field_tag :description, @story.description(:source) %>
+
+And there's always object.textiled = false, as demo'd above.
+
+== Pre-fetching
+
+acts_as_sanitiled locally caches rendered HTML once the attribute in question has
+been requested.  Obviously this doesn't bode well for marshalling or caching.
+
+If you need to force your object to build and cache HTML for all textiled attributes,
+call the +textilize+ method on your object.
+
+If you're real crazy you can even do something like this:
+
+  class Story < ActiveRecord::Base
+    acts_as_sanitiled :body_text, :description
+
+    def after_find
+      textilize
+    end
+  end
+
+All your Textile will now be ready to go in spiffy HTML format.  But you probably
+won't need to do this.
+
+Enjoy.
+
+* By Chris Wanstrath [ chris[at]ozmm[dot]org ]
+* Butchered and Sanitized by Gabe da Silveira [ gabe[at]websaviour[dot]com ]

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "acts_as_sanitiled"
+    gem.summary = %Q{Automatically textiles and/or sanitizes ActiveRecord columns}
+    gem.description = %Q{A modernized version of Chris Wansthrath's venerable acts_as_textiled. It automatically textiles and then sanitizes columns to your specification.  Ryan Grove's excellent Sanitize gem with nokogiri provides the backend for speedy and robust filtering of your output in order to: restrict Textile to a subset of HTML, guarantee well-formedness, and of course prevent XSS.}
+    gem.email = "gabe@websaviour.com"
+    gem.homepage = "http://github.com/dasil003/acts_as_sanitiled"
+    gem.authors = ["Gabe da Silveira"]
+
+    gem.add_dependency('nokogiri', '~> 1.3.3')
+    gem.add_dependency('sanitize', '~> 1.1.0')
+    gem.add_dependency('RedCloth')
+
+    gem.add_development_dependency "bacon"
+    gem.add_development_dependency "activesupport"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |spec|
+    spec.libs << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "acts_as_sanitiled #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/acts_as_sanitiled.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+require 'sanitize'
+require 'RedCloth'
+
+module ActsAsSanitiled #:nodoc: all
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+    def acts_as_textiled(*attributes)
+      raise "only acts_as_sanitized or acts_as_sanitiled can take an options hash" if attributes.last.is_a?(Hash)
+
+      attributes << {:skip_sanitize => true}
+      acts_as_sanitiled(*attributes)
+    end
+
+    def acts_as_sanitized(*attributes)
+      options = attributes.last.is_a?(Hash) ? attributes.pop : {}
+      options[:skip_textile] = true
+      attributes << options
+      acts_as_sanitiled(*attributes)
+    end
+
+    def acts_as_sanitiled(*attributes)
+      @textiled_attributes ||= []
+
+      @textiled_unicode = String.new.respond_to? :chars
+
+      options = attributes.last.is_a?(Hash) ? attributes.pop : {}
+      skip_textile = options.delete(:skip_textile)
+      skip_sanitize = options.delete(:skip_sanitize)
+
+      raise 'Both textile and sanitize were skipped' if skip_textile && skip_sanitize
+
+      sanitize_options = options.empty? ? Sanitize::Config::RELAXED : options
+      red_cloth_options = attributes.last && attributes.last.is_a?(Array) ? attributes.pop : []
+
+      raise 'No attributes were specified to filter' if attributes.empty?
+
+      type_options = %w( plain source )
+
+      attributes.each do |attribute|
+        define_method(attribute) do |*type|
+          type = type.first
+
+          if type.nil? && self[attribute]
+            if textiled[attribute.to_s].nil?
+              string = self[attribute]
+              string = RedCloth.new(string, red_cloth_options).to_html unless skip_textile
+              string = Sanitize.clean(string, sanitize_options) unless skip_sanitize
+              textiled[attribute.to_s] = string
+            end
+            textiled[attribute.to_s]
+          elsif type.nil? && self[attribute].nil?
+            nil
+          elsif type_options.include?(type.to_s)
+            send("#{attribute}_#{type}")
+          else
+            raise "I don't understand the `#{type}' option.  Try #{type_options.join(' or ')}."
+          end
+        end
+
+        define_method("#{attribute}_plain",  proc { strip_html(__send__(attribute)) if __send__(attribute) } )
+        define_method("#{attribute}_source", proc { __send__("#{attribute}_before_type_cast") } )
+
+        @textiled_attributes << attribute
+      end
+
+      include ActsAsSanitiled::InstanceMethods
+    end
+
+    def textiled_attributes
+      Array(@textiled_attributes)
+    end
+  end
+
+  module InstanceMethods
+    def textiled
+      textiled? ? (@textiled ||= {}) : @attributes.dup
+    end
+
+    def textiled?
+      @is_textiled != false
+    end
+
+    def textiled=(bool)
+      @is_textiled = !!bool
+    end
+
+    def textilize
+      self.class.textiled_attributes.each { |attr| __send__(attr) }
+    end
+
+    def reload
+      textiled.clear
+      super
+    end
+
+    def write_attribute(attr_name, value)
+      textiled[attr_name.to_s] = nil
+      super
+    end
+
+  private
+    def strip_html(html)
+      html.gsub!(%r{</p>\n<p>}, "</p>\n\n<p>") # Workaround RedCloth 4.2.x issue
+      Nokogiri::HTML::DocumentFragment.parse(html).inner_text
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.send(:include, ActsAsSanitiled)

data/spec/sanitiled_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe 'New object with textiled description' do
+  before do
+    @story = Story.new
+  end
+
+  it "should have nil description" do
+    @story.description.should.be.nil
+  end
+
+  it "should have nil description source" do
+    @story.description_source.should.be.nil
+  end
+
+  it "should have nil description plain" do
+    @story.description_plain.should.be.nil
+  end
+end
+
+describe 'A standard textiled object' do
+  before do
+    @desc_textile = '_why announces __Sandbox__'
+    @body_textile = <<EOF
+First line
+Second line with *bold*
+
+Second paragraph with special char(TM), <a href="javascript:alert('shit')">XSS attribute</a>,
+script>script tag</script>, and <b>unclosed tag.
+EOF
+
+    @story = Story.new(
+      :title => 'The Thrilling Freaky-Freaky Sandbox Hack',
+      :description => @desc_textile,
+      :body => @body_textile)
+
+    @desc_html    = '_why announces <i>Sandbox</i>'
+    @desc_plain   = '_why announces Sandbox'
+
+    @body_html    = "<p>First line<br />\nSecond line with <strong>bold</strong></p>\n<p>Second paragraph with special char\342\204\242, <a>XSS attribute</a>,<br />\nscript&gt;script tag, and <b>unclosed tag.</b></p>"
+    @body_plain   = "First line\nSecond line with bold\n\nSecond paragraph with special char™, XSS attribute,\nscript>script tag, and unclosed tag."
+  end
+
+  it "should properly textilize and strip html" do
+    @story.description.should.equal @desc_html
+    @story.description(:source).should.equal @desc_textile
+    @story.description(:plain).should.equal @desc_plain
+
+    @story.body.should.equal @body_html
+    @story.body(:source).should.equal @body_textile
+    @story.body(:plain).should.equal @body_plain
+  end
+
+  it "should raise when given a non-sensical option" do
+    proc{ @story.description(:cassadaga) }.should.raise
+  end
+
+  it "should pick up changes to attributes" do
+    @story.description.should.equal @desc_html
+
+    @story.description = "**IRb** is simple"
+    @story.description.should.equal "<b>IRb</b> is simple"
+    @story.description(:plain).should.equal "IRb is simple"
+  end
+
+  it "should be able to toggle whether textile is active or not" do
+    @story.description.should.equal @desc_html
+    @story.textiled = false
+    @story.description.should.equal @desc_textile
+  end
+
+  it "should be able to do on-demand textile caching" do
+    @story.textiled.size.should.equal 0
+    @story.textilize
+    @story.textiled.size.should.equal 2
+    @story.description.should.equal @desc_html
+  end
+
+  it "should clear textiled hash on reload" do
+    @story.textilize
+    @story.textiled.size.should.equal 2
+    @story.reload
+    @story.textiled.size.should.equal 0
+  end
+end
+
+describe 'An object with one textiled and one sanitized field' do
+  before do
+    @author = Author.new(
+      :name => '<b>King *George*</p>',
+      :bio => '*Bold* but with <script>')
+  end
+
+  it "should sanitize but not textilize name" do
+    @author.name.should.equal '<b>King *George*</b>'
+  end
+
+  it "should textilize but not sanitize bio" do
+    @author.bio.should.equal '<p><strong>Bold</strong> but with <script></p>'
+  end
+end
+
+describe 'Defining fields on an ActiveRecord object' do
+  it "should not allow both skip_textile and skip_sanitize" do
+    proc do
+      class Foo < ActiveRecord::Base
+        acts_as_sanitiled :body, :skip_sanitize => true, :skip_textile => true
+      end
+    end.should.raise
+  end
+
+  it "should not allow options hash on acts_as_textiled" do
+    proc do
+      class Foo < ActiveRecord::Base
+        acts_as_textiled :body, :option => :is_verboten
+      end
+    end.should.raise
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'acts_as_sanitiled'
+require 'bacon'
+require 'active_support'
+
+class ActiveRecord
+  class Base
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes.dup.stringify_keys
+    end
+
+    def method_missing(name, *args)
+      if name.to_s[%r{=}]
+        @attributes[key = name.to_s.sub('=','')] = value = args.first
+        write_attribute key, value
+      else
+        self[name.to_s]
+      end
+    end
+
+    def [](value)
+      @attributes[value.to_s.sub('_before_type_cast', '')]
+    end
+  end
+end unless defined? ActiveRecord
+
+ActiveRecord::Base.send(:include, ActsAsSanitiled)
+
+class Story < ActiveRecord::Base
+  acts_as_sanitiled :body
+  acts_as_sanitiled :description, [:lite_mode]
+end
+
+class Author < ActiveRecord::Base
+  acts_as_sanitized :name, :elements => ['b','em']
+  acts_as_textiled :bio
+end
+
+Bacon.summary_on_exit

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_sanitiled
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Gabe da Silveira
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.3.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sanitize
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: RedCloth
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "A modernized version of Chris Wansthrath's venerable acts_as_textiled. It automatically textiles and then sanitizes columns to your specification.  Ryan Grove's excellent Sanitize gem with nokogiri provides the backend for speedy and robust filtering of your output in order to: restrict Textile to a subset of HTML, guarantee well-formedness, and of course prevent XSS."
+email: gabe@websaviour.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- CHANGELOG
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/acts_as_sanitiled.rb
+- rails/init.rb
+- spec/sanitiled_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/dasil003/acts_as_sanitiled
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Automatically textiles and/or sanitizes ActiveRecord columns
+test_files: 
+- spec/sanitiled_spec.rb
+- spec/spec_helper.rb