opulent 0.0.9 → 1.0.2

data/lib/opulent/compiler/root.rb

@@ -0,0 +1,19 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate code for all nodes by calling the method with their type name
+    #
+    # @param current [Array] Current node data with options
+    # @param indent [Fixnum] Indentation size for current node
+    # @param context [Context] Context holding environment variables
+    #
+    def root(current, indent, context)
+      if Keywords.include? current[@type]
+        send :"#{current[@type]}_node", current, indent, context
+      else
+        send current[@type], current, indent, context
+      end
+    end
+  end
+end

data/lib/opulent/compiler/text.rb

@@ -0,0 +1,60 @@
+# @Opulent
+module Opulent
+  # @Compiler
+  class Compiler
+    # Generate the code for a standard text node
+    #
+    # @param node [Array] Node code generation data
+    # @param indent [Fixnum] Size of the indentation to be added
+    # @param context [Context] Processing environment data
+    #
+    def plain(node, indent, context)
+      indentation = " " * indent
+
+      inline = @inline_node.include? @node_stack.last
+
+      # Evaluate text node if it's marked as such and print nodes in the
+      # current context
+      if node[@value] == :text
+        if node[@options][:evaluate]
+          value = context.evaluate "\"#{node[@options][:value]}\""
+        else
+          value = node[@options][:value]
+        end
+      else
+        value = if node[@options][:value] == 'yield'
+          context.evaluate_yield
+        else
+          context.evaluate(node[@options][:value])
+        end
+      end
+
+      # Indent all the lines with the given indentation
+      value = indent_lines value, indentation
+
+      # If the last node was an inline node, we remove the trailing newline
+      # character and we left strip the value
+      #pp @node_stack
+      if @node_stack.last == :text
+        remove_trailing_newline
+        value = " " + value.lstrip
+      elsif inline
+        remove_trailing_newline
+        value.lstrip!
+      end
+      value.rstrip!
+
+      # Escape the value unless explicitly set to false
+      value = node[@options][:escaped] ? escape(value) : value
+
+      # Create the text tag to be added
+      text_tag = "#{value}"
+      text_tag += "\n"
+
+      # Set the current child node as last processed node
+      @node_stack << :text
+
+      @code += text_tag
+    end
+  end
+end

data/lib/opulent/context.rb

@@ -0,0 +1,88 @@
+# @Opulent
+module Opulent
+  # @Context
+  #
+  # The context class is used to differentiate local, instance and class variables
+  # and to define the current working environment. Each class, method and instance
+  # has its own context
+  #
+  class Context
+    attr_accessor :binding, :name, :parent
+
+    # Create a context from the environment binding, extended with the locals
+    # given as arguments
+    #
+    # @param locals [Hash] Binding extension
+    # @param bind [Binding] Call environment binding
+    #
+    def initialize(locals = {}, &block)
+      @block = block || Proc.new
+      @binding = if @block
+        @block.binding.clone
+      else
+        Binding.new
+      end
+
+      extend_locals locals
+    end
+
+    # Evaluate ruby code in current context
+    #
+    # @param code [String] Code to be evaluated
+    #
+    def evaluate(code)
+      begin
+        eval code, @binding
+      rescue NameError => variable
+        Compiler.error :binding, variable, code
+      end
+    end
+
+    # Call given input block and return the output
+    #
+    def evaluate_yield
+      @block.call
+    end
+
+    # Extend the call context with a Hash, String or other Object
+    #
+    # @param context [Object] Extension object
+    #
+    def extend_locals(locals)
+      # Create new local variables from the input hash
+      locals.each do |key, value|
+        begin
+          @binding.local_variable_set(key.to_sym, value)
+        rescue NameError => variable
+          Compiler.error :variable_name, variable, key
+        end
+      end
+    end
+
+    # Extend instance, class and global variables for use in definitions
+    #
+    # @param bind [Binding] Binding to extend current context binding
+    #
+    def extend_nonlocals(bind)
+      bind.eval('instance_variables').each do |var|
+        @binding.eval('self').instance_variable_set var, bind.eval(var.to_s)
+      end
+
+      bind.eval('self.class.class_variables').each do |var|
+        @binding.eval('self').class_variable_set var, bind.eval(var.to_s)
+      end
+
+      bind.eval('self.class.constants').each do |var|
+        @binding.eval('self').const_set var, bind.eval(var.to_s)
+      end
+    end
+  end
+
+
+  # @Binding
+  class Binding
+    def self.new
+      binding
+    end
+  end
+end

data/lib/opulent/engine.rb

@@ -0,0 +1,60 @@
+# @Opulent
+module Opulent
+  # Module method wrapper for creating a new engine instance
+  #
+  def Opulent.new(settings = nil)
+    return Engine.new settings
+  end
+
+  # @Engine
+  class Engine
+    attr_reader :nodes, :preamble, :buffer
+
+    def initialize(settings = nil)
+      # Update render settings
+      Settings.update_settings settings if settings
+    end
+
+    # Analyze the input code and check for matching tokens. In case no match was
+    # found, throw an exception. In special cases, modify the token hash.
+    #
+    # @param file [String] The file that needs to be analyzed
+    # @param locals [Hash] Render call local variables
+    # @param block [Proc] Processing environment data
+    #
+    def render_file(file, locals = {}, &block)
+      # Render the file
+      render File.read(file), locals, &block
+    end
+
+    # Analyze the input code and check for matching tokens. In case no match was
+    # found, throw an exception. In special cases, modify the token hash.
+    #
+    # @param file [String] The file that needs to be analyzed
+    # @param locals [Hash] Render call local variables
+    # @param block [Proc] Processing environment data
+    #
+    def render(code, locals = {}, &block)
+      # Get the nodes tree
+      @nodes = Parser.new.parse code
+
+      # @TODO
+      # Implement precompiled template handling
+      @preamble = @nodes.inspect.inspect
+
+      # Create a new context based on our rendering environment
+      @context = Context.new locals, &block
+
+      # Compile our syntax tree using input context
+      @output = Compiler.new.compile @nodes, @context
+
+      # puts "Nodes\n---\n"
+      # pp @nodes
+      #
+      # puts "\n\nCode\n---\n"
+      # puts @output
+
+      return @output
+    end
+  end
+end

