opulent 1.5.5 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 729baa77847a138e206ec31ed334ff7bde75c1c7
-  data.tar.gz: f46dc9a3d7b9b37759550a8f21e726d7fe4b848a
+  metadata.gz: a007e8b48526ae61f9367fd98af3037f2846386f
+  data.tar.gz: 8fc75200d7244046c2db7ab85e68b39a2d10f1f3
 SHA512:
-  metadata.gz: c009955beb94ed05034dfbd1800fff3ef36a854985d143fe82e538750e3ec844b545e0dacb21e5037a44ba87c08e428f8df124cad1e6a6d3f2239914a9140585
-  data.tar.gz: dd539864154b3822a478c833956a54a56456eabbd25838eedcb479fbddf6f4eb32acb388ea6c4ed2c776f93a7182cb705cc300ad3e0c97f240549e1e4121302d
+  metadata.gz: 123f89a2cc962b954a92097d21cd8f8e162810751887f68eb5d0d223bb35e1060fcc6bf852915d903d6aab8994648a668e83861a85a7d072aaa4a39f59e13a0b
+  data.tar.gz: 6be28781cabf242dd16ee1278e77564adf6770ab33c03f6e25a6a6adf02d51e48e50337f0b4b9316af0973159c5d59a06748d5cc49e5bb5945b3a66e0db63d99

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/lib/opulent.rb

@@ -1,11 +1,11 @@
 require 'tilt'
-require_relative 'opulent/compiler.rb'
-require_relative 'opulent/context.rb'
-require_relative 'opulent/engine.rb'
-require_relative 'opulent/filters.rb'
-require_relative 'opulent/logger.rb'
-require_relative 'opulent/parser.rb'
-require_relative 'opulent/settings.rb'
-require_relative 'opulent/template.rb'
-require_relative 'opulent/tokens.rb'
-require_relative 'opulent/utils.rb'
+require_relative './opulent/compiler'
+require_relative './opulent/context'
+require_relative './opulent/engine'
+require_relative './opulent/logger'
+require_relative './opulent/parser'
+require_relative './opulent/settings'
+require_relative './opulent/template'
+require_relative './opulent/tokens'
+require_relative './opulent/utils'
+require_relative './opulent/version'

data/lib/opulent/compiler.rb

@@ -26,7 +26,7 @@ module Opulent
     #
     # @param path [String] Current file path needed for include nodes
     #
-    def initialize
+    def initialize(settings = {})
       # Setup convention accessors
       @type = 0
       @value = 1
@@ -34,9 +34,12 @@ module Opulent
       @children = 3
       @indent = 4
 
+      # Inherit settings from Engine
+      @settings = settings
+
       # Get special node types from the settings
-      @multi_node = Settings::MultiNode
-      @inline_node = Settings::InlineNode
+      @multi_node = Settings::MULTI_NODE
+      @inline_node = Settings::INLINE_NODE
 
       # Initialize amble object
       @template = [[:preamble]]
@@ -63,19 +66,24 @@ module Opulent
     # Compile input nodes, replace them with their definitions and
     #
     # @param root_node [Array] Root node containing all document nodes
-    # @param context [Context] Context holding environment variables
     #
-    def compile(root_node, context = nil)
+    def compile(root_node, definitions = {})
       # Compiler generated code
       @code = ''
       @generator = ''
+      @definitions = definitions
 
       # Set initial parent, from which we start generating code
       @sibling_stack << root_node[@children].size
 
+      # Write all node definitions as method defs
+      @definitions.each do |_, node|
+        define node
+      end
+
       # Start building up the code from the root node
       root_node[@children].each do |child|
-        root child, 0, context
+        root child, 0
       end
 
       @template << [:postamble]
@@ -96,9 +104,7 @@ module Opulent
     #
     def indent_lines(text, indent)
       text ||= ''
-      text.lines.inject('') do |result, line|
-        result += indent + line
-      end
+      text.lines.map { |line| indent + line }.join
     end
 
     # Give an explicit error report where an unexpected sequence of tokens

data/lib/opulent/compiler/buffer.rb

@@ -1,5 +1,6 @@
 # @Opulent
 module Opulent
+  # @Compiler
   class Compiler
     # Output an object stream into the template
     #
@@ -37,7 +38,8 @@ module Opulent
       @template << [:eval, string]
     end
 
