opulent 1.5.5 → 1.6.0

data/.libold/opulent/filter.rb

@@ -1,101 +0,0 @@
-# @Opulent
-module Opulent
-  # @Filter
-  module Filter
-    # @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 @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
-            Runtime.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,
-      #
-      # Engine.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
-
-      Engine.register self, :coffeescript, tag: :script, attributes: { type: 'javascript' }
-    end
-
-    # @Scss
-    class Scss < Filter
-      def render(code, options = {})
-        ::Sass.compile code, options
-      end
-
-      def gem_name
-        "sass"
-      end
-
-      Engine.register self, :scss, tag: :style, attributes: { type: 'text/css' }
-    end
-
-    # @Sass
-    class Sass < Filter
-      def render(code, options = {})
-        options[:syntax] = :sass
-        ::Sass.compile code, options
-      end
-
-      def gem_name
-        "sass"
-      end
-
-      Engine.register self, :sass, tag: :style, attributes: { type: 'text/css' }
-    end
-  end
-end

data/.libold/opulent/logger.rb

@@ -1,67 +0,0 @@
-# @Opulent
-module Opulent
-  # @Logger
-  module Logger
-    # @Singleton
-    class << self
-      # Color the input text with the chosen color
-      #
-      # @param text [String] the string that will be colored
-      # @param color_code [String] preset code for certain colors
-      #
-      def colorize(text, color_code)
-        require_windows_libs
-        "#{color_code}#{text}\e[0m"
-      end
-
-      # Colors available in the terminal
-      #
-      def black(text); colorize(text, "\e[30m"); end
-      def red(text); colorize(text, "\e[31m"); end
-      def green(text); colorize(text, "\e[32m"); end
-      def yellow(text); colorize(text, "\e[33m"); end
-      def blue(text); colorize(text, "\e[34m"); end
-      def magenta(text); colorize(text, "\e[35m"); end
-      def cyan(text); colorize(text, "\e[36m"); end
-      def white(text); colorize(text, "\e[37m"); end
-      def default(text); colorize(text, "\e[38m"); end
-
-      # Require windows libraries for ANSI Console output
-      #
-      def require_windows_libs
-        begin
-          require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
-        rescue LoadError
-          raise 'You must run "gem install win32console" to use Opulent\'s
-                error reporting on Windows.'
-        end
-      end
-
-      # Pretty print Nodes with their important details
-      #
-      def pretty_print(model, indent = 0)
-        model.each do |node|
-          case node
-          when Nodes::Node
-            puts " " * indent +
-            node.name.to_s +
-            "::" + node.class.to_s.split('::').last +
-            " #{node.attributes unless node.attributes.empty?}"
-            pretty_print node.children, indent + 2
-          when Nodes::Text, Nodes::Print
-            puts " " * indent +
-            "text" +
-            "::" + node.class.to_s.split('::').last +
-            " {:value => \"#{node.value}\"}"
-          when NilClass
-          else
-            puts " " * indent +
-            node.name.to_s +
-            "::" + node.class.to_s.split('::').last +
-            " {:value => \"#{node.value}\"}"
-          end
-        end
-      end
-    end
-  end
-end

data/.libold/opulent/nodes.rb

@@ -1,13 +0,0 @@
-# Include Opulent nodes which know how to evaluate themselves
-require_relative 'nodes/helper'
-require_relative 'nodes/root'
-require_relative 'nodes/node'
-require_relative 'nodes/define'
-require_relative 'nodes/eval'
-require_relative 'nodes/expression'
-require_relative 'nodes/text'
-require_relative 'nodes/filter'
-require_relative 'nodes/control'
-require_relative 'nodes/theme'
-require_relative 'nodes/block'
-require_relative 'nodes/comment'

data/.libold/opulent/nodes/block.rb

@@ -1,29 +0,0 @@
-# @Opulent
-module Opulent
-  # @Nodes
-  module Nodes
-    # @Yield
-    #
-    class Yield < Node
-      # Node evaluation method which goes through all the child nodes and evaluates
-      # them using their own eval method
-      #
-      def evaluate(context)
-        self
-      end
-    end
-
-    # @Block
-    #
-    class Block < Node
-      # Node evaluation method which goes through all the child nodes and evaluates
-      # them using their own eval method
-      #
-      def evaluate(context)
-        @children.map do |child|
-          child.evaluate context
-        end.flatten.compact
-      end
-    end
-  end
-end

data/.libold/opulent/nodes/comment.rb

@@ -1,35 +0,0 @@
-# @Opulent
-module Opulent
-  # @Nodes
-  module Nodes
-    # @Text
-    #
-    # The text class will output raw or escaped HTML text
-    #
-    class Comment
-      # Allow direct access to literal value and type
-      attr_accessor :value, :visible, :parent, :indent, :name
-
-      # Initialize literal instance variables
-      #
-      # @param value stores the literal's explicit value
-      #
-      def initialize(value = nil, parent = nil, indent = 0)
-        @value = value
-        @parent = parent
-        @indent = indent
-        @name = :comment
-      end
-
-      # Value evaluation method which returns the processed value of the
-      # literal
-      #
-      def evaluate(context)
-        comment = self.dup
-        comment.value = context.evaluate "\"#{@value}\""
-        
-        return comment
-      end
-    end
-  end
-end

data/.libold/opulent/nodes/control.rb