data/lib/opulent/filters.rb

@@ -0,0 +1,222 @@
+# @Opulent
+module Opulent
+  # @Filters
+  module Filters
+    # @Singleton
+    class << self
+      attr_accessor :filters
+
+      # Add a new Opulent filter to the filters knowledgebase
+      #
+      # @param class [Class] Class to be used for filter instance
+      # @param name [Symbol] Identifier in the filters hash
+      # @param options [Hash] Filter engine instance options
+      #
+      def register(klass, name, options)
+        @filters ||= {}
+        @filters[name] = klass.new name, options
+      end
+
+      # Check if the chosen filter name is registed within our knowledgebase
+      #
+      def has_filter?(name)
+        @filters.has_key? name
+      end
+    end
+
+    # @Filter
+    class Filter
+      attr_accessor :name, :options, :loaded
+
+      # Set tag and attribute options for filter
+      #
+      def initialize(name, options)
+        @name = name
+        @options = options
+        @loaded = false
+      end
+
+      # Error output in case the filter does not exist
+      #
+      def load_filter
+        unless gem_name.nil? || @loaded
+          # Try to load the library associated to the chosen filter
+          begin
+            require gem_name
+            @loaded = true
+          rescue LoadError => error
+            # Error output with filter name and installation instructions
+            Compiler.error :filter_load, @name, install_error
+          end
+        end
+      end
+
+      # Error message to be shown in order to provide installation instructions
+      # for the developer
+      #
+      def install_error
+        "gem install #{gem_name}"
+      end
+
+      # Process input code using this filter and return the output to the
+      # evaluation method from the Filter Node
+      #
+      def render(code, options = {})
+        raise NoMethodError
+      end
+
+      # RubyGems name for explicit library require
+      #
+      def gem_name
+        raise NoMethodError
+        # "gem_name"
+      end
+
+      # After defining how to render the code,
+      #
+      # Filters.register self, :filter, tag: :tag, attributes: { type: 'text/css' }
+    end
+
+
+    # Add the  default registered rendering filters for Opulent
+
+    # @CoffeeScript
+    class CoffeeScript < Filter
+      def render(code, options = {})
+        ::CoffeeScript.compile code, options
+      end
+
+      def gem_name
+        "coffee-script"
+      end
+
+      Filters.register self, :coffeescript, tag: :script, attributes: { type: 'javascript' }
+    end
+
+    # @JavaScript
+    class JavaScript < Filter
+      def render(code, options = {})
+        code
+      end
+
+      def gem_name
+        nil
+      end
+
+      Filters.register self, :javascript, tag: :script, attributes: { type: 'javascript' }
+    end
+
+    # @Scss
+    class Scss < Filter
+      def render(code, options = {})
+        options[:style] ||= :expanded
+
+        ::Sass.compile code, options
+      end
+
+      def gem_name
+        "sass"
+      end
+
+      Filters.register self, :scss, tag: :style, attributes: { type: 'text/css' }
+    end
+
+    # @Sass
+    class Sass < Filter
+      def render(code, options = {})
+        options[:syntax] = :sass
+        options[:style] ||= :expanded
+
+        ::Sass.compile code, options
+      end
+
+      def gem_name
+        "sass"
+      end
+
+      Filters.register self, :sass, tag: :style, attributes: { type: 'text/css' }
+    end
+
+    # @Css
+    class Css < Filter
+      def render(code, options = {})
+        if options[:cdata]
+          "<![CDATA[\n" + code + "]]>"
+        else
+          code
+        end
+      end
+
+      def gem_name
+        nil
+      end
+
+      Filters.register self, :css, tag: :style, attributes: { type: 'text/css' }
+    end
+
+    # @CData
+    class CData < Filter
+      def render(code, options = {})
+        "<![CDATA[\n" + code + "]]>"
+      end
+
+      def gem_name
+        nil
+      end
+
+      Filters.register self, :cdata, tag: nil, attributes: {}
+    end
+
+    # @Escaped
+    class Escaped < Filter
+      def render(code, options = {})
+        Compiler.escape code
+      end
+
+      def gem_name
+        nil
+      end
+
+      Filters.register self, :escaped, tag: nil, attributes: {}
+    end
+
+    # @Markdown
+    class Markdown < Filter
+      def render(code, options = {})
+        ::Kramdown::Document.new(code, options).to_html
+      end
+
+      def gem_name
+        "kramdown"
+      end
+
+      Filters.register self, :markdown, tag: nil, attributes: {}
+    end
+
+    # @Maruku
+    class Maruku < Filter
+      def render(code, options = {})
+        ::Maruku.new(code, options).to_html
+      end
+
+      def gem_name
+        "maruku"
+      end
+
+      Filters.register self, :maruku, tag: nil, attributes: {}
+    end
+
+    # @RedCloth
+    class RedCloth < Filter
+      def render(code, options = {})
+        ::RedCloth.new(code, options).to_html
+      end
+
+      def gem_name
+        "RedCloth"
+      end
+
+      Filters.register self, :textile, tag: nil, attributes: {}
+    end
+  end
+end