liquid-diagrams 0.1.0

data/lib/liquid_diagrams.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'liquid'
+
+require_relative 'liquid_diagrams/version'
+
+require_relative 'liquid_diagrams/errors'
+require_relative 'liquid_diagrams/utils'
+require_relative 'liquid_diagrams/rendering'
+
+require_relative 'liquid_diagrams/basic_renderer'
+require_relative 'liquid_diagrams/basic_block'
+
+module LiquidDiagrams
+  # @note All renderers should be defined under this module
+  module Renderers
+    pattern = File.join(__dir__, 'liquid_diagrams/renderers/*_renderer.rb')
+
+    Dir[pattern].sort.each { |renderer| require renderer }
+  end
+
+  # @note All blocks are automaticly define under this module if not exist
+  module Blocks
+    Renderers.constants.grep(/Renderer$/).each do |renderer|
+      block_name = "#{renderer.to_s.chomp('Renderer')}Block"
+
+      next if Blocks.const_defined?(block_name)
+
+      Blocks.const_set(block_name, Class.new(BasicBlock))
+    end
+  end
+
+  class << self
+    # Return all diagrams defined in {Renderers}
+    #
+    # @return [Array<Symbol>]
+    def diagrams
+      @diagrams ||= renderers.keys
+    end
+
+    # Return all avaliable renderers under {Renderers}
+    #
+    # @return [Hash{Symbol => BasicRenderer}]
+    def renderers
+      @renderers ||= Hash[
+        Renderers.constants.grep(/Renderer$/).sort.map do |renderer|
+          [
+            renderer.to_s.chomp('Renderer').downcase.to_sym,
+            Renderers.const_get(renderer)
+          ]
+        end
+      ]
+    end
+
+    # Return all registered diagrams block
+    #
+    # Use {.register_diagrams} and {.register_diagram} to register a diagram
+    #
+    # @return [Hash{Symbol => BasicBlock}]
+    def registered_diagrams
+      @registered_diagrams ||= {}
+    end
+
+    # Register diagrams
+    #
+    # @param diagrams [Array<String, Symbol>] diagrams to register
+    #
+    # @return [Array<Liquid::Block>] the registered liquid blocks
+    def register_diagrams(*diagrams)
+      Array(diagrams).flatten.map { |diagram| register_diagram(diagram) }
+    end
+
+    # Register a diagram block
+    #
+    # @param diagram [#to_s] diagram name to register
+    #
+    # @return [Liquid::Block] the registered liquid block
+    def register_diagram(diagram)
+      diagram = diagram.to_s.downcase.to_sym
+
+      raise Errors::DiagramNotFoundError unless diagrams.include?(diagram)
+
+      block = Blocks.const_get("#{diagram.capitalize}Block")
+
+      registered_diagrams.merge!(diagram => block)
+      Liquid::Template.register_tag(diagram, block)
+    end
+  end
+end

data/spec/liquid_diagrams/basic_block_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::BasicBlock do
+  let(:block) do
+    TestBlock.parse(
+      'test', '', Liquid::Tokenizer.new('{% endtest %}'),
+      Liquid::ParseContext.new
+    )
+  end
+
+  before do
+    stub_const('TestBlock', Class.new(described_class))
+    stub_const('TestRenderer', Class.new)
+  end
+
+  describe '.renderer' do
+    it 'return the renderer matching the block' do
+      expect(TestBlock.renderer).to be TestRenderer
+    end
+  end
+
+  describe '#render' do
+    it 'call #render!' do
+      allow(block).to receive(:render!).and_return 'success'
+
+      expect(block.render(Liquid::Context.new)).to eq 'success'
+    end
+
+    context 'when rendering failed' do
+      let(:error) { LiquidDiagrams::Errors::BasicError.new }
+
+      it 'rescue and return the error' do
+        allow(block).to receive(:render!).and_raise(error)
+
+        expect(block.render(Liquid::Context.new)).to eq error
+      end
+    end
+  end
+
+  describe '#render!' do
+    it 'render with renderer' do
+      allow(TestRenderer).to receive(:render).and_return 'success'
+
+      expect(block.render!(Liquid::Context.new)).to eq 'success'
+    end
+  end
+end