-    # Set a local variable through buffer eval an object stream into the template
+    # Set a local variable through buffer eval an object stream into
+    # the template
     #
     # @param name [String] Variable identifier to be set
     # @param name [String] Variable value to be set
@@ -54,7 +56,7 @@ module Opulent
     # @param n [Fixnum] Number of characters to be removed
     #
     def buffer_remove_last_character(type = :freeze, n = 1)
-      @template[-1][1] = @template[-1][1][0..-1-n] if @template[-1][0] == type
+      @template[-1][1] = @template[-1][1][0..-1 - n] if @template[-1][0] == type
     end
 
     # Turn call node attributes into a hash string
@@ -62,15 +64,17 @@ module Opulent
     # @param attributes [Array] Array of node attributes
     #
     def buffer_attributes_to_hash(attributes)
-      "{" + attributes.inject([]) do |extend_map, (key, attribute)|
-        extend_map << (":\"#{key}\" => " + if key == :class
-          '[' + attribute.map do |exp|
-            exp[@value]
-          end.join(", ") + ']'
-        else
-          attribute[@value]
-        end)
-      end.join(', ') + "}"
+      '{' + attributes.inject([]) do |extend_map, (key, attribute)|
+        extend_map << (
+        ":\"#{key}\" => " + if key == :class
+                              '[' + attribute.map do |exp|
+                                exp[@value]
+                              end.join(', ') + ']'
+                            else
+                              attribute[@value]
+                            end
+        )
+      end.join(', ') + '}'
     end
 
     # Go through the node attributes and apply extension where needed
@@ -81,30 +85,51 @@ module Opulent
     def buffer_attributes(attributes, extension)
       # Proc for setting class attribute extension, used as DRY closure
       #
-      buffer_class_attribute_type_check = Proc.new do |variable, escape = true|
+      buffer_class_attribute_type_check = proc do |variable, escape = true|
         class_variable = buffer_set_variable :local, variable
+
         buffer_eval "if #{class_variable}.is_a? Array"
-        escape ? buffer_escape("#{class_variable}.join ' '") : buffer("#{class_variable}.join ' '")
+        if escape
+          buffer_escape("#{class_variable}.join ' '")
+        else
+          buffer("#{class_variable}.join ' '")
+        end
+
         buffer_eval "elsif #{class_variable}.is_a? Hash"
-        escape ? buffer_escape("#{class_variable}.to_a.join ' '") : buffer("#{class_variable}.to_a.join ' '")
-        buffer_eval "elsif [TrueClass, NilClass, FalseClass].include? #{class_variable}.class"
-        buffer_eval "else"
-        escape ? buffer_escape("#{class_variable}") : buffer("#{class_variable}")
-        buffer_eval "end"
+        if escape
+          buffer_escape("#{class_variable}.to_a.join ' '")
+        else
+          buffer("#{class_variable}.to_a.join ' '")
+        end
+
+        buffer_eval 'elsif [TrueClass, NilClass, FalseClass].include? ' \
+                    "#{class_variable}.class"
+
+        buffer_eval 'else'
+        if escape
+          buffer_escape("#{class_variable}")
+        else
+          buffer("#{class_variable}")
+        end
+
+        buffer_eval 'end'
       end
 
       # Handle class attributes by checking if they're simple, noninterpolated
       # strings and extend them if needed
       #
-      buffer_class_attribute = Proc.new do |attribute|
-        if attribute[@value] =~ Tokens[:exp_string]
-          buffer_split_by_interpolation attribute[@value][1..-2]
+      buffer_class_attribute = proc do |attribute|
+        if attribute[@value] =~ Tokens[:exp_string_match]
+          buffer_split_by_interpolation attribute[@value][1..-2],
+                                        attribute[@options][:escaped]
         else
-          buffer_class_attribute_type_check[attribute[@value], attribute[@options][:escaped]]
+          buffer_class_attribute_type_check[
+            attribute[@value],
+            attribute[@options][:escaped]
+          ]
         end
       end
 
-
       # If we have class attributes, process each one and check if we have an
       # extension for them
       if attributes[:class]
@@ -113,7 +138,7 @@ module Opulent
         # Process every class attribute
         attributes[:class].each do |node_class|
           buffer_class_attribute[node_class]
