asciidoctor-diagram 2.0.0 → 2.1.0

data/lib/asciidoctor-diagram/diagram_source.rb

@@ -1,3 +1,4 @@
+require 'asciidoctor/logging'
 require_relative 'util/which'
 
 module Asciidoctor
@@ -5,6 +6,12 @@ module Asciidoctor
     # This module describes the duck-typed interface that diagram sources must implement. Implementations
     # may include this module but it is not required.
     module DiagramSource
+      include Asciidoctor::Logging
+
+      def diagram_type
+        raise NotImplementedError.new
+      end
+
       def image_name
         raise NotImplementedError.new
       end
@@ -15,20 +22,24 @@ module Asciidoctor
         raise NotImplementedError.new
       end
 
+      def global_attr(name, default_value = nil)
+        attr(name) || attr(name, default_value, 'diagram')
+      end
+
       # Get the value for the specified attribute. First look in the attributes on
       # this document and return the value of the attribute if found. Otherwise, if
       # this document is a child of the Document document, look in the attributes of the
       # Document document and return the value of the attribute if found. Otherwise,
       # return the default value, which defaults to nil.
       #
-      # @param name [String, Symbol] the name of the attribute to lookup
+      # @param name [String, Symbol, Array] the name(s) of the attribute to lookup
       # @param default_value [Object] the value to return if the attribute is not found
       # @inherit [Boolean, String] indicates whether to check for the attribute on the AsciiDoctor::Document if not found on this document.
       #                            When a non-nil String is given the an attribute name "#{inherit}-#{name}" is looked for on the document.
       #
       # @return the value of the attribute or the default value if the attribute is not found in the attributes of this node or the document node
       # @abstract
-      def attr(name, default_value = nil, inherit = nil)
+      def attr(name, default_value = nil, inherit = diagram_type)
         raise NotImplementedError.new
       end
 
@@ -75,14 +86,42 @@ module Asciidoctor
         if config.key? cmd_var
           cmd_path = config[cmd_var]
         else
-          cmd_path = attr_names.map { |attr_name| attr(attr_name, nil, true) }.find { |attr| !attr.nil? }
-
-          unless cmd_path && File.executable?(cmd_path)
-            cmd_paths = cmd_names.map do |c|
-              ::Asciidoctor::Diagram::Which.which(c, :path => options[:path])
-            end
-
-            cmd_path = cmd_paths.reject { |c| c.nil? }.first
+          logger.debug "Finding '#{cmd}' in attributes"
+          cmd_path = attr_names.map { |attr_name|
+                                 attr = attr(attr_name, nil, true)
+                                 if logger.debug? && attr
+                                   logger.debug "Found value '#{attr}' in attribute '#{attr_name}'" if attr
+                                 end
+                                 attr
+                               }
+                               .reject { |attr| attr.nil? }
+                               .map { |attr|
+                                 expanded = File.expand_path(attr)
+                                 if logger.debug? && attr != expanded
+                                   logger.debug "Expanded '#{attr}' to '#{expanded}'"
+                                 end
+                                 expanded
+                               }
+                               .select { |path|
+                                 executable = File.executable?(path)
+                                 if logger.debug?
+                                   logger.debug "Is '#{path}' executable? #{executable}"
+                                 end
+                                 executable
+                               }
+                               .first
+
+          unless cmd_path
+            logger.debug "Finding '#{cmd}' in environment"
+            cmd_path = cmd_names.map { |c|
+                             path = ::Asciidoctor::Diagram::Which.which(c, :path => options[:path])
+                             if logger.debug? && path
+                               logger.debug "Found '#{path}' in environment"
+                             end
+                             path
+                           }
+                           .reject { |path| path.nil? }
+                           .first
           end
 
           config[cmd_var] = cmd_path
@@ -113,6 +152,10 @@ module Asciidoctor
         @attributes = attributes
       end
 
+      def diagram_type
+        @block_processor.name.downcase
+      end
+
       def resolve_path target, start = base_dir
         @parent_block.normalize_system_path(target, start)
       end
@@ -125,29 +168,33 @@ module Asciidoctor
         attr('target', 'diag-' + checksum)
       end
 
-      def attr(name, default_value = nil, inherit = nil)
+      def attr(name, default_value = nil, inherit = diagram_type)
         name = name.to_s if ::Symbol === name
+        name = [name] unless name.is_a?(Enumerable)
 
-        value = @attributes[name]
+        value = name.lazy.map { |n| @attributes[n] }.reject { |v| v.nil? }.first
 
         if value.nil? && inherit
-          case inherit
-          when String, Symbol
-            value = @parent_block.attr("#{inherit.to_s}-#{name}", default_value, true)
-          else
-            value = @parent_block.attr(name, default_value, inherit)
+          inherited_values = name.lazy.map do |n|
+            case inherit
+            when String, Symbol
+              @parent_block.attr("#{inherit.to_s}-#{n}", default_value, true)
+            else
+              @parent_block.attr(n, default_value, inherit)
+            end
           end
+          value = inherited_values.reject { |v| v.nil? }.first
         end
 
         value || default_value
       end
 
       def should_process?(image_file, image_metadata)
