shortcode 1.1.1 → 1.2.0

data/lib/shortcode.rb

@@ -9,32 +9,46 @@ begin
   require 'slim'
 rescue LoadError; end
 
-module Shortcode
+class Shortcode
+  # This is providedc for backwards compatibility
+  def self.process(string, additional_attributes=nil)
+    singleton.process(string, additional_attributes)
+  end
 
-  class << self
-    attr_writer :configuration
+  # This is provided for backwards compatibility
+  def self.singleton
+    @instance ||= new
   end
 
-  def self.process(string, additional_attributes=nil)
-    Shortcode::Processor.new.process string, additional_attributes
+  # This is providedc for backwards compatibility
+  def self.setup(&prc)
+    singleton.setup(&prc)
+  end
+
+  # This is providedc for backwards compatibility
+  def self.register_presenter(*presenters)
+    singleton.register_presenter(*presenters)
   end
 
-  def self.setup
+  def process(string, additional_attributes=nil)
+    Shortcode::Processor.new.process(string, configuration, additional_attributes)
+  end
+
+  def setup
     yield configuration
   end
 
-  def self.register_presenter(*presenters)
+  def register_presenter(*presenters)
     presenters.each do |presenter|
-      Shortcode::Presenter.register presenter
+      configuration.register_presenter(presenter)
     end
   end
 
   private
 
-    def self.configuration
-      @configuration ||= Configuration.new
-    end
-
+  def configuration
+    @configuration ||= Configuration.new
+  end
 end
 
 require 'shortcode/version'

data/lib/shortcode/configuration.rb

@@ -8,9 +8,15 @@ class Shortcode::Configuration
   # Allows templates to be set from strings rather than read from the filesystem
   attr_accessor :templates
 
+  # Allows setting whether templates on the configuration are checked first, or templates in the file system
+  attr_accessor :check_config_templates_first
+
   # Assigns helper modules to be included in templates
   attr_accessor :helpers
 
+  # Allows presenters to be set that can be used to process shortcode arguments before rendered
+  attr_accessor :presenters
+
   # Set the supported block_tags
   attr_reader :block_tags
   def block_tags=(block_tags)
@@ -30,13 +36,19 @@ class Shortcode::Configuration
   attr_accessor :use_attribute_quotes
 
   def initialize
-    @template_parser      = :erb
-    @template_path        = "app/views/shortcode_templates"
-    @templates            = nil
-    @helpers              = []
-    @block_tags           = []
-    @self_closing_tags    = []
-    @attribute_quote_type = '"'
-    @use_attribute_quotes = true
+    @template_parser              = :erb
+    @template_path                = "app/views/shortcode_templates"
+    @templates                    = {}
+    @check_config_templates_first = true
+    @helpers                      = []
+    @block_tags                   = []
+    @self_closing_tags            = []
+    @attribute_quote_type         = '"'
+    @use_attribute_quotes         = true
+    @presenters                   = {}
+  end
+
+  def register_presenter(presenter)
+    Shortcode::Presenter.register(self, presenter)
   end
 end

data/lib/shortcode/exceptions.rb

@@ -1,4 +1,4 @@
-module Shortcode
+class Shortcode
 
   # Raised when the template file can not be found
   class TemplateNotFound < StandardError; end

data/lib/shortcode/parser.rb

@@ -1,43 +1,73 @@
-class Shortcode::Parser < Parslet::Parser
+class Shortcode::Parser
+  def initialize(configuration)
+    @configuration = configuration
+    setup_rules
+  end
 
-  rule(:block_tag)        { match_any_of Shortcode.configuration.block_tags }
-  rule(:self_closing_tag) { match_any_of Shortcode.configuration.self_closing_tags }
+  def parse(string)
+    klass_instance.parse(string)
+  end
 
-  rule(:quotes) { str(Shortcode.configuration.attribute_quote_type) }
+  def open(*args)
+    klass_instance.open(*args)
+  end
 
-  rule(:space)        { str(' ').repeat(1) }
-  rule(:space?)       { space.maybe }
-  rule(:newline)      { (str("\r\n") | str("\n")) >> space? }
-  rule(:newline?)     { newline.maybe }
-  rule(:whitespace)   { (space | newline).repeat(1) }
+  private
 
-  rule(:key) { match('[a-zA-Z0-9\-_]').repeat(1) }
+  # This allows us to create a new class with the rules for the specific configuration
+  def klass
+    @klass ||= Class.new(Parslet::Parser)
+  end
 