-          buffer_freeze " "
+          buffer_freeze ' '
         end
 
         # Remove trailing whitespace from the buffer
@@ -121,41 +146,51 @@ module Opulent
 
         # Check for extension with :class key
         if extension
-          buffer_eval "if #{extension}.has_key? :class"
-          buffer_freeze " "
-          buffer_class_attribute_type_check["#{extension}.delete(:class)"]
-          buffer_eval "end"
+          buffer_eval "if #{extension[:name]}.has_key? :class"
+          buffer_freeze ' '
+          buffer_class_attribute_type_check[
+            "#{extension[:name]}.delete(:class)"
+          ]
+          buffer_eval 'end'
         end
 
         buffer_freeze '"'
       elsif extension
         # If we do not have class attributes but we do have an extension, try to
         # see if the extension contains a class attribute
-        buffer_eval "if #{extension}.has_key? :class"
+        buffer_eval "if #{extension[:name]}.has_key? :class"
         buffer_freeze " class=\""
-        buffer_class_attribute_type_check["#{extension}.delete(:class)"]
+        buffer_class_attribute_type_check["#{extension[:name]}.delete(:class)"]
         buffer_freeze '"'
-        buffer_eval "end"
+        buffer_eval 'end'
       end
 
       # Proc for setting class attribute extension, used as DRY closure
       #
-      buffer_data_attribute_type_check = Proc.new do |key, variable, escape = true, dynamic = false|
+      buffer_data_attribute_type_check = proc do |key, variable, escape = true, dynamic = false|
         # @Array
         buffer_eval "if #{variable}.is_a? Array"
         dynamic ? buffer("\" #{key}=\\\"\"") : buffer_freeze(" #{key}=\"")
-        escape ? buffer_escape("#{variable}.join '_'") : buffer("#{variable}.join '_'")
+
+        if escape
+          buffer_escape("#{variable}.join '_'")
+        else
+          buffer("#{variable}.join '_'")
+        end
+
         buffer_freeze '"'
 
         # @Hash
         buffer_eval "elsif #{variable}.is_a? Hash"
         buffer_eval "#{variable}.each do |#{OPULENT_KEY}, #{OPULENT_VALUE}|"
-        dynamic ? buffer("\" #{key}-\"") : buffer_freeze(" #{key}-") # key-hashkey="
+        # key-hashkey
+        dynamic ? buffer("\" #{key}-\"") : buffer_freeze(" #{key}-")
         buffer "\"\#{#{OPULENT_KEY}}\""
+        #="value"
         buffer_freeze "=\""
-        escape ? buffer_escape("_opulent_value") : buffer("_opulent_value") # value
+        escape ? buffer_escape('_opulent_value') : buffer('_opulent_value')
         buffer_freeze '"'
-        buffer_eval "end"
+        buffer_eval 'end'
 
         # @TrueClass
         buffer_eval "elsif #{variable}.is_a? TrueClass"
@@ -165,44 +200,53 @@ module Opulent
         buffer_eval "elsif [NilClass, FalseClass].include? #{variable}.class"
 
         # @Object
-        buffer_eval "else"
+        buffer_eval 'else'
         dynamic ? buffer("\" #{key}=\\\"\"") : buffer_freeze(" #{key}=\"")
         escape ? buffer_escape("#{variable}") : buffer("#{variable}")
         buffer_freeze '"'
 
         # End
-        buffer_eval "end"
+        buffer_eval 'end'
       end
 
       # Handle data (normal) attributes by checking if they're simple, noninterpolated
       # strings and extend them if needed
       #
-      buffer_data_attribute = Proc.new do |key, attribute|
+      buffer_data_attribute = proc do |key, attribute|
         # When we have an extension for our attributes, check current key.
         # If it exists, check it's type and generate everything dynamically
         if extension
-          buffer_eval "if #{extension}.has_key? :\"#{key}\""
-          variable = buffer_set_variable :local, "#{extension}.delete(:\"#{key}\")"
-          buffer_data_attribute_type_check[key, variable, attribute[@options][:escaped]]
-          buffer_eval "else"
+          buffer_eval "if #{extension[:name]}.has_key? :\"#{key}\""
+          variable = buffer_set_variable :local,
+                                         "#{extension[:name]}" \
+                                         ".delete(:\"#{key}\")"
+          buffer_data_attribute_type_check[
+            key,
+            variable,
+            attribute[@options][:escaped]
+          ]
+          buffer_eval 'else'
         end
 
         # Check if the set attribute is a simple string. If it is, freeze it or
         # escape it. Otherwise, evaluate and initialize the type check.