@@ -1,230 +0,0 @@
-# @Opulent
-module Opulent
-  # @Nodes
-  module Nodes
-    # @CnditionalControl
-    #
-    # Control structure for if-elsif-else and unless
-    #
-    class CnditionalControl
-      attr_accessor :name, :value, :parent, :indent, :children
-
-      # Ruby code evaluation node
-      #
-      # @param name [String] name of the html node
-      # @param value [String] condition to be met
-      # @param parent [Node] parent of the element
-      # @param indent [Fixnum] node indentation for restructuring
-      # @param children [Array] contents to be interpreted
-      #
-      def initialize(name = '', value = '', parent = nil, indent = 0, children = [[]])
-        @name = name
-        @value = [value]
-        @parent = parent
-        @indent = indent
-        @children = children
-      end
-
-      # Add a new node to the nodes array
-      #
-      def push(node)
-        @children[-1] << node
-        self
-      end
-
-      # Node evaluation method which goes through all the child nodes and evaluates
-      # them using their own eval method
-      #
-      def evaluate(context)
-        index = @value.index do |value|
-          value.empty? || context.evaluate(value)
-        end
-
-        if index
-          @children[index].map do |child|
-            child.evaluate context
-          end
-        end
-      end
-    end
-
-    # @IfControl
-    #
-    # Control structure for if-elsif-else directive
-    #
-    class CaseControl
-      attr_accessor :name, :case, :value, :parent, :indent, :children
-
-      # Ruby code evaluation node
-      #
-      # @param name [String] name of the html node
-      # @param value [String] condition to be met
-      # @param parent [Node] parent of the element
-      # @param indent [Fixnum] node indentation for restructuring
-      # @param children [Array] contents to be interpreted
-      #
-      def initialize(name = '', switch_case = '', parent = nil, indent = 0, children = [[]])
-        @name = name
-        @case = switch_case
-        @value = []
-        @parent = parent
-        @indent = indent
-        @children = children
-      end
-
-      # Add a new node to the nodes array
-      #
-      def push(node)
-        @children[-1] << node
-        self
-      end
-
-      # Node evaluation method which goes through all the child nodes and evaluates
-      # them using their own eval method
-      #
-      def evaluate(context)
-        switch_case = context.evaluate @case
-        index = @value.index do |value|
-          value.empty? || switch_case == context.evaluate(value)
-        end
-
-        if index
-          @children[index].map do |child|
-            child.evaluate context
-          end.flatten.compact
-        end
-      end
-    end
-
-    # @LoopControl
-    #
-    # Control structure for while and until directives
-    #
-    class LoopControl
-      attr_accessor :name, :value, :parent, :indent, :children
-
-      # Ruby code evaluation node
-      #
-      # @param name [String] name of the html node
-      # @param value [String] condition to be met
-      # @param parent [Node] parent of the element
-      # @param indent [Fixnum] node indentation for restructuring
-      # @param children [Array] contents to be interpreted
-      #
-      def initialize(name = '', value = '', parent = nil, indent = 0, children = [])
-        @name = name
-        @value = value
-        @parent = parent
-        @indent = indent
-        @children = children
-      end
-
-      # Add a new node to the nodes array
-      #
-      def push(node)
-        @children << node
-        self
-      end
-
-      # Node evaluation method which goes through all the child nodes and evaluates
-      # them using their own eval method
-      #
-      def evaluate(context)
-        result = []
-
-        evaluate_children = Proc.new do |context|
-          result << @children.map do |child|
-            child.evaluate context
-          end.flatten
-        end
-
-        case @name
-        when :while
-          while context.evaluate @value
-            evaluate_children[context]
-          end
-        when :until
-          until context.evaluate @value
-            evaluate_children[context]
-          end
-        end
-
-        return result.flatten.compact
-      end
-    end
-
-    # @EachControl
-    #
-    # Control structure for while and until directives
-    #
-    class EachControl < LoopControl
-      # Node evaluation method which goes through all the child nodes and evaluates
-      # them using their own eval method
-      #
-      def evaluate(context)
-        result = []
-
-        # Process named variables for each structure
-        variables = @value[0].clone
-
-        # The each structure accept missing arguments as well, therefore we need to
-        # substitute them with our defaults
-        #
-        # each in iterable
-        # each value in iterable
-        # each key, value in iterable
-
-        # Value argument name provided only
-        if variables.length == 1
-          variables.unshift Engine[:each][:default_key]
-
-        # Missing key and value arguments
-        elsif variables.empty?
-          variables[0] = Engine[:each][:default_key]
-          variables[1] = Engine[:each][:default_value]
-        end
-
-        # Evaluate in current context and add to results
-        evaluate_children = Proc.new do |key, value, context|
-          # Update the local variables in the each context with the values from the
-          # current loop iteration
-          locals = {
-            variables[0] => key,
-            variables[1] => value
-          }
-          context.extend_context locals
-
-          # Add the mapped child elements
-          result << @children.map do |child|
-            child.evaluate context
-          end.flatten
-        end
-
-        # Create a new context based on the parent context and progressively update
-        # variables in the new context
-        each_context = Context.new({}, context.binding.clone)
-
-        # Evaluate the iterable object
-        enumerable = each_context.evaluate(@value[1])
-
-        # Check if input can be iterated
-        Runtime.error :enumerable, @value[1] unless enumerable.respond_to? :each
-
-        # Selectively iterate through the input and add the result using the previously
-        # defined proc object
-        case enumerable
-        when Hash
-          enumerable.each do |key, value|
-            evaluate_children[key, value, context]
-          end
-        else
-          enumerable.each_with_index do |value, key|
-            evaluate_children[key, value, context]
-          end
-        end
-
-        return result.flatten.compact
-      end
-    end
-  end
-end