-  rule(:value_with_quotes) { quotes >> (quotes.absent? >> any).repeat.as(:value) >> quotes }
-  rule(:value_without_quotes) { quotes.absent? >> ( (str(']') | whitespace).absent? >> any ).repeat.as(:value) }
-  rule(:value) { Shortcode.configuration.use_attribute_quotes ? value_with_quotes : (value_without_quotes | value_with_quotes) }
+  def klass_instance
+    @klass_instance ||= klass.new
+  end
 
-  rule(:option)   { key.as(:key) >> str('=') >> value }
-  rule(:options)  { (str(' ') >> option).repeat(1) }
-  rule(:options?) { options.repeat(0, 1) }
+  def setup_rules
+    define_match_any_of
 
-  rule(:open)       { str('[') >> block_tag.as(:open) >> options?.as(:options) >> str(']') >> newline? }
-  rule(:close)      { str('[/') >> block_tag.as(:close) >> str(']') >> newline? }
-  rule(:open_close) { str('[') >> self_closing_tag.as(:open_close) >> options?.as(:options) >> str(']') >> newline? }
+    shortcode_configuration = @configuration
+    klass.rule(:block_tag)        { match_any_of shortcode_configuration.block_tags }
+    klass.rule(:self_closing_tag) { match_any_of shortcode_configuration.self_closing_tags }
 
-  rule(:text)   { ((close | block | open_close).absent? >> any).repeat(1).as(:text) }
-  rule(:block)  { (open >> (block | text | open_close).repeat.as(:inner) >> close) }
+    klass.rule(:quotes) { str(shortcode_configuration.attribute_quote_type) }
 
-  rule(:body) { (block | text | open_close).repeat.as(:body) }
-  root(:body)
+    klass.rule(:space)        { str(' ').repeat(1) }
+    klass.rule(:space?)       { space.maybe }
+    klass.rule(:newline)      { (str("\r\n") | str("\n")) >> space? }
+    klass.rule(:newline?)     { newline.maybe }
+    klass.rule(:whitespace)   { (space | newline).repeat(1) }
 
-  private
+    klass.rule(:key) { match('[a-zA-Z0-9\-_]').repeat(1) }
+
+    klass.rule(:value_with_quotes) { quotes >> (quotes.absent? >> any).repeat.as(:value) >> quotes }
+    klass.rule(:value_without_quotes) { quotes.absent? >> ( (str(']') | whitespace).absent? >> any ).repeat.as(:value) }
+    klass.rule(:value) { shortcode_configuration.use_attribute_quotes ? value_with_quotes : (value_without_quotes | value_with_quotes) }
+
+    klass.rule(:option)   { key.as(:key) >> str('=') >> value }
+    klass.rule(:options)  { (str(' ') >> option).repeat(1) }
+    klass.rule(:options?) { options.repeat(0, 1) }
 
-    def match_any_of(tags)
-      return str('') if tags.length < 1
-      tags.map{ |tag| str(tag) }.inject do |tag_chain, tag|
-        tag_chain.send :|, tag
+    klass.rule(:open)       { str('[') >> block_tag.as(:open) >> options?.as(:options) >> str(']') >> newline? }
+    klass.rule(:close)      { str('[/') >> block_tag.as(:close) >> str(']') >> newline? }
+    klass.rule(:open_close) { str('[') >> self_closing_tag.as(:open_close) >> options?.as(:options) >> str(']') >> newline? }
+
+    klass.rule(:text)   { ((close | block | open_close).absent? >> any).repeat(1).as(:text) }
+    klass.rule(:block)  { (open >> (block | text | open_close).repeat.as(:inner) >> close) }
+
+    klass.rule(:body) { (block | text | open_close).repeat.as(:body) }
+    klass.root(:body)
+  end
+
+  def define_match_any_of
+    klass.send(:define_method, :match_any_of) do |tags|
+      if tags.length < 1
+        return str('')
+      else
+        tags.map{ |tag| str(tag) }.inject do |tag_chain, tag|
+          tag_chain.send :|, tag
+        end
       end
     end
-
+  end
 end

data/lib/shortcode/presenter.rb

@@ -1,27 +1,19 @@
 class Shortcode::Presenter
+  def self.register(configuration, presenter)
+    validate presenter
+    [*presenter.for].each { |k| configuration.presenters[k.to_sym] = presenter }
+  end
 