-        if attribute[@value] =~ Tokens[:exp_string]
+        if attribute[@value] =~ Tokens[:exp_string_match]
           buffer_freeze " #{key}=\""
-          buffer_split_by_interpolation attribute[@value][1..-2], attribute[@options][:escaped]
+          buffer_split_by_interpolation attribute[@value][1..-2],
+                                        attribute[@options][:escaped]
           buffer_freeze "\""
         else
           # Evaluate and type check
           variable = buffer_set_variable :local, attribute[@value]
-          buffer_data_attribute_type_check[key, variable, attribute[@options][:escaped]]
+          buffer_data_attribute_type_check[
+            key,
+            variable,
+            attribute[@options][:escaped]
+          ]
         end
 
         # Extension end
-        if extension
-          buffer_eval "end"
-        end
+        buffer_eval 'end' if extension
       end
 
       # Process the remaining, non-class related attributes
@@ -212,19 +256,26 @@ module Opulent
       end
 
       # Process remaining extension keys if there are any
-      if extension
-        buffer_eval "#{extension}.each do |ext#{OPULENT_KEY}, ext#{OPULENT_VALUE}|"
-        buffer_data_attribute_type_check["\#{ext#{OPULENT_KEY}}", "ext#{OPULENT_VALUE}", true, true]
-        buffer_eval "end"
-      end
+      return unless extension
+
+      buffer_eval "#{extension[:name]}.each do " \
+                  "|ext#{OPULENT_KEY}, ext#{OPULENT_VALUE}|"
+
+      buffer_data_attribute_type_check[
+        "\#{ext#{OPULENT_KEY}}",
+        "ext#{OPULENT_VALUE}",
+        extension[:escaped],
+        true
+      ]
+      buffer_eval 'end'
     end
 
     # Transform buffer array into a reusable template
     #
     def templatize
-      separator = DEBUG ? "\n" : "; " # Readablity during development
-      @template.inject("") do |buffer, input|
-        buffer += case input[0]
+      separator = DEBUG ? "\n" : '; ' # Readablity during development
+      @template.map do |input|
+        case input[0]
         when :preamble
           "#{BUFFER} = []#{separator}"
         when :buffer
@@ -238,7 +289,7 @@ module Opulent
         when :postamble
           "#{BUFFER}.join"
         end
-      end
+      end.join
     end
 
     # Split a string by its interpolation, then check if it really needs to be
@@ -248,11 +299,21 @@ module Opulent
     # @param escape [Boolean] Escape string
     #
     def buffer_split_by_interpolation(string, escape = true)
-      string.split(Utils::InterpolationPattern).each_with_index do |input, index|
-        if index % 2 == 0
-          escape ? (input =~ Utils::EscapeHTMLPattern ? buffer_escape(input.inspect) : buffer_freeze(input)) : buffer_freeze(input)
+      parts = string.split Utils::INTERPOLATION_PATTERN
+      parts.each do |input|
+        if input =~ Utils::INTERPOLATION_PATTERN
+          input = input[2..-2]
+          if escape
+            buffer_escape input
+          else
+            buffer input
+          end
         else
-          escape ? buffer_escape(input) : buffer(input)
+          if escape && input =~ Utils::ESCAPE_HTML_PATTERN
+            buffer_escape(input.inspect)
+          else
+            buffer_freeze(input)
+          end
         end
       end
     end

data/lib/opulent/compiler/comment.rb

@@ -6,13 +6,12 @@ module Opulent
     #
     # @param node [Array] Node code generation data
     # @param indent [Fixnum] Size of the indentation to be added
-    # @param context [Context] Processing environment data
     #
-    def comment(node, indent, context)
+    def comment(node, indent)
       buffer_freeze "\n" if node[@options][:newline]
-      buffer_freeze "<!-- "
+      buffer_freeze '<!-- '
       buffer_split_by_interpolation node[@value].strip, false
-      buffer_freeze " -->"
+      buffer_freeze ' -->'
     end
   end
 end