RubyGems - opulent - Versions diffs - 1.3.3 → 1.4.0 - Mend

opulent 1.3.3 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

checksums.yaml +4 -4
data/README.md +2 -9
data/docs/attributes.md +1 -1
data/docs/comments.md +22 -0
data/docs/doctype.md +42 -0
data/docs/expressions.md +38 -0
data/docs/nodes.md +33 -0
data/docs/reference.md +4 -2
data/docs/usage.md +28 -1
data/lib/opulent/compiler/define.rb +5 -1
data/lib/opulent/context.rb +1 -1
data/lib/opulent/parser/define.rb +6 -0
data/lib/opulent/parser/node.rb +25 -6
data/lib/opulent/settings.rb +3 -4
data/lib/opulent/version.rb +1 -1
metadata +6 -2

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1abeda932886282bd5f9fce009b1fa624a802b12
-  data.tar.gz: 5123994660042759c670b74489dbb9284238ced1
+  metadata.gz: 44c953a9be6c659e56a0c33bc41637d7e1e0730d
+  data.tar.gz: 260dd8c631ab34debe0748cc53a27024988246b6
 SHA512:
-  metadata.gz: a745a8f4df10a3b22adc5db60f89455a699a92b35d46b7f3da1ab25ae7d92476c9be8e53cf8df0e7fbe561296a8a7bab75b23eb02966442ccb4adb2086308e4b
-  data.tar.gz: 89e1701db7adf3533dbd0b799f1f7fa599ec8ec6d6b340895da44411c8d882338acac06fde9d66033e33c254016ff00303f1534b4240ebd83f4b2f6aa9743f13
+  metadata.gz: 59e7c5c79cca92558ca68f2ab5be229bdd2815e4cb5a488465d3e0d391e548626905e1398327ebdc52746fb70cf688705ef7d6eaf2b696b40f2e717b3f795140
+  data.tar.gz: 5d0a8ad12ca13ba645417a1f73b0bfbb46f96b57db9d509976c777a5761feae6dcbfec48fee944c79f8063813116ca5d9d5e7ce08d59a72f912ab29a54dc8ccd

data/README.md CHANGED

@@ -2,6 +2,8 @@
 Opulent is an __Intelligent Web Templating Engine__ created for extremely fast and efficient Web Development. Based on the idea of lightweight and reusable __Web Components__, Opulent greatly increases your development speed for any project.
+[Read the Documentation](docs/reference.md)
 ## Syntax
 Opulent has a beautiful, minimalistic syntax: no tags, indentation based, optional brackets, inline text, inline children and in page definitions.
@@ -75,15 +77,6 @@ require 'opulent'
 Opulent.new.render_file :index
 ```
-For layouts you can simply use the following code. By default, the layout is set to __layouts/application__.
-```ruby
-require 'opulent'
-opulent = Opulent.new layouts: true
-opulent.render_file :index, layout: :'path/layout'
-```
 <!--
 ## Development

data/docs/attributes.md CHANGED

@@ -131,7 +131,7 @@ div unescaped=~"<div></div>"
 Unescaped buffered code can be dangerous. You must be sure to sanitize any user inputs to avoid cross-site scripting.
 ### Extending Attributes
-Attributes can be extended using a '__+__' symbol, followed by an expression which returns a Hash.
+Attributes can be extended using a '__+__' symbol, followed by an expression which provides Hash.
 __Example__
 ```html

data/docs/comments.md ADDED

@@ -0,0 +1,22 @@
+# Opulent Comments
+Single line comments are marked up with a forward slash character `/`.
+```sass
+/ This is a comment
+```
+## Block Comments
+Block comments are marked up with two forward slash characters `//`.
+```sass
+// This is a block comment.
+   It is on multiple lines.
+```
+## Output Comments
+By default, comments are only for reference inside Opulent files. You can output them
+by adding an exclamation character `!`, to resemble HTML.
+```html
+/! This comment will be outputted
+```

data/docs/doctype.md ADDED

@@ -0,0 +1,42 @@
+# Opulent Expressions
+```html
+doctype html
+<!DOCTYPE html>
+```
+## Doctype Shortcuts
+```html
+doctype xml
+<?xml version="1.0" encoding="utf-8" ?>
+```
+```html
+doctype transitional
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+```
+```html
+doctype strict
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+```
+```html
+doctype frameset
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
+```
+```html
+doctype 1.1
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+```
+```html
+doctype basic
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">
+```
+```html
+doctype mobile
+<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">
+```
+## Custom Doctypes
+```html
+doctype html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN"
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN">
+```

data/docs/expressions.md ADDED

@@ -0,0 +1,38 @@
+# Opulent Expressions
+Opulent makes it possible to write inline Ruby code in your templates. There are a few types of code.
+##Unbuffered Code
+Unbuffered code starts with `-` (single line) or `+` (multi line) and does not provide an output directly.
+```sass
+- a = 1 + 2 + 3
++ if a == 6
+    a = 3
+  end
+```
+## Buffered Code
+Buffered code starts with `=` and it outputs the Ruby expression as plain text. For safety reasons, it will be escaped by default.
+```sass
+p = "this is " + "an <escaped> ruby expression"
+```
+```html
+<p>
+  this is an &lt;escaped&gt; ruby expression
+</p>
+```
+## Unuffered Code
+Whenever we want to unescape an output in Opulent, we use the tilde character `~` to do so.
+```sass
+p =~ "this is " + "an <escaped> ruby expression"
+```
+```html
+<p>this is an <escaped> ruby expression</p>
+```

data/docs/nodes.md ADDED