-  class << self
-    attr_writer :presenters
-
-    def presenters
-      @presenters ||= {}
-    end
-
-    def register(presenter)
-      validate presenter
-      [*presenter.for].each { |k| presenters[k.to_sym] = presenter }
-    end
-
-    def validate(presenter)
-      raise ArgumentError, "The presenter must define the class method #for" unless presenter.respond_to?(:for)
-      raise ArgumentError, "The presenter must define an initialize method" unless presenter.private_instance_methods(false).include?(:initialize)
-      %w(content attributes).each do |method|
-        raise ArgumentError, "The presenter must define the method ##{method}" unless presenter.method_defined?(method.to_sym)
-      end
+  def self.validate(presenter)
+    raise ArgumentError, "The presenter must define the class method #for" unless presenter.respond_to?(:for)
+    raise ArgumentError, "The presenter must define an initialize method" unless presenter.private_instance_methods(false).include?(:initialize)
+    %w(content attributes).each do |method|
+      raise ArgumentError, "The presenter must define the method ##{method}" unless presenter.method_defined?(method.to_sym)
     end
   end
 
-  def initialize(name, attributes, content, additional_attributes)
+  def initialize(name, configuration, attributes, content, additional_attributes)
+    @configuration = configuration
     @attributes = attributes
     @content = content
     @additional_attributes = additional_attributes
@@ -38,12 +30,13 @@ class Shortcode::Presenter
 
   private
 
-    def initialize_custom_presenter(name)
-      if Shortcode::Presenter.presenters.has_key? name.to_sym
-        presenter   = Shortcode::Presenter.presenters[name.to_sym].new(@attributes, @content, @additional_attributes)
-        @attributes = presenter.attributes
-        @content    = presenter.content
-      end
-    end
+  attr_reader :configuration
 
+  def initialize_custom_presenter(name)
+    if configuration.presenters.has_key? name.to_sym
+      presenter   = configuration.presenters[name.to_sym].new(@attributes, @content, @additional_attributes)
+      @attributes = presenter.attributes
+      @content    = presenter.content
+    end
+  end
 end

data/lib/shortcode/processor.rb

@@ -1,17 +1,16 @@
 class Shortcode::Processor
 
-  def process(string, additional_attributes=nil)
-    transformer.apply parser.parse(string), additional_attributes: additional_attributes
+  def process(string, configuration, additional_attributes=nil)
+    transformer(configuration).apply parser(configuration).parse(string), additional_attributes: additional_attributes
   end
 
   private
 
-    def parser
-      @parser ||= Shortcode::Parser.new
-    end
-
-    def transformer
-      @transformer ||= Shortcode::Transformer.new
-    end
+  def parser(configuration)
+    @parser ||= Shortcode::Parser.new(configuration)
+  end
 
+  def transformer(configuration)
+    @transformer ||= Shortcode::Transformer.new(configuration)
+  end
 end

data/lib/shortcode/tag.rb

@@ -1,16 +1,16 @@
 class Shortcode::Tag
 
-  def initialize(name, attributes=[], content='', additional_attributes=nil)
+  def initialize(name, configuration, attributes=[], content='', additional_attributes=nil)
     @name = name.downcase
-    @binding = Shortcode::TemplateBinding.new(@name, attributes, content, additional_attributes)
+    @configuration = configuration
+    @binding = Shortcode::TemplateBinding.new(@name, @configuration, attributes, content, additional_attributes)
   end
 
   def markup
-    return markup_from_config unless Shortcode.configuration.templates.nil?
-    template_files.each do |path|
-      return File.read(path) if File.file? path
-    end
-    raise Shortcode::TemplateNotFound, "Searched in:", template_files
+    template = first_priority_template
+    template = second_priority_template if template.nil?
+    return template unless template.nil?
+    raise Shortcode::TemplateNotFound, "No template found for #{@name} in configuration or files"
   end
 
   def render
@@ -19,34 +19,47 @@ class Shortcode::Tag
 
   private
 
-    def render_template
-      case Shortcode.configuration.template_parser
-      when :erb
-        ERB.new(markup).result(@binding.get_binding)
-      when :haml
-        Haml::Engine.new(markup, ugly: true).render(@binding)
-      when :slim
-        Slim::Template.new { markup }.render(@binding)
-      else
-        raise Shortcode::TemplateParserNotSupported, Shortcode.configuration.template_parser
-      end
-    end
+  attr_reader :configuration
 
-    def markup_from_config
-      if Shortcode.configuration.templates.has_key? @name.to_sym
-        Shortcode.configuration.templates[@name.to_sym]
-      else
-        raise Shortcode::TemplateNotFound, "Shortcode.configuration.templates does not contain the key #{@name.to_sym}"
-      end
+  def render_template
+    case configuration.template_parser
+    when :erb
+      ERB.new(markup).result(@binding.get_binding)
+    when :haml
+      Haml::Engine.new(markup).render(@binding)
+    when :slim
+      Slim::Template.new { markup }.render(@binding)
+    else
+      raise Shortcode::TemplateParserNotSupported, configuration.template_parser
     end
