pug-ruby 1.0.2 → 2.0.0.rc1

data/Rakefile

@@ -1,12 +1,78 @@
-# encoding: utf-8
+# encoding: UTF-8
 # frozen_string_literal: true
 
-require 'rake/testtask'
-require 'bundler/gem_tasks'
+require "rake/testtask"
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-end
+ENV["TESTOPTS"] = "--verbose"
+Rake::TestTask.new { |t| t.libs << "test" }
+
+namespace "javascripts" do
+  task "build" do
+    require "json"
+    require "open3"
+
+    def run(*args)
+      puts(*args)
+      stdout, stderr, exit_status = Open3.capture3(*args)
+      raise stderr.strip.empty? ? stdout : stderr unless exit_status.success?
+      stdout
+    end
+
+    def load_all(url)
+      max = run("curl --head #{url}").match(/Link:[^\n\r]+/).to_s.scan(/page=(\d+)/).flatten.map(&:to_i).uniq.max || 1
+      (1..max).reduce([]) { |ary, p| ary + JSON.parse(run("curl #{url}?page=#{p}")) }
+    end
+
+    def clone_repository(url, branch, dir)
+      run "[ -d #{dir} ] || git clone --single-branch --branch #{branch} --depth 1 --no-hardlinks #{url} #{dir}"
+    end
+
+    def install_node_modules(dir)
+      run "[ -d #{dir} -a ! -d #{dir}/node_modules ] && cd #{dir} && npm install --only=production --ignore-scripts || true"
+    end
 
-desc 'Run test suite'
-task default: :test
+    def build_template_compiler(engine, engine_dir, engine_version, output_file)
+      run "[ -f #{output_file} ] || (node support/browserify-#{engine}.js #{engine_dir} #{engine_version} #{output_file} &&
+                                     node support/minify-#{engine}.js #{output_file})"
+    end
+
+    def build_template_runtime(engine, engine_runtime_dir, engine_version, output_file)
+      run "[ -f #{output_file} ] || node support/browserify-#{engine}-runtime.js #{engine_runtime_dir} #{engine_version} #{output_file}"
+    end
+
+    def copy_license_file(engine, engine_dir, engine_version, output_file)
+      run "[ ! -f #{output_file} -a -f #{engine_dir}/LICENSE ] && cp #{engine_dir}/LICENSE #{output_file} || true"
+    end
+
+    tags  = load_all("https://api.github.com/repos/pugjs/pug/releases").map { |x| x.fetch("tag_name") }
+    tags += load_all("https://api.github.com/repos/pugjs/pug/tags").map { |x| x.fetch("name") }
+    tags.uniq.each do |tag|
+      if tag.match?(/\A1/)
+        version = tag
+        clone_repository        "https://github.com/pugjs/pug.git", tag, "tmp/jade-#{version}"
+        install_node_modules    "tmp/jade-#{version}"
+        build_template_compiler :jade, "tmp/jade-#{version}", version, "vendor/jade-#{version}.min.js"
+        build_template_runtime  :jade, "tmp/jade-#{version}", version, "vendor/jade-runtime-#{version}.js"
+        copy_license_file       :jade, "tmp/jade-#{version}", version, "vendor/jade-runtime-#{version}-license"
+
+      elsif tag.match?(/\A(?:pug@|2)/) && !tag.match?(/alpha/)
+        version = tag.gsub(/\Apug@/, "")
+        clone_repository        "https://github.com/pugjs/pug.git", tag, "tmp/pug-#{version}"
+        install_node_modules    "tmp/pug-#{version}"
+        install_node_modules    "tmp/pug-#{version}/packages/pug"
+        build_template_compiler :pug, "tmp/pug-#{version}", version, "vendor/pug-#{version}.min.js"
+        copy_license_file       :pug, "tmp/pug-#{version}", version, "vendor/pug-#{version}-license"
+        copy_license_file       :pug, "tmp/pug-#{version}/packages/pug", version, "vendor/pug-#{version}-license"
+      end
+    end
+
+    tags = load_all("https://api.github.com/repos/pugjs/pug-runtime/tags").map { |x| x.fetch("name") }
+    tags.uniq.each do |tag|
+      next unless tag.match?(/\A2/)
+      version = tag
+      clone_repository        "https://github.com/pugjs/pug-runtime.git", tag, "tmp/pug-runtime-#{version}"
+      build_template_runtime  :pug, "tmp/pug-runtime-#{version}", version, "vendor/pug-runtime-#{version}.js"
+      copy_license_file       :pug, "tmp/pug-runtime-#{version}", version, "vendor/pug-runtime-#{version}-license"
+    end
+  end
+end

data/lib/jade-pug/base.rb