-        image_metadata['checksum'] != checksum
+        image_metadata[:checksum] != checksum
       end
 
       def create_image_metadata
-        {'checksum' => checksum}
+        {:checksum => checksum}
       end
 
       def checksum

data/lib/asciidoctor-diagram/ditaa/converter.rb

@@ -23,27 +23,40 @@ module Asciidoctor
           :transparent => lambda { |o, v| o  << '--transparent' if v == 'true'}
       }
 
-      JARS = ['ditaa-1.3.14.jar', 'ditaamini-0.12.jar'].map do |jar|
-        File.expand_path File.join('../..', jar), File.dirname(__FILE__)
-      end
-      Java.classpath.concat JARS
-
+      CLASSPATH_ENV = 'DIAGRAM_DITAA_CLASSPATH'
+      DITAA_JARS = if ENV.has_key?(CLASSPATH_ENV)
+                        ENV[CLASSPATH_ENV].split(File::PATH_SEPARATOR)
+                      else
+                        begin
+                          require 'asciidoctor-diagram/ditaa/classpath'
+                          ::Asciidoctor::Diagram::DitaaClasspath::JAR_FILES
+                        rescue LoadError
+                          raise "Could not load PlantUML. Eiter require 'asciidoctor-diagram-ditaamini' or specify the location of the PlantUML JAR(s) using the 'DIAGRAM_DITAA_CLASSPATH' environment variable."
+                        end
+                      end
+
+      Java.classpath.concat Dir[File.join(File.dirname(__FILE__), '*.jar')]
+      Java.classpath.concat DITAA_JARS
 
       def supported_formats
         [:png, :svg]
       end
 
-      def collect_options(source, name)
+      def collect_options(source)
         options = {}
         
         OPTIONS.keys.each do |option|
           attr_name = option.to_s.tr('_', '-')
-          options[option] = source.attr(attr_name, nil, name) || source.attr(attr_name, nil, 'ditaa-option')
+          options[option] = source.attr(attr_name) || source.attr(attr_name, nil, 'ditaa-option')
         end
         
         options
       end
 
+      def native_scaling?
+        true
+      end
+
       def convert(source, format, options)
         Java.load
 

data/lib/asciidoctor-diagram/dpic.rb

@@ -0,0 +1,7 @@
+require 'asciidoctor/extensions'
+require_relative 'dpic/extension'
+
+Asciidoctor::Extensions.register do
+  block Asciidoctor::Diagram::DpicBlockProcessor, :dpic
+  block_macro Asciidoctor::Diagram::DpicBlockMacroProcessor, :dpic
+end

data/lib/asciidoctor-diagram/dpic/converter.rb

@@ -0,0 +1,30 @@
+require_relative '../diagram_converter'
+require_relative '../util/cli_generator'
+require_relative '../util/platform'
+
+module Asciidoctor
+  module Diagram
+    # @private
+    class DpicConverter
+      include DiagramConverter
+      include CliGenerator
+
+
+      def supported_formats
+        [:svg]
+      end
+
+      def convert(source, format, options)
+        dpic_path = source.find_command('dpic')
+
+        code = source.to_s
+        code.prepend ".PS\n" unless code.start_with?(".PS\n")
+        code << "\n.PE" unless code.start_with?("\n.PE")
+
+        generate_file_stdout(dpic_path, format.to_s, code) do |tool_path, input_path|
+          [tool_path, "-v", "-z", input_path]
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor-diagram/dpic/extension.rb

@@ -0,0 +1,14 @@
+require_relative 'converter'
+require_relative '../diagram_processor'
+
+module Asciidoctor
+  module Diagram
+    class DpicBlockProcessor < DiagramBlockProcessor
+      use_converter DpicConverter
+    end
+
+    class DpicBlockMacroProcessor < DiagramBlockMacroProcessor
+      use_converter DpicConverter
+    end
+  end
+end

data/lib/asciidoctor-diagram/gnuplot/converter.rb

@@ -14,15 +14,15 @@ module Asciidoctor
         [:png, :svg, :gif, :txt, :literal]
       end
 
-      def collect_options(source, name)
+      def collect_options(source)
         {
-            :width => source.attr('width', nil, name),
-            :height => source.attr('height', nil, name),
-            :transparent => source.attr('transparent', nil, name),
-            :crop => source.attr('crop', nil, name),
-            :font => source.attr('font', nil, name),
-            :fontscale => source.attr('fontscale', nil, name),
-            :background => source.attr('background', nil, name),
+            :width => source.attr('width'),
+            :height => source.attr('height'),
+            :transparent => source.attr('transparent'),
+            :crop => source.attr('crop'),
+            :font => source.attr('font'),
+            :fontscale => source.attr('fontscale'),
+            :background => source.attr('background'),
         }
       end
 

data/lib/asciidoctor-diagram/graphviz/converter.rb

@@ -13,8 +13,8 @@ module Asciidoctor
         [:png, :pdf, :svg]
       end
 
-      def collect_options(source, name)
-        {:layout => source.attr('layout', nil, name)}
+      def collect_options(source)
+        {:layout => source.attr('layout')}
       end
 
       def convert(source, format, options)

