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

opulent 1.3.3 → 1.4.0

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