markdoc 1.0.1 → 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 903c73cf0ff9c9c6b3b9caaf41c0d9fd6ebda60624259acae36e09fa8fd4f81a
+  data.tar.gz: aad92c597c2acc1f40449d7e5f1feaa608140831bbd88d22640e77e23796e620
+SHA512:
+  metadata.gz: fee4a4c2de9b2350c3df3991c6b6a3c11640fe7026f741e6eb62bb50475fc5adb6492004fb24e304231cbdfa1c9beba8de527b1d79a76e8e497e27bae0d66498
+  data.tar.gz: a2e44199fb3ed992890ce7a74d028b90e2d708c28eaa5cb9db34746784c11c4283d3134ecbdf72bf67c4077a7c2f3256ff5605f3a5bf5113d8b9db6a5cb15501

data/lib/markdoc/pseudocode.treetop

@@ -21,11 +21,7 @@ module Markdoc
     end
 
     rule sentence
-      ( !keywords word )+ <SentenceLiteral>
-    end
-
-    rule word
-      [a-zA-Z0-9 ]+
+      ( !keywords [^\n]+ )+ <SentenceLiteral>
     end
 
     rule space
@@ -36,4 +32,4 @@ module Markdoc
       space* [\n]+ space*
     end
   end
-end
+end

data/lib/markdoc/sequence.rb

@@ -1,211 +1,323 @@
 module Markdoc
   module Sequence
-    def self.draw(code, format = :svg)
-      parser = Parser.new(code)
+    DEFAULTS = {
+      diagram: {
+        offsetx: 10,
+        offsety: 10,
+        width:   900,
+        height:  600
+      },
+      role: {
+        font: "'Roboto Condensed', sans-serif",
+        border: '#3c4260',
+        fill:   '#dcd7d7',
+        radius:  2,
+        spacing: 100,
+        width:   100,
+        height:  55,
+        line:    3,
+      },
+      message: {
+        color: '#3c4260',
+        font: "'Roboto Condensed', sans-serif",
+        size: 11,
+        spacing: 40,
+        offset: 100, # from top
+        line:    3,
+        dash: '4,2'
+      }
+    }
 
-      digest = Digest::MD5.hexdigest code
+    def self.draw(code)
+      diagram = Diagram.new(code)
+      diagram.parse
+      diagram.print
+    end
+
+    class Role
+      include Comparable
+
+      attr_accessor :id, :label, :messages, :column,
+                    :offsetx, :offsety, :border, :fill, :radius, :spacing, :width, :height, :line, :font,
+                    :prev, :succ
 
-      pic = nil
-      Tempfile.open([digest, '.pic']) do |file|
-        file.write parser.parse
-        pic = file.path
+      def initialize(args)
+        self.messages = []
+        self.id = args[:id].strip
+        self.label = args[:label].strip
+
+        # ui settings
+        self.column = args[:column]
+        self.offsetx = args[:diagram][:offsetx]
+        self.offsety = args[:diagram][:offsety]
+        self.border = args[:ui][:border]
+        self.fill = args[:ui][:fill]
+        self.radius = args[:ui][:radius]
+        self.spacing = args[:ui][:spacing]
+        self.width = args[:ui][:width]
+        self.height = args[:ui][:height]
+        self.line = args[:ui][:line]
+        self.font = args[:ui][:font]
       end
 
-      if format == :pic
-        return IO.read(pic)
+      def <=> o
+        column <=> o.column
       end
 
-      image = Tempfile.new([digest, ".#{format}"])
-      image.close
+      def type
+        case label
+        when /actor/i
+          :actor
+        when /database/i
+          :database
+        when /site|web/i
+          :website
+        when /application|system/i
+          :system
+        else
+          :component
+        end
+      end
 
-      if system("pic2plot -T#{format} #{pic} > #{image.path}")
-        IO.read image
-      else
-        raise "Can't generate sequence diagram"
+      def center
+        x + width/2
       end
-    end
 
-    class Role
-      attr_accessor :type, :id, :label, :active
-      def initialize(type, id, label)
-        self.type, self.id, self.label = type, id, label
-        self.active = false
+      def x
+        offsetx + column*(width + spacing)
       end
-      def activate
-        return if active
-        self.active = true
-        "active(#{id});"
+
+      def y
+        offsety
       end
