liquid-diagrams 0.3.0 → 0.4.0

data/lib/liquid_diagrams/renderers/smcat_renderer.rb

@@ -16,16 +16,6 @@ module LiquidDiagrams
           "#{input} --output-to #{output}"
         end.sub(XML_REGEX, '')
       end
-
-      def build_command
-        command = +'smcat'
-
-        @config.slice(*OPTIONS).each do |opt, value|
-          command << " --#{opt} #{value}"
-        end
-
-        command
-      end
     end
   end
 end

data/lib/liquid_diagrams/renderers/svgbob_renderer.rb

@@ -13,16 +13,6 @@ module LiquidDiagrams
       def render
         Rendering.render_with_stdin_stdout(build_command, @content)
       end
-
-      def build_command
-        command = +'svgbob'
-
-        @config.slice(*OPTIONS).each do |opt, value|
-          command << " --#{opt} #{value}"
-        end
-
-        command
-      end
     end
   end
 end

data/lib/liquid_diagrams/renderers/syntrax_renderer.rb

@@ -13,16 +13,6 @@ module LiquidDiagrams
           "--input #{input} --output #{output}"
         end
       end
-
-      def build_command
-        command = +'syntrax'
-
-        @config.slice(*OPTIONS).each do |opt, value|
-          command << " --#{opt} #{value}"
-        end
-
-        command
-      end
     end
   end
 end

data/lib/liquid_diagrams/renderers/vega_renderer.rb

@@ -2,32 +2,18 @@
 
 module LiquidDiagrams
   module Renderers
-    %i[Vega Vegalite].each do |diagram|
-      renderer = Class.new(BasicRenderer) do
-        const_set :OPTIONS, %w[
-          scale
-        ].freeze
+    class VegaRenderer < BasicRenderer
+      OPTIONS = %w[
+        scale
+      ].freeze
 
-        define_method :render do
-          if diagram.downcase == 'vegalite'
-            @content = Rendering.render_with_stdin_stdout('vl2vg', @content)
-          end
-
-          Rendering.render_with_stdin_stdout(build_command, @content)
-        end
-
-        def build_command
-          command = +'vg2svg'
-
-          @config.slice(*self.class.const_get(:OPTIONS)).each do |opt, value|
-            command << " --#{opt} #{value}"
-          end
-
-          command
-        end
+      def render
+        Rendering.render_with_stdin_stdout(build_command, @content)
       end
 
-      const_set("#{diagram}Renderer", renderer)
+      def executable
+        'vg2svg'
+      end
     end
   end
 end

data/lib/liquid_diagrams/renderers/vegalite_renderer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LiquidDiagrams
+  module Renderers
+    class VegaliteRenderer < BasicRenderer
+      OPTIONS = %w[
+        scale
+      ].freeze
+
+      def render
+        Rendering.render_with_stdin_stdout(build_command, @content)
+      end
+
+      def executable
+        'vl2svg'
+      end
+    end
+  end
+end

data/lib/liquid_diagrams/renderers/wavedrom_renderer.rb

@@ -9,7 +9,7 @@ module LiquidDiagrams
         end
       end
 
-      def build_command
+      def executable
         'wavedrom-cli'
       end
     end

data/lib/liquid_diagrams/rendering.rb

@@ -9,6 +9,9 @@ module LiquidDiagrams
     module_function
 
     def render_with_stdin_stdout(command, content)
+      options = yield command if block_given?
+      command = "#{command} #{options}".strip
+
       render_with_command(command, :stdout, stdin_data: content)
     end
 
@@ -18,11 +21,10 @@ module LiquidDiagrams
 
       File.write(input.path, content)
 
-      extra = yield input.path, output.path
-      command = "#{command} #{extra}"
+      options = yield input.path, output.path
+      command = "#{command} #{options}".strip
 
       render_with_command(command, output.path)
-    # TODO: recue Tempfile.new and File.write error
     ensure
       input.close!
       output.close!
@@ -36,9 +38,9 @@ module LiquidDiagrams
       end
 
       unless status.success?
-        raise Errors::RenderingFailedError, <<~MSG
-          #{command}: #{stderr.empty? ? stdout : stderr}
-        MSG
+        msg = "#{command}: #{stderr.empty? ? stdout : stderr}"
+
+        raise Errors::RenderingFailedError, msg
       end
 
       output == :stdout ? stdout : File.read(output)

data/lib/liquid_diagrams/utils.rb

@@ -6,38 +6,45 @@ module LiquidDiagrams
 
     # Join the args with prefix
     #
-    # @param args
+    # @param args [String, Array, Hash]
     # @param with [String]
     #
+    # @yield When `args` is a Hash, you must provide a block
+    # @yieldreturn [String] The result string to join
+    #
     # @return [String]
     #
     # @example join on string
-    #   join('path', with: ' -I')                     # => ' -Ipath'
+    #   join('path', with: ' -I')                     # => '-Ipath'
     #
     # @example join on array