data/lib/asciidoctor-diagram/http/converter.rb

@@ -0,0 +1,93 @@
+require_relative '../diagram_converter'
+require_relative '../util/cli_generator'
+require_relative '../util/platform'
+
+require 'base64'
+require 'net/http'
+require 'uri'
+require 'zlib'
+
+module Asciidoctor
+  module Diagram
+    # @private
+    class HttpConverter
+      include DiagramConverter
+
+      def initialize(base_uri, type, converter)
+        @base_uri = base_uri
+        @type = type
+        @converter = converter
+      end
+
+      def supported_formats
+        @converter.supported_formats
+      end
+
+      def convert(source, format, options)
+        code = source.code
+
+        uri = URI(@base_uri)
+
+        case @type
+        when :plantuml
+          deflate = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
+                                      -Zlib::MAX_WBITS,
+                                      Zlib::MAX_MEM_LEVEL,
+                                      Zlib::DEFAULT_STRATEGY)
+
+          compressed = deflate.deflate(code, Zlib::FINISH)
+          deflate.close
+
+          encoded = Base64.urlsafe_encode64(compressed)
+          data = '0A' + encoded
+
+          path = uri.path
+          path << '/' unless path.end_with? '/'
+          path << format.to_s
+          path << '/' << data
+          uri.path = path
+        when :kroki_io
+          compressed = Zlib.deflate(code, Zlib::BEST_COMPRESSION)
+          data = Base64.urlsafe_encode64(compressed)
+
+          path = uri.path
+          path << '/' unless path.end_with? '/'
+          path << source.diagram_type.to_s
+          path << '/' << format.to_s
+          path << '/' << data
+          uri.path = path
+        else
+          raise "Unsupported server type: " + @type
+        end
+
+        get_uri(uri)
+      end
+
+      private
+
+      def get_uri(uri, attempt = 1)
+        if attempt >= 10
+          raise "Too many redirects"
+        end
+
+        Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme.downcase == 'https') do |http|
+          response = http.request_get uri.path
+          case response
+            when Net::HTTPSuccess
+              response.body
+            when Net::HTTPRedirection then
+              location = response['Location']
+              new_uri = URI.parse(location)
+              if new_uri.relative?
+                get_uri(uri + location, attempt + 1)
+              else
+                get_uri(new_uri, attempt + 1)
+              end
+            else
+              response.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor-diagram/http/server.rb

@@ -67,15 +67,15 @@ module Asciidoctor
         end
       end
 
-      def render_diagram(type, accepts, code, attributes)
+      def render_diagram(type, accepts, source, attributes)
         converter = get_converter(type.downcase.to_sym)
         return [500, "Unsupported diagram type #{type}"] unless converter
 
         format = converter.supported_formats.find {|f| accepts.call(f)}
         return [500, "Could not determine supported output format"] unless format
 
-        source = ServerSource.new(code, attributes)
-        options = converter.collect_options(source, type.downcase)
+        source = ServerSource.new(type.downcase, source, attributes)
+        options = converter.collect_options(source)
         diagram = converter.convert(source, format, options)
 
         content_type to_mime_type(format)
@@ -86,12 +86,17 @@ module Asciidoctor
     class ServerSource
       include Asciidoctor::Diagram::DiagramSource
 
-      def initialize(source, attributes)
+      def initialize(name, source, attributes)
+        @name = name
         @source = source
         @attributes = attributes
       end
 
-      def attr(name, default_value = nil, inherit = nil)
+      def diagram_type
+        @name
+      end
+
+      def attr(name, default_value = nil, inherit = diagram_type)
         @attributes[name] || default_value
       end
 

data/lib/asciidoctor-diagram/lilypond/converter.rb

@@ -9,14 +9,24 @@ module Asciidoctor
       include DiagramConverter
       include CliGenerator
 
+      EXTRA_PATH = []
+
+      if ::Asciidoctor::Diagram::Platform.os == :macosx
+        lilypond_app = ::Asciidoctor::Diagram::Which.which('LilyPond.app', :path => ['/Applications'])
+        if lilypond_app
+          EXTRA_PATH << File.join(lilypond_app, 'Contents/Resources/bin')
+        end
+      end
+
+      EXTRA_PATH.freeze
 
       def supported_formats
         [:png, :pdf]
       end
 
-      def collect_options(source, name)
+      def collect_options(source)
         {
-            :resolution => source.attr('resolution', nil, name)
+            :resolution => source.attr('resolution')
         }
       end
 
@@ -34,7 +44,7 @@ module Asciidoctor
 
         resolution = options[:resolution]
 
-        generate_stdin(source.find_command('lilypond'), format.to_s, code) do |tool_path, output_path|
+        generate_stdin(source.find_command('lilypond', :path => EXTRA_PATH), format.to_s, code) do |tool_path, output_path|
           args = [tool_path, '-daux-files=#f', '-dbackend=eps', '-dno-gs-load-fonts', '-dinclude-eps-fonts', '-o', Platform.native_path(output_path), '-f', format.to_s]
 
           args << '-dsafe'