-      def deactivate
-        return unless active
-        self.active = false
-        "inactive(#{id});"
+
+      def print
+        elements = []
+        case type
+        when :actor
+          elements << %Q[<g transform="translate(#{x+10},0)"><path d="M74,64 a30,30 0 0,0 -27,-27 a16,18 0 1,0 -16,0 a30,30 0, 0,0 -27,27 z" stroke-width="#{line}" fill="#{fill}" stroke="#{border}"/></g>]
+          elements << %Q[<text x="#{x+46-2*id.size}" y="#{y+height-5}" font-family="#{font}" font-size="12" fill="#{border}">#{id}</text>]
+        else
+          elements << %Q[<rect fill="#{fill}" stroke="#{border}" rx="#{radius}" ry="#{radius}" x="#{x}" y="#{y}" width="#{width}" height="#{height}" stroke-width="#{line}"/>]
+          elements << %Q[<text x="#{x+10}" y="#{y+20}" font-family="#{font}" font-size="12" fill="#{border}">#{label}</text>]
+        end
+
+        x1 = center
+        y1 = offsety + height
+        x2 = center
+        y2 = messages.last.y + 10
+        elements << %Q[<line x1="#{x1}" y1="#{y1}" x2="#{x2}" y2="#{y2}" stroke="#{border}" stroke-width="#{line}"/>]
+
+        elements.join("\n")
       end
     end
 
     class Message
-      attr_accessor :type, :source, :dest, :label, :comment
-      def initialize(type, source, dest, label, comment)
-        self.type, self.source, self.dest, self.label, self.comment = type, source, dest, label.strip, comment.strip
-      end
+      attr_accessor :source, :dest, :op, :label, :comment, :row,
+                    :offset, :color, :font, :size, :spacing, :line, :dash,
+                    :options
+
+      def initialize(args)
+        self.options = []
+        self.label = args[:label].strip
+        self.comment = args[:comment].strip
+
+        self.op = args[:op]
+        self.row = args[:row]
+        # ui
+        self.offset  = args[:ui][:offset]
+        self.color   = args[:ui][:color]
+        self.font    = args[:ui][:font]
+        self.size    = args[:ui][:size]
+        self.spacing = args[:ui][:spacing]
+        self.line    = args[:ui][:line]
+        self.dash    = args[:ui][:dash]
+
+        if op.index('~')
+          options << %Q[stroke-dasharray="#{dash}"]
+        elsif op.index('-').nil?
+          raise "Message direction must be one of ->, ~>, <-, <~"
+        end
+
+        if op.index('>')
+          self.source, self.dest = args[:role1], args[:role2]
+        elsif op.index('<')
+          self.source, self.dest = args[:role2], args[:role1]
+        else
+          raise "Message direction must be one of ->, ~>, <-, <~"
+        end
 
-      def roles
-        [source, dest]
+        source.messages << self
+        dest.messages << self unless source.eql?(dest)
       end
 
-      def deliver
-        %Q[#{type}(#{source.id},#{dest.id}, "#{label}");]
+      def print
+        role1, role2 = *(source < dest ? [source, dest] : [dest, source])
+        elements = []
+
+        if role1.eql?(role2)
+          x1 = role1.center
+          y1 = y
+          x2 = x1 + 50
+          y2 = y1 + spacing
+
+          elements << %Q(<polyline points="#{x1},#{y1} #{x2},#{y1} #{x2},#{y2} #{x1+5},#{y2}" fill="none" stroke-width="2" stroke-linejoin="round" stroke="#{color}" #{options.join ' '}/>)
+          elements << %Q(<polygon points="#{x1+10},#{y2-5} #{x1},#{y2} #{x1+10},#{y2+5}" fill="#{color}"/>)
+          elements << %Q(<text x="#{x1+10}" y="#{y1-5}" font-family="#{font}" font-size="#{size}" fill="#{color}">#{label}</text>)
+        else
+          x1 = role1.center
+          x2 = role2.center
+
+          if role1 == source
+            x2 -= 10
+            elements << %Q(<polygon points="#{x2},#{y-5} #{x2+10},#{y} #{x2},#{y+5}" fill="#{color}"/>)
+          else
+            x1 += 10
+            elements << %Q(<polygon points="#{x1},#{y-5} #{x1-10},#{y} #{x1},#{y+5}" fill="#{color}"/>)
+          end
+
+          elements << %Q(<line x1="#{x1}" y1="#{y}" x2="#{x2}" y2="#{y}" stroke="#{color}" stroke-width="2" #{options.join ' '}/>)
+          elements << %Q(<text x="#{x1+40}" y="#{y-5}" font-family="#{font}" font-size="#{size}" fill="#{color}">#{label}</text>)
+
+          if comment.size > 0
+            x = role2.prev.center + 15
+            elements << %Q(<path fill="#eeeeee" d="M#{x2-30},#{y+1} L#{x2-30},#{y+10} H#{x} V#{y+2*spacing - 25} H#{x2} V#{y+10} H#{x2-20} z" />)
+            elements << %Q(<text x="#{x+5}" y="#{y+23}" font-family="#{font}" font-size="#{size}" fill="#{color}">)
+            split(comment).each_with_index do |line, i|
+              elements << %Q(<tspan x="#{x+5}" y="#{y+23+13*i}">#{line}</tspan>)
+            end
+            elements << '</text>'
+          end
+        end
+
+        elements.join("\n")
       end
 
-      def describe
-        return if comment.empty?
-        width = comment.length > 10 ? 1 : comment.length * 0.13
-        width = 0.5 if width < 0.5
-        %Q[comment(#{dest.id},C,up 0.2 right, wid #{'%.1f' % width} ht 0.3 "#{comment}");]
+      def y
+        offset + row*spacing
       end
 
-      def height
-        source == dest ? 2 : 1
+      private
+
+      def split(text, max = 35)
+        ary = []
+        line = ''
+        text.split.each do |word|
+          if (line + word).length < max
+            line << ' ' << word
+          else
+            ary << line
+            line = word
+          end
+        end
+        ary << line if line.length > 0
+        ary
       end
+
     end
 
-    class Parser
-      attr_accessor :source, :variables, :roles, :messages, :output
-
-      def defaults
-        {
-          boxht:     '0.5', # Object box height
-          boxwid:    '1.3', # Object box width
-          awid:      '0.1', # Active lifeline width
-          spacing:   '0.25', # Spacing between messages
-          movewid:   '0.75', # Spacing between objects
-          dashwid:   '0.05', # Interval for dashed lines
-          maxpswid:  '20', # Maximum width of picture
-          maxpsht:   '20', # Maximum height of picture
-          underline: '0', # Underline the name of objects
-        }
-      end
+    class Diagram
+      attr_accessor :input, :output, :attributes, :roles, :messages, :rows
 
-      def initialize(source, options = {})
-        self.source = source
+      def initialize(input, options = {})
+        self.input = input
         self.output = []
         self.roles = []
         self.messages = []
-        self.variables = defaults.dup
+        self.rows = 0
+        self.attributes = DEFAULTS.dup
+
         options.each do |key, value|
-          variables[key] = value
+          attributes.merge!(key => value)
         end
       end
 
       def find(id)
-        id.strip!
-        roles.detect{|role| role.id == id}
+        roles.detect{|role| role.id == id.strip} or raise("Non-declared role: #{id}")
       end
 
       def parse
-        source.split("\n").each do |line|
+        input.split("\n").each do |line|
           next if line.strip.empty?
-          if match = line.match(/^([a-zA-Z0-9_ \t]+) *= *([a-zA-Z0-9_ \t]+)/)
-            if match[2] =~ /Actor/
-              roles << Role.new(:actor, match[1].strip, match[1].strip)
-            else
-              roles << Role.new(:object, match[1].strip, match[2].strip)
-            end
-          elsif match = line.match(/^([a-zA-Z0-9_ \t]+) *([<\-~>]{2}) *([a-zA-Z0-9_ \t]+):([^#]+)#?(.*)/)
-            role1, role2, op = find(match[1]), find(match[3]), match[2]
-
-            if op.index('>')
-              source, dest = role1, role2
-            elsif op.index('<')
-              source, dest = role2, role1
-            else
-              raise "Message direction must be one of ->, ~>, <-, <~"
-            end
 
-            if op.index('-')
-              type = :message
-            elsif op.index('~')
-              type = :rmessage
-            else
-              raise "Message direction must be one of ->, ~>, <-, <~"
-            end
-
-            message = Message.new(type, source, dest, match[4], match[5])
-            # deactivate prev messages roles
-            if last = messages.last
-              (last.roles - message.roles).each do |role|
-                output << role.deactivate if role.active
-              end
-            end
-            # activate source before send message
-            output << source.activate unless source.active
-            output << message.deliver
-            output << message.describe
-            # activate dest
-            output << dest.activate unless dest.active
-            messages << message
-          elsif match = line.match(/^([a-zA-Z0-9_ \t]+) *:([^#]+)#?(.*)/)
-            role = find(match[1])
-            message = Message.new(:message, role, role, match[2], match[3])
-            # deactivate prev messages roles
-            if last = messages.last
-              (last.roles - message.roles).each do |role|
-                output << role.deactivate if role.active
-              end
-            end
-            # activate role before send message
-            output << role.activate unless role.active
-            output << message.deliver
-            output << message.describe
-            messages << message
+          if matches = line.match(/^(?<id>[a-zA-Z0-9_ \t]+) *= *(?<label>[a-zA-Z0-9_ \t]+)/)
+            # User = Actor
+            roles << Role.new(
+              id: matches[:id],
+              label: matches[:label],
+              column: roles.size,
+              diagram: attributes[:diagram],
+              ui: attributes[:role]
+            )
+          elsif matches = line.match(/^(?<role1>[a-zA-Z0-9_ \t]+) *(?<op>[<\-~>]{2}) *(?<role2>[a-zA-Z0-9_ \t]+):(?<label>[^#]+)#?(?<comment>.*)/)
+            # User -> Web : Login
+            messages << Message.new(
+              role1: find(matches[:role1]),
+              role2: find(matches[:role2]),
+              row: rows,
+              op: matches[:op],
+              label: matches[:label],
+              comment: matches[:comment],
+              diagram: attributes[:diagram],
+              ui: attributes[:message]
+            )
+            self.rows += 1
+            # comment takes 1 more row
+            self.rows += 1 if matches[:comment].length > 0
+          elsif matches = line.match(/^(?<role>[a-zA-Z0-9_ \t]+) *:(?<label>[^#]+)#?(?<comment>.*)/)
+            # Web : Save the form
+            messages << Message.new(
+              role1: find(matches[:role]),
+              role2: find(matches[:role]),
+              row: rows,
+              op: '->',
+              label: matches[:label],
+              comment: matches[:comment],
+              diagram: attributes[:diagram],
+              ui: attributes[:message]
+            )
+            # self message takes 2 rows
+            self.rows += 2
           end
         end
 
-        header
-        footer
+        prev = nil
+        roles.each do |succ|
+          succ.prev = prev
+          prev.succ = succ if prev
+          prev = succ
+        end
+      end
 
-        output.compact.join("\n")
+      def print
+        template % {
+          width: width,
+          height: height,
+          content: (roles + messages).map(&:print).join("\n")
+        }
       end
 
-      def macros
-        IO.read File.join(File.dirname(__FILE__), 'sequence.pic')
+      def height
+        attributes[:message][:offset] +
+          attributes[:message][:spacing] * rows +
+          attributes[:diagram][:offsety] * 2
       end
 
-      def header
-        headers = []
-        headers << '.PS'
-        headers << ''
-        headers << macros
-        headers << ''
-        headers << '# Variables'
-        # calculate height
+      def width
+        (attributes[:role][:spacing] + attributes[:role][:width]) * roles.size +
+          attributes[:diagram][:offsetx]
+      end
 
-        variables[:maxpsht] = ((variables[:spacing].to_f *
-                                messages.map(&:height).reduce(:+)) +
-                               variables[:boxht].to_f).ceil
+      private
 
-        variables.each do |key, value|
-          headers << "#{key} = #{value};"
-        end
-        headers << '# Actors and Objects'
-        roles.each do |object|
-          headers << %Q[#{object.type}(#{object.id},"#{object.label}");]
-        end
-        headers << 'step();'
-        headers << ''
-        self.output =  headers + output
+      def template
+        '<svg xmlns="http://www.w3.org/2000/svg" '+
+          'xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" '+
+          'width="%{width}" height="%{height}" '+
+          'viewBox="0 0 %{width} %{height}">'+
+          '%{content}</svg>'
       end
 
-      def footer
-        output << ''
-        output << 'step();'
-        output << '# Complete the lifelines'
-        roles.each do |object|
-          output << "complete(#{object.id});"
-        end
-        output << ''
-        output << '.PE'
-      end
     end
   end
 end

data/lib/markdoc/version.rb

@@ -1,3 +1,3 @@
 module Markdoc
-  VERSION = '1.0.1'
+  VERSION = '1.2.1'
 end

metadata

@@ -1,122 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: markdoc
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.2.1
 platform: ruby
 authors:
 - Lkhagva Ochirkhuyag
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-04-10 00:00:00.000000000 Z
+date: 2020-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: polyglot
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   name: treetop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: pygments.rb
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 10.0.0
 description: Markdown with support for pseudocode to flowchart and sequence diagram
   generation
 email: ochkoo@gmail.com
 executables:
 - markdoc
+- pseudo2svg
+- sequence2svg
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/markdoc
+- bin/pseudo2svg
+- bin/sequence2svg
+- css/pygments.css
+- css/style.css
 - lib/markdoc.rb
 - lib/markdoc/pseudocode.rb
 - lib/markdoc/pseudocode.treetop
 - lib/markdoc/renderer.rb
 - lib/markdoc/sequence.rb
 - lib/markdoc/version.rb
-- css/style.css
-- css/pygments.css
-- bin/markdoc
-- bin/pseudo2svg
-- bin/sequence2svg
 homepage: https://github.com/ochko/markdoc
 licenses:
 - MIT
-post_install_message: 
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.23.2
-signing_key: 
-specification_version: 3
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
 summary: Markdown to HTML converter with diagrams
 test_files: []