data/spec/liquid_diagrams/basic_renderer_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::BasicRenderer do
+  describe '.render' do
+    let(:renderer) { Object.new }
+
+    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'
+    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
+end

data/spec/liquid_diagrams/renderers/blockdiag_renderer_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::BlockdiagRenderer 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
+  end
+end

data/spec/liquid_diagrams/renderers/erd_renderer_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::ErdRenderer do
+  subject(:renderer) { described_class.new('content') }
+
+  describe '#render' do
+    include_examples 'render with stdin and stdout', described_class
+  end
+
+  describe '#build_command' do
+    context 'when config is empty' do
+      it { expect(renderer.build_command).to eq 'erd --fmt=svg' }
+    end
+
+    context 'when config is not empty' do
+      before do
+        renderer.instance_variable_set(
+          :@config, { 'edge' => 10, 'color' => :blue }
+        )
+      end
+
+      it 'build command with config' do
+        expect(renderer.build_command).to match '--edge=10'
+      end
+
+      it 'ignore unsupported configuration' do
+        expect(renderer.build_command).not_to match '--color'
+      end
+    end
+
+    context 'when switch is true' do
+      it 'build command' do
+        renderer.instance_variable_set(:@config, { 'dot-entity' => true })
+
+        expect(renderer.build_command).to match '--dot-entity'
+      end
+    end
+
+    context 'when switch is false' do
+      it 'build command' do
+        renderer.instance_variable_set(:@config, { 'dot-entity' => false })
+
+        expect(renderer.build_command).not_to match '--dot-entity'
+      end
+    end
+  end
+end

data/spec/liquid_diagrams/renderers/graphviz_renderer_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::GraphvizRenderer do
+  subject(:renderer) { described_class.new('content') }
+
+  describe '#render' do
+    include_examples 'render with stdin and stdout', described_class
+  end
+
+  describe '#build_command' do
+    context 'when config is empty' do
+      it { expect(renderer.build_command).to eq 'dot -Tsvg' }
+    end
+
+    context 'when config is not empty' do
+      before do
+        renderer.instance_variable_set(:@config, { 'layout' => 'dot' })
+      end
+
+      it 'build command with config' do
+        expect(renderer.build_command).to match '-Kdot'
+      end
+    end
+
+    context 'with string attributes' do
+      before do
+        renderer.instance_variable_set(
+          :@config, { 'graph_attributes' => 'color=red' }
+        )
+      end
+
+      it 'build command' do
+        expect(renderer.build_command).to match ' -Gcolor=red'
+      end
+    end
+
+    context 'with array attributes' do
+      before do
+        renderer.instance_variable_set(
+          :@config, { 'node_attributes' => %w[color=red size=10] }
+        )
+      end
+
+      it 'build command' do
+        expect(renderer.build_command).to match ' -Ncolor=red -Nsize=10'
+      end
+    end
+
+    context 'with hash attributes' do
+      before do
+        renderer.instance_variable_set(
+          :@config, { 'edge_attributes' => { 'color': 'red', 'size': '10' } }
+        )
+      end
+
+      it 'build command' do
+        expect(renderer.build_command).to match ' -Ecolor=red -Esize=10'
+      end
+    end
+  end
+end

data/spec/liquid_diagrams/renderers/mermaid_renderer_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::MermaidRenderer 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 match 'mmdc --puppeteerConfigFile' }
+    end
+
+    context 'when config is not empty' do
+      before do
+        renderer.instance_variable_set(:@config, { 'scale' => 10, 'color' => :blue })
+      end
+
+      it 'build command with config' do
+        expect(renderer.build_command).to match '--scale 10'
+      end
+
+      it 'ignore unsupported configuration' do
+        expect(renderer.build_command).not_to match '--color blue'
+      end
+    end
+  end
+end