-    #   join(['path1', 'path2'], with: ' -I')         # => ' -Ipath1 -Ipath2'
+    #   join(%w[path1 path2], with: ' -I')            # => '-Ipath1 -Ipath2'
     #
     # @example join on hash
     #   join({ color: 'red', size: '10' }, with: ' --') do |k, v|
     #     "#{k} #{v}"
-    #   end                                           # => ' --color red --size 10'
+    #   end                                           # => '--color red --size 10'
     def join(args, with:)
       args = Array(args)
       args = args.map { |arg| yield arg } if block_given?
 
-      "#{with}#{args.join(with)}"
+      "#{with}#{args.join(with)}".strip
     end
 
-    # Merge from the hash with only those keys exists
-    #
-    # @example
-    #   merge({ k1: 1, k2: 2}, { k1: 11, k3: 13})     # => { k1: 11, k2: 2 }
-    def merge(first, second)
-      first.merge(second.slice(*first.keys))
+    def build_options(config, keys, prefix: '--', sep: ' ')
+      config.slice(*keys).map do |opt, val|
+        "#{prefix}#{opt}#{sep}#{val}"
+      end.join(' ').strip
+    end
+
+    def build_flags(config, keys, prefix: '--')
+      config.slice(*keys).map do |flag, val|
+        "#{prefix}#{flag}" if val
+      end.join(' ').strip
     end
 
     def run_jar(jar)
-      +"java -Djava.awt.headless=true -jar #{jar}"
+      "java -Djava.awt.headless=true -jar #{jar}"
     end
 
     def vendor_path(file = '')
@@ -51,9 +58,9 @@ module LiquidDiagrams
       options = {}
 
       input.scan(INLINE_OPTIONS_REGEXP) do |key, value|
-        value.delete!('"') if value&.include?('"')
+        value.delete!('"') if value.include?('"')
 
-        options[key.to_sym] = value
+        options[key.to_s] = value
       end
 
       options

data/lib/liquid_diagrams/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LiquidDiagrams
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/spec/liquid_diagrams/basic_block_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 RSpec.describe LiquidDiagrams::BasicBlock do
   let(:block) do
     TestBlock.parse(
-      'test', '', Liquid::Tokenizer.new('{% endtest %}'),
+      'test', 'markup', Liquid::Tokenizer.new('{% endtest %}'),
       Liquid::ParseContext.new
     )
   end
@@ -22,83 +22,46 @@ RSpec.describe LiquidDiagrams::BasicBlock do
   end
 
   describe '#render' do
-    it 'call #render_with_rescue' do
-      allow(block).to receive(:render_with_rescue).and_return 'success'
+    it 'call #render_content to render' do
+      allow(block).to receive(:read_config)
+      allow(block).to receive(:render_content).and_return 'svg ok!'
 
-      expect(block.render(Liquid::Context.new)).to eq 'success'
+      expect(block.render(Liquid::Context.new)).to eq 'svg ok!'
+      expect(block).to have_received(:read_config)
     end
   end
 
-  describe '#render_with_rescue' do
-    it 'call #render_without_rescue' do
-      allow(block).to receive(:render_without_rescue).and_return 'success'
+  describe '#render_content' do
+    it 'call handle error if error rescued' do
+      error = LiquidDiagrams::Errors::BasicError.new
 
-      expect(block.render(Liquid::Context.new)).to eq 'success'
-    end
-
-    it 'rescue and handle the error' do
-      allow(block).to receive(:render_without_rescue).and_raise(
-        LiquidDiagrams::Errors::BasicError.new
-      )
-      allow(block).to receive(:handle_error).and_return 'ok'
-
-      expect(block.render(Liquid::Context.new)).to eq 'ok'
-    end
-  end
+      allow(TestRenderer).to receive(:render).and_raise(error)
+      allow(block).to receive(:handle_error)
 
-  describe '#render_without_rescue' do
-    it 'render with renderer' do
-      allow(TestRenderer).to receive(:render).and_return 'success'
+      block.render_content
 
-      expect(block.render(Liquid::Context.new)).to eq 'success'
+      expect(block).to have_received(:handle_error).with(error)
     end
   end
 
-  describe '#config' do
-    it 'merge template options with inline options' do
-      allow(block).to receive(:template_options).and_return({ k1: :v1 })
-      allow(block).to receive(:inline_options).and_return({ k1: :v2, k2: :v2 })
-
-      expect(block.config).to eq({ k1: :v2, k2: :v2 })
-    end
-  end
-
-  describe '#template_options' do
-    let(:key) { LiquidDiagrams::OPTIONS_KEY }
-
-    it 'accept symbol key' do
-      allow(block).to receive(:parse_context).and_return({ key => { test: '1' } })
-
-      expect(block.template_options).to eq '1'
-    end
-
-    it 'accept string key' do
-      allow(block).to receive(:parse_context).and_return({ key => { 'test' => '2' } })
-
-      expect(block.template_options).to eq '2'
+  describe '#handle_error' do
+    it 'simply return the error' do
+      expect(block.handle_error('some error')).to eq 'some error'
     end
   end
 
