renderable 1.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85e3db025cfa6d26e33ad8a230b69c9e06fd0690
+  data.tar.gz: 346cce3206106a17fe0ed335e6c0742e3eb5943c
+SHA512:
+  metadata.gz: 143acf4807cbf9dff01253bdc42066ed7a247d9081c48b6d7e551142f1dcfb31f293a88b07d4e0b2ccda393f575f86f2f8b6bc8adf5798fa9ff7b430748d3b53
+  data.tar.gz: 705a08ab8cb1b1e191e1aa62fcb1b677c99835306306e69e0ce227326de373356311429abf8018162c550250420ac55da1e22e8a5ce21aa693db1b0f7024b8d2

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Declare your gem's dependencies in acts_as_renderable.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013–2017 Jon Pearse
+
+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.textile

@@ -0,0 +1,111 @@
+h1. renderable
+
+@renderable@ is a wee gem I threw together fairly quickly to [a] scratch an itch, and [b] teach myself some new things.
+
+It provides a nice simple hook for automagically converting the content of fields containing "Textile":http://textile.sitemonks.com/ into HTML whenever your ActiveRecord model is saved.
+
+h2. Installation
+
+Is fairly simple.
+
+*1. add @renderable@ to your Gemfile*
+
+<pre>gem "renderable"</pre>
+
+_(you may also need to add RedCloth to your Gemfile… there’s a weird nuance here I’ve not quite understood)_
+
+*2. add appropriate fields to your database*
+
+Each renderable property of your model requires two database fields—one to store the original Textile content, and the other to store the rendered HTML. By default, this second field has the same name as the first, only with a ‘_rendered’ suffix.
+
+I have created a couple of migration tasks, though, so you can either do this:
+
+<pre><code lang="ruby">create_table :my_models do |t|
+    t.string :foo
+    t.renderable :bar
+    t.integer :baz, null: false
+end</code></pre>
+
+Or this:
+
+<pre><code lang="ruby">add_renderable :my_models, :my_field</code></pre>
+
+In both cases, a @:string@ type is created by default, but you can override this by specifying the required field type as an additional parameter (@t.renderable :foo, :text@ and @add_renderable :my_models, :my_field, :text@). Additional options (limit, nullability, etc) can be specified as normal.
+
+*3. hook into your model*
+
+Simply add a call to @acts_as_renderable@ in your model:
+
+<pre><code lang="ruby">class MyModel < ActiveRecord::Base
+    …
+    # automatically render ‘body’ and ‘description’ fields
+    acts_as_renderable fields: [ :body, :description ]
+    …
+end</code></pre>
+
+*4. use*
+
+Your model will now have additional properties containing rendered HTML versions of your textile-ed content. Thus, for the above example:
+
+<pre><code lang="haml">
+-# output the rendered HTML
+.content
+    ~ @my_model.body_rendered.html_safe
+</code></pre>
+
+h2. Why?
+
+Why not?
+
+…
+
+Seriously though, I love Textile and find myself using it all over the place. In a normal path for most Rails developers, I came across "RedCloth":http://redcloth.org and merrily set about writing code.
+
+However after a while, I found myself copy-pasting the same @:before_save@ hook into each of my models—grab a textile field, shove it through RedCloth, and dump the result into a ‘_rendered’ field. It wasn’t very DRY, but it worked.
+
+@renderable@ was the next logical step—I wanted to abstract everything into one place, and I wanted to see what all this ‘gem’ malarkey is about. The result is an insanely simple gem—I think there’s more hook code than business logic—but it works.
+
+
+h2. You’re doing it wrong!/What about %{gem}?
+
+Oh, more than likely. And I’d be _very_ surprised if there wasn’t already something out there that did this for me… but ultimately, I fancied a bit of a challenge and I learned a lot.
+
+h2. Version history
+
+h3. 1.0.7 (2017-05-28)
+
+* Releasing as a real gem
+
+h3. 1.0.6 (2016-10-09)
+
+* *[FIX]* made a tweak to the callback terminator that now means `before_*`` callbacks are correctly called _(seems only to affect Rails 5… no idea why)_
+
+h3. 1.0.5 (2015-09-06)
+
+* *[FIX]* fixing exception thrown when options are specified without a field type
+
+h3. 1.0.4 (2014-09-11)
+
+* adjusting rendering process to only run if a field has been updated
+
+h3. 1.0.3 (2014-08-02)
+
+* now compatible with Rails ~> 4.1.0
+
+h3. 1.0.2 (2014-02-05 - _I was busy…_)
+
+* adding @before_:field_render@ and @after_:field_render@ callbacks
+* making callbacks work in a more Rails-esque way (I’m still learnin’)
+
+h3. 1.0.1 (2014-02-05)
+
+* added @restrictions@ option to @acts_as_renderable@, allowing the ability to pass restrictions (eg @:filter_html@, @:lite_mode@) to RedCloth
+* added clean-up code to make output of @:lite_mode@ a little more sane
+
+h3. 1.0.0 (2013-08-17)
+
+Initial release.
+
+…
+
+Share and enjoy!

data/lib/renderable/callbacks.rb

@@ -0,0 +1,34 @@
+module Renderable
+  module Callbacks
+    def self.included(base)
+      base.extend(Defining)
+    end
+
+    module Defining
+      def define_renderable_callbacks(*callbacks)
+        define_callbacks *[callbacks, {:terminator => renderable_terminator }].flatten
+        callbacks.each do |callback|
+          eval <<-end_callbacks
+            def before_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :before, *args, &blk)
+            end
+            def after_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :after, *args, &blk)
+            end
+          end_callbacks
+        end
+      end
+
+      private
+        def renderable_terminator
+          lambda do |_, result|
+            if result.respond_to?(:call)
+              result.call == false
+            else
+              result == false
+            end
+          end
+        end
+    end
+  end
+end

data/lib/renderable/glue.rb

@@ -0,0 +1,13 @@
+require 'renderable/schema'
+
+module Renderable
+  module Glue
+    def self.included base      
+      base.extend ClassMethods
+      base.send :include, Callbacks
+      base.send :include, Schema if defined? ActiveRecord
+      
+      base.class_attribute :renderable_options
+    end
+  end
+end

data/lib/renderable/instance_methods.rb

@@ -0,0 +1,42 @@
+module Renderable
+  module InstanceMethods
+    
+    private
+      def renderable_render
+                
+        suff = renderable_options[:suffix]
+        renderable_options[:fields].each do |field|
+          
+          # skip if the field is unchanged
+          next unless self.changed.include? field.to_s
+
+          # actually render
+          run_callbacks(:render) do            
+            run_callbacks(:"#{field}_render") do           
+                            
+              # a. call out          
+              content = self[field.to_sym]          
+              content = content.nil? ? nil : RedCloth.new(content, renderable_options[:restrictions]).to_html
+          
+              # b. if we're using RedCloth's lite_mode, let's make the HTML sane again...
+              if renderable_options[:restrictions].include?(:lite_mode)
+            
+                # for reasons best known to RedCloth, lite_mode replaces all newlines with a BR tag. This is butt-ugly and
+                # we can do better.
+                #
+                # So, let's find all instances of multiple BRs and replace them with Ps.
+                content = '<p>'+content.gsub( /(<br\s?\/?>\n){2,}/, "</p>\n\n<p>" )+'</p>';
+            
+              end
+          
+              # c. copy it back
+              self["#{field}#{suff}".to_sym] = content
+            end
+          end  
+          
+        end
+      
+      end
+    
+  end
+end

data/lib/renderable/railtie.rb

@@ -0,0 +1,22 @@
+require 'renderable'
+require 'renderable/schema'
+
+module Renderable
+  require 'rails'
+  
+  class Railtie < Rails::Railtie
+    initializer 'renderable.insert_into_active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        Renderable::Railtie.insert
+      end
+    end
+  end
+  
+  class Railtie
+    def self.insert
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.send :include, Renderable::Glue
+      end
+    end
+  end
+end

data/lib/renderable/schema.rb

@@ -0,0 +1,104 @@
+module Renderable
+
+  module Schema
+    def self.included( base )
+
+      ActiveRecord::ConnectionAdapters::Table.send :include, TableDefinition
+      ActiveRecord::ConnectionAdapters::TableDefinition.send :include, TableDefinition
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.send :include, Statements
+
+    end
+  end
+
+  module Statements
+
+    # Adds a renderable column to the specified table.
+    #
+    # This is reasonably intelligent, and will create any required fields. Thus, if you are adding renderable
+    # functionality to an existing field, it will only add the ‘rendered’ version of the field.
+    #
+    # === Parameters
+    #
+    # [table_name]    the name of the table to which to add the field(s)
+    # [field_name]    the base name of the field that will be added
+    # [field_type]    the type of the field that will be added (defaults to @:string@)
+    # [options]       any additional options to be passed to add_column
+    #
+    def add_renderable( table_name, field_name, field_type = :string, options = {})
+      raise ArgumentError "Please specify name of table in add_renderable call in your migration" if table_name.blank?
+      raise ArgumentError "Please specify name of field in add_renderable call in your migration" if field_name.blank?
+
+      # do we have a suffix specified
+      suffix = options.delete(:suffix) { |k| '_rendered' }
+
+      # bugfix: if we don’t specify a field type but do specify options, it snarfs things up, so resolve that here
+      # @TODO: is there a better way of doing this in Ruby?
+      if field_type.is_a? Hash
+
+        # copy field_type hash to options
+        options = field_type
+
+        # default field_type again
+        field_type = :string
+
+      end
+
+      # add base column
+      add_column table_name, field_name, field_type, options unless column_exists?(table_name, field_name)
+
+      # rendered column
+      add_column table_name, "#{field_name}#{suffix}", field_type, options
+    end
+
+    # Removes a renderable field from the specified table.
+    #
+    # === Parameters
+    #
+    # [table_name]    the name of the table from which to remove the field
+    # [field_name]    the name of the field to remove
+    # [suffix]        the custom suffix used when creating the field, if used at all
+    #
+    def remove_renderable( table_name, field_name, suffix = '_rendered' )
+
+      remove_column table_name, field_name if column_exists?(table_name, field_name)
+      remove_column table_name, "#{field_name}#{suffix}" if column_exists?(table_name, field_name)
+
+    end
+
+  end
+
+  module TableDefinition
+
+    # Adds a renderable field to the current table. This is used inside a create_table block.
+    #
+    # === Parameters
+    #
+    # [field_name]    the name of the field to add
+    # [field_type]    the type of the field to add
+    # [options]       any additional options to be passed to add_column
+    #
+    def renderable( field_name, field_type = :string, options = {} )
+      raise ArgumentError "Please specify name of field in renderable call in your migration" if field_name.blank?
+
+      # get suffix
+      suffix = options.delete(:suffix) { |k| '_rendered' }
+
+      # bugfix: if we don’t specify a field type but do specify options, it snarfs things up, so resolve that here
+      # @TODO: is there a better way of doing this in Ruby?
+      if field_type.is_a? Hash
+
+        # copy field_type hash to options
+        options = field_type
+
+        # default field_type again
+        field_type = :string
+
+      end
+
+      # add columns
+      column field_name, field_type, options
+      column "#{field_name}#{suffix}", field_type, options
+
+    end
+  end
+end

data/lib/renderable/version.rb

@@ -0,0 +1,3 @@
+module Renderable
+  VERSION = "1.0.7"
+end

data/lib/renderable.rb

@@ -0,0 +1,58 @@
+require 'renderable/callbacks'
+require 'renderable/glue'
+require 'renderable/instance_methods'
+require 'renderable/version'
+
+require 'renderable/railtie' if defined?(Rails)
+
+module Renderable
+  
+  module ClassMethods
+    
+    # Add auto-rendering behaviour to an ActiveRecord object. This will automatically set up accessors on both original
+    # and rendered fields, using attr_accessor
+    #
+    # === Parameters
+    #
+    # [options] a Hash containing options for Renderable (see below)
+    #
+    # === Options
+    #
+    # [:fields]   an array of ActiveRecord fields you wish to make renderable
+    # [:suffix]   the suffix to use for ‘rendered’ versions of fields. (default: ‘_rendered’)
+    #
+    def acts_as_renderable( options = {} )
+      include InstanceMethods
+      
+      # sanity check
+      if options[:fields].blank?
+        return
+      end
+      
+      # default options
+      options[:suffix]        ||= '_rendered'
+      options[:restrictions]  ||= []
+      
+      # store the options
+      self.renderable_options = options
+      
+      # set accessible on fields
+      options[:fields].each do |field|
+        if ::Rails::VERSION::STRING < '4.0'
+          attr_accessible field, "#{field}#{options[:suffix]}"
+        end
+        
+        define_renderable_callbacks :"#{field}_render"
+      end
+      
+      # set up callbacks
+      define_renderable_callbacks :render
+      
+      # hook
+      before_save :renderable_render
+            
+    end
+    
+  end
+  
+end

data/renderable.gemspec

@@ -0,0 +1,20 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "renderable/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |gem|
+  gem.authors     = "Jon Pearse"
+  gem.email       = "jon@jonpearse.net"
+  gem.summary     = "Textile->HTML pre-rendering for ActiveRecord via RedCloth"
+  gem.description = "renderable provides a simple hook for ActiveRecord that converts Textile to HTML when the object is saved"
+  gem.homepage    = "https://github.com/jonpearse/renderable"
+  gem.license     = "MIT"
+
+  gem.files       = `git ls-files`.split($\)
+  gem.name        = "renderable"
+  gem.version     = Renderable::VERSION
+
+  gem.add_dependency('redcloth', '~> 0')
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: renderable
+version: !ruby/object:Gem::Version
+  version: 1.0.7
+platform: ruby
+authors:
+- Jon Pearse
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redcloth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: renderable provides a simple hook for ActiveRecord that converts Textile
+  to HTML when the object is saved
+email: jon@jonpearse.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- MIT-LICENSE.txt
+- README.textile
+- lib/renderable.rb
+- lib/renderable/callbacks.rb
+- lib/renderable/glue.rb
+- lib/renderable/instance_methods.rb
+- lib/renderable/railtie.rb
+- lib/renderable/schema.rb
+- lib/renderable/version.rb
+- renderable.gemspec
+homepage: https://github.com/jonpearse/renderable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Textile->HTML pre-rendering for ActiveRecord via RedCloth
+test_files: []