data/spec/liquid_diagrams/renderers/nomnoml_renderer_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::NomnomlRenderer do
+  subject(:renderer) { described_class.new('content') }
+
+  describe '#render' do
+    include_examples 'render with tempfile', described_class
+  end
+
+  describe '#build_command' do
+    it { expect(renderer.build_command).to eq 'nomnoml' }
+  end
+end

data/spec/liquid_diagrams/renderers/plantuml_renderer_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::PlantumlRenderer do
+  subject(:renderer) { described_class.new('content') }
+
+  describe '#render' do
+    before do
+      allow(renderer).to receive(:build_command)
+      allow(LiquidDiagrams::Rendering).to receive(
+        :render_with_stdin_stdout
+      ).and_return('<?xml version="1.0" encoding="UTF-8" standalone="no"?><>')
+    end
+
+    it 'call build_command' do
+      renderer.render
+
+      expect(renderer).to have_received(:build_command)
+    end
+
+    it 'render with stdin and stdout' do
+      renderer.render
+
+      expect(LiquidDiagrams::Rendering).to have_received(:render_with_stdin_stdout)
+    end
+
+    it 'remove xml heading' do
+      expect(renderer.render).to eq '<>'
+    end
+  end
+
+  describe '#build_command' do
+    it do
+      command = renderer.build_command
+
+      expect(command).to match 'Plantuml'
+      expect(command).to match '-tsvg -pipe'
+    end
+  end
+end

data/spec/liquid_diagrams/renderers/smcat_renderer_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::SmcatRenderer 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 'Smcat' }
+    end
+
+    context 'when config is not empty' do
+      before do
+        renderer.instance_variable_set(
+          :@config, { 'engine' => 'dot', 'color' => :blue }
+        )
+      end
+
+      it 'build command with config' do
+        expect(renderer.build_command).to match '--engine dot'
+      end
+
+      it 'ignore unsupported configuration' do
+        expect(renderer.build_command).not_to match '--color blue'
+      end
+    end
+  end
+end

data/spec/liquid_diagrams/renderers/svgbob_renderer_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::SvgbobRenderer do
+  subject(:renderer) { described_class.new('content') }
+
+  describe '#render' do
+    include_examples 'render with stdin and stdout', described_class
+  end
+
+  describe '#build_command' do
+    context 'when config is empty' do
+      it { expect(renderer.build_command).to eq 'svgbob' }
+    end
+
+    context 'when config is not empty' do
+      before do
+        renderer.instance_variable_set(:@config, { 'scale' => 10, 'color' => :blue })
+      end
+
+      it 'build command with config' do
+        expect(renderer.build_command).to match '--scale 10'
+      end
+
+      it 'ignore unsupported configuration' do
+        expect(renderer.build_command).not_to match '--color blue'
+      end
+    end
+  end
+end

data/spec/liquid_diagrams/renderers/syntrax_renderer_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::SyntraxRenderer 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 'syntrax' }
+    end
+
+    context 'when config is not empty' do
+      before do
+        renderer.instance_variable_set(:@config, { 'scale' => 10, 'color' => :blue })
+      end
+
+      it 'build command with config' do
+        expect(renderer.build_command).to match '--scale 10'
+      end
+
+      it 'ignore unsupported configuration' do
+        expect(renderer.build_command).not_to match '--color blue'
+      end
+    end
+  end
+end

data/spec/liquid_diagrams/renderers/vega_renderer_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::VegaRenderer do
+  subject(:renderer) { described_class.new('content') }
+
+  describe '#render' do
+    include_examples 'render with stdin and stdout', described_class
+  end
+
+  describe '#build_command' do
+    context 'when config is empty' do
+      it { expect(renderer.build_command).to eq 'vg2svg' }
+    end
+
+    context 'when config is not empty' do
+      before do
+        renderer.instance_variable_set(
+          :@config, { 'scale' => 10, 'other' => 'value' }
+        )
+      end
+
+      it 'build command with config' do
+        expect(renderer.build_command).to match '--scale 10'
+      end
+
+      it 'ignore unsupported configuration' do
+        expect(renderer.build_command).not_to match '--other'
+      end
+    end
+  end
+end