+  end
+
+  def first_priority_template
+    configuration.check_config_templates_first ? markup_from_config : markup_from_file
+  end
+
+  def second_priority_template
+    configuration.check_config_templates_first ? markup_from_file : markup_from_config
+  end
 
-    def template_files
-      template_paths.map do |filename|
-        File.join Shortcode.configuration.template_path, filename
-      end
+  def markup_from_file
+    template_files.each do |path|
+      return File.read(path) if File.file? path
     end
+    nil
+  end
+
+  def markup_from_config
+    configuration.templates[@name.to_sym]
+  end
 
-    def template_paths
-      [ "#{@name}.html.#{Shortcode.configuration.template_parser.to_s}", "#{@name}.#{Shortcode.configuration.template_parser.to_s}" ]
+  def template_files
+    template_paths.map do |filename|
+      File.join configuration.template_path, filename
     end
+  end
+
+  def template_paths
+    [ "#{@name}.html.#{configuration.template_parser.to_s}", "#{@name}.#{configuration.template_parser.to_s}" ]
+  end
 end

data/lib/shortcode/template_binding.rb

@@ -1,11 +1,12 @@
 class Shortcode::TemplateBinding
 
-  def initialize(name, attributes=[], content='', additional_attributes=nil)
+  def initialize(name, configuration, attributes=[], content='', additional_attributes=nil)
+    @configuration = configuration
     include_helper_modules
-    presenter   = Shortcode::Presenter.new name, set_attributes(attributes), content, additional_attributes
-    @name       = name
-    @attributes = presenter.attributes
-    @content    = presenter.content
+    presenter      = Shortcode::Presenter.new name, configuration, set_attributes(attributes), content, additional_attributes
+    @name          = name
+    @attributes    = presenter.attributes
+    @content       = presenter.content
   end
 
   # Expose private binding() method for use with erb templates
@@ -15,19 +16,19 @@ class Shortcode::TemplateBinding
 
   private
 
-    def set_attributes(attributes)
-      hash = {}
-      attributes.each { |o| hash[o[:key].to_sym] = o[:value] }
-      hash
-    end
+  attr_reader :configuration
 
-    def include_helper_modules
-      return unless Shortcode.configuration.helpers.any?
-      class << self
-        Shortcode.configuration.helpers.each do |helper|
-          include helper
-        end
-      end
-    end
+  def set_attributes(attributes)
+    hash = {}
+    attributes.each { |o| hash[o[:key].to_sym] = o[:value] }
+    hash
+  end
 
+  def include_helper_modules
+    return unless configuration.helpers.any?
+
+    configuration.helpers.each do |helper|
+      self.class.send(:include, helper)
+    end
+  end
 end

data/lib/shortcode/transformer.rb

@@ -1,17 +1,38 @@
-class Shortcode::Transformer < Parslet::Transform
+class Shortcode::Transformer
+  def initialize(configuration)
+    @configuration = configuration
+    setup_rules
+  end
 
-  rule(text: simple(:text)) { String(text) }
-  rule(
-    open:     simple(:name),
-    options:  subtree(:options),
-    inner:    sequence(:inner),
-    close:    simple(:name)
-  ) { Shortcode::Tag.new(name.to_s, options, inner.join, additional_attributes).render }
-  rule(
-    open_close: simple(:name),
-    options:    subtree(:options)
-  ) { Shortcode::Tag.new(name.to_s, options, '', additional_attributes).render }
+  def apply(str, options = {})
+    klass_instance.apply(str, options)
+  end
 
-  rule(body: sequence(:strings)) { strings.join }
+  private
 
+  def klass
+    @klass ||= Class.new(Parslet::Transform)
+  end
+
+  def klass_instance
+    @klass_instance ||= klass.new
+  end
+
+  def setup_rules
+    shortcode_configuration = @configuration
+
+    klass.rule(text: klass.send(:simple, :text)) { String(text) }
+    klass.rule(
+      open:     klass.send(:simple, :name),
+      options:  klass.send(:subtree, :options),
+      inner:    klass.send(:sequence, :inner),
+      close:    klass.send(:simple, :name)
+    ) { Shortcode::Tag.new(name.to_s, shortcode_configuration, options, inner.join, additional_attributes).render }
+    klass.rule(
+      open_close: klass.send(:simple, :name),
+      options:    klass.send(:subtree, :options)
+    ) { Shortcode::Tag.new(name.to_s, shortcode_configuration, options, '', additional_attributes).render }
+
+    klass.rule(body: klass.send(:sequence, :strings)) { strings.join }
+  end
 end