@@ -0,0 +1,178 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "memoist"
+
+module JadePug
+  extend Memoist
+
+  #
+  # Compiles the template.
+  #
+  # @param source [String, #read]
+  # @param options [Hash]
+  # @return [String]
+  def compile(source, options = {})
+    compiler.compile(source, options)
+  end
+
+  #
+  # Returns engine compiler for given version.
+  # Compilers are cached.
+  #
+  # @param wanted_version [String, :system]
+  # @return [JadePug::Compiler]
+  def compiler(wanted_version = version)
+    (@compilers ||= {})["#{name}-#{wanted_version}"] ||= begin
+      case wanted_version
+        when :system then self::SystemCompiler.new
+        else              self::ShippedCompiler.new(wanted_version)
+      end
+    end
+  end
+
+  #
+  # Switches compiler version.
+  #
+  # - If you want to switch compiler to one of that shipped with gem simple pass version as a string.
+  # - If you want to switch compiler to system pass :system as a version.
+  #
+  # Pass block to temporarily switch the version. Without block the version is switched permanently.
+  #
+  # @param wanted_version [String, :system]
+  # @return [String, :system] Returns the version if no block has been given.
+  # @return Passes through the returned value from the block if it has been given.
+  def use(wanted_version)
+    previous_version = version
+    @version         = wanted_version
+    did_switch_version(previous_version, wanted_version)
+
+    return @version unless block_given?
+
+    begin
+      yield
+    ensure
+      @version = previous_version
+      did_switch_version(wanted_version, previous_version)
+    end
+  end
+
+  #
+  # Executed after compiler version switched.
+  # Outputs some useful information about version being used.
+  #
+  # @param version_from [String, :system]
+  # @param version_to [String, :system]
+  # @return [nil]
+  def did_switch_version(version_from, version_to)
+    if version_from != version_to
+      if Symbol === version_to
+        echo "Using #{version_to} #{name}."
+      else
+        echo "Using #{name} #{version_to}. NOTE: Advanced features like includes, extends and blocks will not work."
+      end
+    end
+    nil
+  end
+
+  #
+  # Returns the list of all available engine compiler versions shipped with gem.
+  #
+  # @return [Array<String>]
+  def versions
+    sort_versions(Dir[File.expand_path("../../../vendor/#{name.downcase}-*.js", __FILE__)].map do |path|
+      match = File.basename(path).match(/\A#{name.downcase}-(?!runtime-)(?<v>.+)\.min\.js\z/)
+      match[:v] if match
+    end.compact)
+  end
+  memoize :versions
+
+  #
+  # Returns the list of all available engine runtime versions shipped with gem.
+  #
+  # @return [Array<String>]
+  def runtime_versions
+    sort_versions(Dir[File.expand_path("../../../vendor/#{name.downcase}-*.js", __FILE__)].map do |path|
+      match = File.basename(path).match(/\A#{name.downcase}-runtime-(?<v>.+)\.js\z/)
+      match[:v] if match
+    end.compact)
+  end
+  memoize :runtime_versions
+
+  #
+  # Returns version for system-wide installed engine compiler.
+  #
+  # @return [String]
+  def system_version
+    compiler(:system).version
+  end
+
+  #
+  # Returns config object for engine.
+  # Executed only once per engine (return value is memoized).
+  #
+  # @return [JadePug::Config]
+  def config
+    self::Config.new
+  end
+  memoize :config
+
+  #
+  # Prints messages.
+  # By default messages are sent to the STDOUT by using {Kernel#puts}.
+  #
+  # @param *messages [Array<Object>]
+  # @return [nil]
+  def echo(*messages)
+    puts(*messages) unless silence?
+  end
+
+  #
+  # Turns the effect of {#echo} on or off.
+  #
+  # @param silence [true, false]
+  # @return [true, false]
+  def silence=(silence)
+    @silence = !!silence
+  end
+
+  #
+  # Returns true if {#echo} should print messages.
+  # Otherwise returns false.
+  #
+  # @return [true, false]
+  def silence?
+    !!@silence
+  end
+
+  #
+  # Returns version of currently used engine compiler.
+  # If no version has been set returns :system.
+  #
+  # Only for internal usage.
+  #
+  # To get the actual version of engine compiler refer to {Compiler#version}.
+  #
+  #   Jade.compiler.version => "1.11.0"
+  #
+  # @return [String, :system]
+  def version
+    if instance_variable_defined?(:@version)
+      @version
+    else
+      :system
+    end
+  end
+  private :version
+
+  #
+  # Sorts versions in ascending order.
+  # @see {https://stackoverflow.com/a/33290373/2369428}
+  #
+  # @param versions [Array<String>]
+  # @return [Array<String>]
+  def sort_versions(versions)
+    versions.sort_by { |v| Gem::Version.new(v) }
+  end
+  private :sort_versions
+end

data/lib/jade-pug/compiler.rb

@@ -0,0 +1,166 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "memoist"
+require "method-not-implemented"
+require "json"
+
+module JadePug
+  #
+  # Abstraction layer for engine compiler.
+  #
+  class Compiler
+    extend Memoist
+
+    #
+    # Returns the engine module.
+    #
+    # Used in such cases:
+    # - used to compute the name for engine
+    # - used to refer to the error classes
+    #
+    # @return [Jade, Pug]
+    attr_reader :engine
+
+    #
+    # Returns the version of engine compiler.
+    #
+    # @return [String]
+    attr_reader :version
+
+    #
+    # @param engine [Jade, Pug]
+    # @param version [String]
+    def initialize(engine, version)
+      @engine  = engine
+      @version = version
+    end
+
+    #
+    # Compiles template.
+    #
+    # By default does nothing.
+    #
+    # @abstract Derived compilers must implement it.
+    # @param source [String, #read]
+    #   The template source code or any object which responds to #read and returns string.
+    # @param options [Hash]
+    # @return [String]
+    def compile(source, options = {})
+      method_not_implemented
+    end
+
+    #
+    # Returns true if this compiler is a system compiler.
+    # Otherwise returns false.
+    #
+    # @return [true, false]
+    def system?
+      SystemCompiler === self
+    end
+
+    #
+    # Returns true if this compiler is a shipped compiler.
+    # Otherwise returns false.
+    #
+    # @return [true, false]
+    def shipped?
+      ShippedCompiler === self
+    end
+
+  protected
+
+    #
+    # Reads the template source code.
+    # Responds for pre-processing source code.
+    # Actually, it just checks if source code responds to #read and if so
+    #
+    # @param source [String, #read]
+    # @return [String]
+    def prepare_source(source)
+      source.respond_to?(:read) ? source.read : source
+    end
+
+    #
+    # Responds for preparing compilation options.
+    #
+    # The next steps are executed:
+    # - is merges options into the engine config
+    # - it camelizes and symbolizes every option key
+    # - it removes nil values from the options
+    #
+    # @param options [Hash]
+    # @return [Hash]
+    def prepare_options(options)
+      options = engine.config.to_hash.merge(options)
+      options.keys.each { |k, v| options[k.to_s.gsub(/_([a-z])/) { $1.upcase }.to_sym] = options[k] }
+      options.delete_if { |k, v| v.nil? }
+    end
+
+    #
+    # Generates the JavaScript code that is the bridge
+    # from the gem to the template engine compiler.
+    #
+    # The code responds for:
+    # - invoking compiler
+    # - rendering template function with given locals
+    # - returning the result
+    #
+    # @param :method [String]
+    #   The name of engine method to call.
+    # @param :arguments [Array<Object>]
+    #   The array of arguments to be passed to the method.
+    # @param :locals [Hash]
+    #   The hash of template local variables to be used to render template.
+    # @param :options [Hash]
+    #   The hash of options passed to {#compile}.
+    # @return [String]
+    def compilation_snippet(args)
+      method    = args.fetch(:method)
+      arguments = args.fetch(:arguments)
+      locals    = args.fetch(:locals)
+      options   = args.fetch(:options)
+
+      <<-JAVASCRIPT
+        (function() {
+          var engine   = #{npm_package_require_snippet};
+          var template = engine[#{ JSON.dump(method) }].apply(engine, #{ JSON.dump(arguments) });
+            
+          if (typeof template === 'function') {
+            template = template(#{ JSON.dump(locals) });
+          }
+        
+          if (typeof console === 'object' && console !== null && typeof console.log === 'function') {
+            console.log(template);
+          }
+
+          return template;
+        })()
+      JAVASCRIPT
+    end
+
+    #
+    # Returns the JavaScript code used to access engine NPM module.
+    #
+    # @abstract Derived compilers must implement it.
+    # @return [String]
+    def npm_package_require_snippet
+      method_not_implemented
+    end
+
+    #
+    # Responds for post-processing compilation result.
+    #
+    # By default removes leading and trailing whitespace
+    # by calling {String#strip} and returns the result.
+    # Derived compilers may override it for it's own special behavior.
+    #
+    # @param source [String] The source code of template.
+    # @param result [String] The compiled code of template.
+    # @param options [Hash] The compilation options.
+    # @return [String]
+    def process_result(source, result, options)
+      result.strip
+    end
+  end
+end

data/lib/jade-pug/config.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "regexp-match-polyfill"
+
+module JadePug
+  #
+  # Defines template engine compiler configuration.
+  #
+  class Config
+    #
+    # Allows to dynamically set config attributes.
+    #
+    def method_missing(name, *args, &block)
+      return super if block
+
+      case args.size
+        when 0
+
+          # config.client?
+          if name =~ /\A(\w+)\?\z/
+            !!(respond_to?($1) ? send($1) : instance_variable_get("@#{$1}"))
+
+          # config.client
+          elsif name =~ /\A(\w+)\z/
+            instance_variable_get("@#{$1}")
+
+          else
+            super
+          end
+
+        when 1
+          # config.client=
+          if name =~ /\A(\w+)=\z/
+            instance_variable_set("@#{$1}", args.first)
+          else
+            super
+          end
+        else
+          super
+      end
+    end
+
+    def respond_to_missing?(name, include_all)
+      name.match?(/\A\w+[=?]?\z/)
+    end
+
+    #
+    # Transforms config to the hash with all keys symbolized.
+    #
+    # @return [Hash]
+    def to_hash
+      instance_variables.each_with_object({}) do |var, h|
+        h[var[1..-1].to_sym] = instance_variable_get(var)
+      end
+    end
+
+    alias to_h to_hash
+  end
+end