-  describe '#inline_options' do
-    let(:markup) { 'a1=v1 a2="v2" a3="k3 v3"' }
-
-    let :block do
-      TestBlock.parse(
-        'test', markup, Liquid::Tokenizer.new('{% endtest %}'),
-        Liquid::ParseContext.new
-      )
-    end
-
+  describe '#read_config' do
     before do
-      allow(LiquidDiagrams::Utils).to receive :parse_inline_options
+      allow(LiquidDiagrams).to receive(
+        :configuration
+      ).and_return({ k1: :v1, k2: :v2 })
+      allow(LiquidDiagrams::Utils).to receive(
+        :parse_inline_options
+      ).and_return({ k1: :v3 })
     end
 
-    it 'call Utils.parse_inline_options' do
-      block.inline_options
-
-      expect(LiquidDiagrams::Utils).to have_received(
-        :parse_inline_options
-      ).with(markup)
+    it 'merge options with inline options' do
+      expect(block.read_config).to eq({ k1: :v3, k2: :v2 })
     end
   end
 end

data/spec/liquid_diagrams/basic_renderer_spec.rb

@@ -3,26 +3,48 @@
 require 'spec_helper'
 
 RSpec.describe LiquidDiagrams::BasicRenderer do
-  describe '.render' do
-    let(:renderer) { Object.new }
+  let(:renderer) { described_class.new('') }
 
+  describe '.render' do
     before do
       allow(renderer).to receive(:render).and_return 'yay'
       allow(described_class).to receive(:new).and_return(renderer)
     end
 
     it 'create an instance and render with it' do
-      expect(described_class.render('content', { k: 'v' })).to eq 'yay'
+      expect(described_class.render('content', { k: :v })).to eq 'yay'
     end
   end
 
   describe '#render' do
-    let(:renderer) { described_class.new('') }
-
     it 'raise not implemented error' do
       expect { renderer.render }.to raise_error(
         LiquidDiagrams::Errors::NotImplementedError
       )
     end
   end
+
+  describe '#build_command' do
+    it 'combine #executable and #arguments' do
+      allow(renderer).to receive(:executable).and_return 'cmd'
+      allow(renderer).to receive(:arguments).and_return '--flag --opt val'
+
+      expect(renderer.build_command).to eq 'cmd --flag --opt val'
+    end
+  end
+
+  describe '#executable' do
+    it 'provide a default executable' do
+      expect(renderer.executable).to eq 'basic'
+    end
+  end
+
+  describe '#arguments' do
+    it 'combine options and flags' do
+      allow(LiquidDiagrams::Utils).to receive(:build_flags).and_return '--flag'
+      allow(LiquidDiagrams::Utils).to receive(:build_options).and_return '--opt val'
+
+      expect(renderer.arguments).to eq '--flag --opt val'
+    end
+  end
 end

data/spec/liquid_diagrams/renderers/bitfield_renderer_spec.rb

@@ -2,26 +2,8 @@
 
 require 'spec_helper'
 
-RSpec.describe LiquidDiagrams::Renderers::BitfieldRenderer do
-  subject(:renderer) { described_class.new('content') }
-
+RSpec.describe LiquidDiagrams::Renderers::BitfieldRenderer, :renderers do
   describe '#render' do
     include_examples 'render with tempfile', described_class
   end
-
-  describe '#build_command' do
-    context 'when config is empty' do
-      it { expect(renderer.build_command).to match 'bitfield' }
-    end
-
-    context 'when config is not empty' do
-      before do
-        renderer.instance_variable_set(:@config, { 'fontsize' => 10 })
-      end
-
-      it 'build command with config' do
-        expect(renderer.build_command).to match '--fontsize 10'
-      end
-    end
-  end
 end

data/spec/liquid_diagrams/renderers/blockdiag_renderer_spec.rb

@@ -2,42 +2,14 @@
 
 require 'spec_helper'
 
-RSpec.describe LiquidDiagrams::Renderers::BlockdiagRenderer do
+RSpec.describe LiquidDiagrams::Renderers::BlockdiagRenderer, :renderers do
   subject(:renderer) { described_class.new('content') }
 
   describe '#render' do
     include_examples 'render with tempfile', described_class
   end
 
-  describe '#build_command' do
-    context 'when config is empty' do
-      it { expect(renderer.build_command).to eq 'blockdiag -T svg --nodoctype' }
-    end
-
-    context 'when config is not empty' do
-      before do
-        renderer.instance_variable_set(:@config, { 'size' => 10 })
-      end
-
-      it 'build command with config' do
-        expect(renderer.build_command).to match '--size=10'
-      end
-    end
-
-    context 'when switch is true' do
-      it 'build command' do
-        renderer.instance_variable_set(:@config, { 'antialias' => true })
-
-        expect(renderer.build_command).to match '--antialias'
-      end
-    end
-
-    context 'when switch is false' do
-      it 'build command' do
-        renderer.instance_variable_set(:@config, { 'antialias' => false })
-
-        expect(renderer.build_command).not_to match '--antialias'
-      end
-    end
+  describe '#executable' do
+    it { expect(renderer.executable).to eq 'blockdiag -Tsvg --nodoctype' }
   end
 end