@@ -0,0 +1,33 @@
+# Opulent Nodes
+Opulent has several node features which can be used within your views.
+## Syntax
+By default, every identifier can be a node, except the few keywords that Opulent uses for itself (e.g. def, yield, if, else, etc.).
+```sass
+node-name
+```
+Will render as:
+```html
+<node-name></node-name>
+```
+The following will render the same output:
+```sass
+div class="myclass"
+div.myclass
+.myclass
+.("myclass")
+."myclass"
+```
+```html
+<div class="myclass"></div>
+```
+## Inline Child Nodes
+Nodes such as text can be written inline without any identifier. However, when we want to have child nodes written inline we use the `>` character.
+```sass
+ul
+  li > a href="http://google.com" Google
+```

data/docs/reference.md CHANGED

@@ -5,5 +5,7 @@ Opulent is an __Intelligent Web Templating Engine__ created for extremely fast a
 1. [Attributes](attributes.md)
 2. [Control Structures](control-structures.md)
-3. [Expressions](usage.md)
-4. [Comments](usage.md)
+3. [Expressions](expressions.md)
+4. [Comments](comments.md)
+5. [Doctype](doctype.md)
+5. [Nodes](nodes.md)

data/docs/usage.md CHANGED

@@ -1,3 +1,30 @@
 # Opulent Usage
-@TODO
+Opulent can be used to render a file by providing a symbol with the name of the file or to render code by providing a string input.
+```ruby
+require 'opulent'
+Opulent.new.render_file :index
+```
+Opulent comes with a built in layout system. So if you're not using any web development framework, you'll really appreciate that.
+For layouts you can simply use the following code. By default, the layout is set to __layouts/application__.
+```ruby
+require 'opulent'
+opulent = Opulent.new layouts: true
+opulent.render_file :index, layout: :'path/to/layout'
+```
+Here is a list of options you can use with opulent at the moment together with their default values.
+```ruby
+options = {
+  indent: 2,
+  layouts: false,
+  default_layout: :'views/layouts/application'
+}
+opulent = Opulent.new options
+```

data/lib/opulent/compiler/define.rb CHANGED

@@ -10,7 +10,11 @@ module Opulent
     #
     def def_node(node, indent, context)
       # Create a new definition context
-      definition_context = Context.new
+      #
+      # @update: Added &context.block to make sure yield can be called from
+      # within a definition (it might be a nice feature)
+      #
+      definition_context = Context.new &context.block
       definition_context.extend_nonlocals context.binding
       definition_context.name = node[@value]
       definition_context.parent = context

data/lib/opulent/context.rb CHANGED

@@ -16,7 +16,7 @@ module Opulent
     # @param block [Binding] Call environment block
     # @param content [Binding] Content yielding
     #
-    def initialize(locals = {}, block, &content)
+    def initialize(locals = {}, block = nil, &content)
       @content = content
       @block = block

data/lib/opulent/parser/define.rb CHANGED

@@ -20,7 +20,13 @@ module Opulent
         # Create node
         definition = [:def, name, {parameters: attributes}, [], indent]
+        # Set definition as root node and let the parser know that we're inside
+        # a definition. This is used because inside definitions we do not process
+        # nodes (we do not check if they are have a definition or not).
+        @inside_definition = true
         root(definition, indent)
+        @inside_definition = false
         # Add to parent
         @definitions[name] = definition

data/lib/opulent/parser/node.rb CHANGED

@@ -80,18 +80,37 @@ module Opulent
         # Create a clone of the definition model. Cloning the options is also
         # necessary because it's a shallow copy
-        if @definitions.keys.include? node_name
-          model = @definitions[node_name].clone
-          model[@options] = {}.merge model[@options]
-          model[@options][:call] = current_node
-          parent[@children] << model
+        if !@inside_definition && @definitions.keys.include?(node_name)
+          parent[@children] << process_definition(node_name, current_node)
         else
           parent[@children] << current_node
         end
       end
     end
+    # When entering a definition model, we replace all the node types with their
+    # know definitions at definition call time.
+    #
+    # @param node_name [Symbol] Node identifier
+    # @param call_context [Node] Initial node call with its attributes
+    #
+    def process_definition(node_name, call_context)
+      model = @definitions[node_name].clone
+      model[@options] = {}.merge model[@options]
+      model[@options][:call] = call_context
+      # Recursively map each child node with its definition
+      model[@children].map! do |child|
+        if @definitions.keys.include? child[@value]
+          process_definition child[@value], child
+        else
+          child
+        end
+      end
+      return model
+    end
     # Helper method to create an array of values when an attribute is set
     # multiple times. This happens unless the key is id, which is unique
     #

data/lib/opulent/settings.rb CHANGED

@@ -41,12 +41,11 @@ module Opulent
     class << self
       # Opulent runtime options
       Defaults = {
-        pretty: true,
+        #pretty: true, # At the moment, code cannot be uglified
+        #dependency_manager: true, # Soon to be implemented
         indent: 2,
-        dependency_manager: true,
-        invert_escaping: true,
         layouts: false,
-        default_layout: :'layouts/application'
+        default_layout: :'views/layouts/application'
       }
       # Set defaults as initial options

data/lib/opulent/version.rb CHANGED

@@ -1,4 +1,4 @@
 # @Opulent
 module Opulent
-  VERSION = "1.3.3"
+  VERSION = "1.4.0"
 end

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opulent
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.4.0
 platform: ruby
 authors:
 - Alex Grozav
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-09-01 00:00:00.000000000 Z
+date: 2015-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,7 +136,11 @@ files:
 - benchmark/cases/node/node.slim
 - bin/opulent
 - docs/attributes.md
+- docs/comments.md
 - docs/control-structures.md
+- docs/doctype.md
+- docs/expressions.md
+- docs/nodes.md
 - docs/reference.md
 - docs/usage.md
 - lib/opulent.rb