opulent 0.0.9 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e616139da8f4b17f4fc7f52bb66b3e18d4d42be
-  data.tar.gz: eb8dfdcaae0b2fb04c83430a742c7ae31ad34364
+  metadata.gz: 3d6fdf705335f29c2162e3b2868398f4015ba29c
+  data.tar.gz: be920ffc6c6349e76d76ef802425146e5ed734e8
 SHA512:
-  metadata.gz: aca80c297f91ccc02b465534f6da7c755749092a10c14ca9b733e64df2f1aa90c551aeaa0383fa49ffd15ea3ecf81e6035df4b48e4bc6163e80aa41a4e0af048
-  data.tar.gz: 7363ff73b1572727aa7aecaa42b86b04c6e101b82e399b763d25a3538a9c2aee1e1974254b34be5073cc08d1aa8e0dc0269746de8215af2d5a41670fb20751ea
+  metadata.gz: 5ff789a689f140eccd4f853322bef8bec37747e52187a62d8c87a59d799944732451d419cd534fd7fc06ab216a55ac48db0a027db98200b86ce912d85c89ad3f
+  data.tar.gz: bfcb9e0566c3081bb99f2fe9f30ec697b7f78d35af9924e0fe0fd2835e04176007a62e90a072da4dc0361b23c902213d679d33cc24d486f085155176db67c21a

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.libold/opulent.rb

@@ -0,0 +1,96 @@
+require 'htmlentities'
+require 'tilt'
+require_relative 'opulent/engine'
+require_relative 'opulent/logger'
+require_relative 'opulent/preprocessor'
+require_relative 'opulent/tokens'
+require_relative 'opulent/nodes'
+require_relative 'opulent/parser'
+require_relative 'opulent/context'
+require_relative 'opulent/runtime'
+require_relative 'opulent/template'
+require_relative 'opulent/filter'
+require 'pp'
+
+# @Opulent
+module Opulent
+  # Wrapper method for creating a new Opulent instance
+  #
+  def Opulent.new
+    return Opulent.new
+  end
+
+  # @Opulent
+  class Opulent
+    # 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)
+      # Temporarily set file render mode for using it in the Preprocessor
+      @mode = :file
+
+      # Render the file
+      render 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 code from the input file
+      @code = PreProcessor.process code, @mode, &block
+
+      # Reset rendering mode to code. The mode variable is used to specify
+      # whether we're using render file or render code. When using render code,
+      # the preprocessor can be used only when a block is also passed
+      @mode = :code
+
+      # Instantiate required language components
+      @syntax = Parser.parse @code
+
+      # Create a new context based on our rendering environment
+      #bind = block.binding if block
+      #@context = Context.new locals, bind
+
+      # Instantiate required language components
+      #@model = Runtime.remodel @syntax, @context
+
+      #puts "\n\nModel\n---"
+      #Logger.pretty_print @model
+    end
+
+    # Update the engine options with the required option changes
+    #
+    def update_options(opts)
+      Engine.update_options(opts)
+    end
+
+    private
+
+    # Give an explicit error report where an unexpected sequence of tokens
+    # appears and give indications on how to solve it
+    #
+    # @param context [Symbol] Context name in which the error happens
+    # @param data [Array] Additional error information
+    #
+    def error(context, *data)
+      message = case context
+      when :options_key
+        "The input \"#{data[0]}\" is not a valid option name."
+      end
+
+      # Reconstruct lines to display where errors occur
+      fail "\n\nOpulent " + Logger.red("[Engine Error]") + "\n---\n" +
+      "An error has been encountered when updating the engine options.\n" +
+      "#{message}"
+    end
+  end
+end

data/.libold/opulent/context.rb

@@ -0,0 +1,80 @@
+# @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 :locals, :binding, :parent, :name
+
+    # 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 = {}, bind = nil)
+      @binding = if bind
+        bind.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
+        Runtime.error :binding, variable, code
+      end
+    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
+          Runtime.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/.libold/opulent/engine.rb

@@ -0,0 +1,88 @@
+# @SugarCube
+module Opulent
+  # @Engine
+  module Engine
+    # Default (root) theme name which can be accesed using the root definitions
+    DEFAULT_THEME = :default
+
+    # Default yield target which is used for child block replacements
+    DEFAULT_YIELD = :children
+
+    # List of self enclosing node elements
+    SELF_ENCLOSING = %w(img link input meta br hr area base col command embed keygen param source track wbr)
+
+    # @Singleton
+    class << self
+      attr_accessor :filters, :options
+
+      # Opulent runtime options
+      @@defaults = {
+        pretty: true,
+        indent: 2,
+        dependency_manager: true,
+        shorthand: {
+          class: /\./,
+          id: /\#/,
+          name: /\&/
+        },
+        each: {
+          :default_key => :key,
+          :default_value => :value
+        }
+      }
+
+      # Set defaults as initial options
+      @@options = @@defaults.clone
+
+      # Get an option at runtime
+      #
+      # @param name [Symbol] Identifier for the option
+      #
+      def [](name)
+        @@options[name]
+      end
+
+      # Set a new option at runtime
+      #
+      # @param name [Symbol] Identifier for the option
+      # @param value Option value to be set
+      #
+      def []=(name, value)
+        @@options[name] = value
+      end
+
+      # 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 filter?(name)
+        @filters.has_key? name
+      end
+
+      # Update the engine options with the required option changes
+      #
+      # @param opts [Hash] Option extension
+      #
+      def update_options(opts)
+        @@options = @@defaults.clone
+
+        opts.each do |key, value|
+          if @@options[key]
+            @@options[key] = value
+          else
+            error :options_key, key
+          end
+        end
+      end
+    end
+  end
+end

data/.libold/opulent/filter.rb

@@ -0,0 +1,101 @@
+# @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

@@ -0,0 +1,67 @@
+# @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