data/spec/liquid_diagrams/renderers/wavedrom_renderer_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Renderers::WavedromRenderer do
+  subject(:renderer) { described_class.new('content') }
+
+  describe '#render' do
+    include_examples 'render with tempfile', described_class
+  end
+
+  describe '#build_command' do
+    it { expect(renderer.build_command).to eq 'wavedrom-cli' }
+  end
+end

data/spec/liquid_diagrams/rendering_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LiquidDiagrams::Rendering do
+  describe '.render_with_stdin_stdout' do
+    it 'call render_with_command' do
+      allow(described_class).to receive(:render_with_command)
+
+      described_class.render_with_stdin_stdout('command', 'content')
+
+      expect(described_class).to have_received(:render_with_command).with(
+        'command', :stdout, stdin_data: 'content'
+      )
+    end
+  end
+
+  describe '.render_with_tempfile' do
+    let(:input) { Object.new }
+    let(:output) { Object.new }
+
+    before do
+      allow(described_class).to receive(:render_with_command)
+
+      allow(File).to receive(:write)
+      allow(Tempfile).to receive(:new).and_return(input, output)
+
+      allow(input).to receive(:path)
+      allow(input).to receive(:close!)
+      allow(output).to receive(:path)
+      allow(output).to receive(:close!)
+    end
+
+    it 'call Tempfile.new twice to create input and output file' do
+      described_class.render_with_tempfile('command', 'content') {}
+
+      expect(Tempfile).to have_received(:new).twice
+    end
+
+    it 'yield input path and output path' do
+      described_class.render_with_tempfile('command', 'content') {}
+
+      expect(input).to have_received(:path).twice
+      expect(output).to have_received(:path).twice
+    end
+
+    it 'close input and output file after rendering' do
+      described_class.render_with_tempfile('command', 'content') {}
+
+      expect(input).to have_received(:close!).once
+      expect(output).to have_received(:close!).once
+    end
+
+    it 'call render_with_command' do
+      described_class.render_with_tempfile('command', 'content') {}
+
+      expect(described_class).to have_received(:render_with_command)
+    end
+  end
+
+  describe '.render_with_command' do
+    it 'call Open3.capture3' do
+      status = Object.new
+
+      allow(status).to receive(:success?).and_return(true)
+      allow(Open3).to receive(:capture3).and_return(['o', 'e', status])
+
+      described_class.render_with_command('command')
+
+      expect(Open3).to have_received(:capture3)
+    end
+
+    context 'when command is not found' do
+      it 'raise a command not found error' do
+        allow(Open3).to receive(:capture3).and_raise(Errno::ENOENT)
+
+        expect do
+          described_class.render_with_command('command')
+        end.to raise_error LiquidDiagrams::Errors::CommandNotFoundError
+      end
+    end
+
+    context 'when rendering failed' do
+      before do
+        status = Object.new
+
+        allow(status).to receive(:success?).and_return(false)
+        allow(Open3).to receive(:capture3).and_return(['o', 'e', status])
+      end
+
+      it 'raise a rendering failed error' do
+        expect do
+          described_class.render_with_command('command')
+        end.to raise_error LiquidDiagrams::Errors::RenderingFailedError
+      end
+    end
+
+    context 'when output is stdout' do
+      before do
+        status = Object.new
+
+        allow(status).to receive(:success?).and_return(true)
+        allow(Open3).to receive(:capture3).and_return(['o', 'e', status])
+      end
+
+      it 'read output from stdout' do
+        expect(described_class.render_with_command('cmd', :stdout)).to eq 'o'
+      end
+    end
+
+    context 'when output is a file' do
+      before do
+        status = Object.new
+
+        allow(status).to receive(:success?).and_return(true)
+        allow(Open3).to receive(:capture3).and_return(['o', 'e', status])
+        allow(File).to receive(:read)
+      end
+
+      it 'read output from the file' do
+        described_class.render_with_command('cmd', 'a_file')
+
+        expect(File).to have_received(:read).with('a_file')
+      end
+    end
+  end
+end