chem_scanner 0.1.3

data/lib/chem_scanner/chem_draw/node/fragment_node.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    ALIAS_VALUES = [0, 4, 5, 8, 12].freeze
+
+    # CDX Node parser
+    class FragmentNode < BaseNode
+      require "chem_scanner/chem_draw/node/fragment"
+      require "chem_scanner/chem_draw/node/text"
+
+      attr_accessor :num_hydrogens, :atnum, :spin, :charge, :iso, :type,
+                    :ext_type, :x, :y, :is_alias, :alias_text,
+                    :warning, :warning_data, :fragment, :nested_fragment,
+                    :nested_text, :color, :expanded, :point, :is_polymer
+
+      def initialize(parser, parser_type, id)
+        super(parser, parser_type, id)
+
+        @num_hydrogens = -1
+        @atnum = -1
+        @spin = 0
+        @charge = 0
+        @iso = 0
+        @color = 0
+        @type = -1
+        @ext_type = -1
+        @alias_text = ""
+        @warning = false
+        @warning_data = ""
+        @is_alias = false
+
+        @nested_fragment = {}
+        @nested_text = {}
+        @expanded = false
+        @is_polymer = false
+      end
+
+      # rubocop:disable Methods/PerceivedComplexity
+      def parse_node(tag, nid, data)
+        ref = @props_ref[tag]
+        ref = ref.nil? ? @obj_ref[tag] : ref
+
+        case ref
+        when "Node_Element" then @atnum = read_value(tag, data)
+        when "Atom_Radical" then @spin = read_value(tag, data)
+        when "Atom_Isotope" then @iso = read_value(tag, data)
+        when "Fragment"
+          frag = Fragment.new(@parser, @parser_type, nid)
+          frag.read
+          @nested_fragment[nid] = frag
+        when "Atom_GenericNickname"
+          nickname = send("#{@parser_type}_text", data)
+          @generic_nickname = nickname.first[:text] unless nickname.empty?
+        when "Node_Type"
+          @type = read_type(tag, data, CDXML_NODE_TYPE)
+          @is_alias = ALIAS_VALUES.include?(@type)
+        when "2DPosition" then @x, @y = read_value(tag, data)
+        when "Atom_Charge" then @charge = read_value(tag, data)
+        when "Text"
+          @text = Text.new(@parser, @parser_type, nid, true)
+          # NOTE: MUST read first in order to maintain CDX reader
+          @text.read
+          @polygon = @text.polygon
+
+          @nested_text[@text.id] = @text
+        when "ChemicalWarning"
+          @warning = true
+          @warning_data = @parser_type == "cdxml" ? data.text : data
+        when "Atom_NumHydrogens" then @num_hydrogens = read_value(tag, data)
+        when "ForegroundColor" then @color = read_value(tag, data)
+        when "Atom_ExternalConnectionType"
+          @ext_type = read_type(tag, data, CDXML_ATOM_EXTERNAL_CONNECTION_TYPE)
+        else do_unhandled(tag)
+        end
+      end
+      # rubocop:enable Methods/PerceivedComplexity
+
+      def post_parse_node
+        @point = Geometry::Point.new(@x, @y)
+
+        if !@text.nil? && !@text.value.empty?
+          @alias_text = @text.value
+          return
+        end
+
+        interpreter = ChemScanner::Interpreter
+        if !@generic_nickname.nil? &&
+            interpreter.rgroup_atom?(@generic_nickname)
+          @is_alias = true
+          @type = 7
+          @alias_text = @generic_nickname
+        end
+      end
+
+      def leftbottom
+        @polygon.nil? ? point : @polygon.bounding_box.leftbottom
+      end
+
+      def righttop
+        @polygon.nil? ? point : @polygon.bounding_box.righttop
+      end
+
+      def has_nil_coord?
+        (@x.nil? || @y.nil?) && @polygon.nil?
+      end
+
+      def set_type(type)
+        @type = type
+      end
+
+      def set_expanded
+        @expanded = true
+      end
+
+      def set_is_polymer
+        @is_alias = true
+        @is_polymer = true
+      end
+
+      def clone
+        cloned = self.class.new(@parser, @parser_type, nil)
+        cloned.num_hydrogens = @num_hydrogens
+        cloned.atnum = @atnum
+        cloned.spin = @spin
+        cloned.charge = @charge
+        cloned.iso = @iso
+        cloned.color = @color
+        cloned.type = @type
+        cloned.alias_text = @alias_text
+        cloned.warning = @warning
+        cloned.warning_data = @warning_data
+        cloned.is_alias = @is_alias
+        cloned.expanded = @expanded
+
+        cloned.nested_fragment = {}
+        cloned.nested_text = {}
+        @nested_fragment.each { |k, v| cloned.nested_fragment[k] = v }
+        @nested_text.each { |k, v| cloned.nested_text[k] = v }
+
+        cloned
+      end
+    end
+  end
+end

data/lib/chem_scanner/chem_draw/node/graphic.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    # CDX Graphic parser
+    class Graphic < BaseNode
+      attr_reader :arrow_id, :type, :arrow_head, :head, :tail,
+                  :line_type, :orbital_type, :oval_type, :polygon
+
+      GRAPHIC_BRACKET_TYPE = 6
+
+      def initialize(parser, parser_type, id)
+        super(parser, parser_type, id)
+
+        @line_type = 0
+      end
+
+      def parse_node(tag, _id, data)
+        case @props_ref[tag]
+        when "Arrow_Type"
+          @arrow_head = read_type(tag, data, CDXML_ARROW_TYPE)
+        when "Line_Type"
+          @line_type = read_type(tag, data, CDXML_LINE_TYPE)
+        when "Graphic_Type"
+          @type = read_type(tag, data, CDXML_GRAPHIC_TYPE)
+        # Graphic objects are the only objects whose kCDXProp_BoundingBox
+        # property has a special meaning, representing a pair of points
+        # rather than a rectangle.
+        when "BoundingBox" then @polygon = read_value(tag, data)
+        when "SupersededBy" then @arrow_id = read_value(tag, data)
+        when "3DMajorAxisEnd" then @right, @top = read_value(tag, data)
+        when "3DMinorAxisEnd" then @left, @bottom = read_value(tag, data)
+        when "Orbital_Type"
+          @orbital_type = read_type(tag, data, CDXML_ORBITAL_TYPE)
+        when "Oval_Type"
+          @oval_type = read_type(tag, data, CDXML_OVAL_TYPE)
+        else do_unhandled(tag)
+        end
+      end
+
+      def post_parse_node
+        # When dealing with orbital, boundingbox is not reliable
+        build_orbital_polygon if @type == 5
+
+        # In case of Graphic is arrow
+        # Treat as arrow if is a line, no "SupersededBy" and has "BoundingBox"
+        return unless @type == 1 && @arrow_id.nil? && !@polygon.nil?
+
+        vertices = @polygon.vertices
+        # start point ~ head
+        sp = vertices[1]
+        # end point ~ tail
+        ep = vertices[3]
+
+        @head = { x: sp.x, y: sp.y }
+        @tail = { x: ep.x, y: ep.y }
+      end
+
+      def build_orbital_polygon
+        return unless @orbital_type == 256 && @oval_type == 3
+
+        p1 = Geometry::Point.new(@left, @bottom)
+        p2 = Geometry::Point.new(@left, @top)
+        p3 = Geometry::Point.new(@right, @top)
+        p4 = Geometry::Point.new(@right, @bottom)
+
+        @polygon = Geometry::Polygon.new([p1, p2, p3, p4])
+      end
+
+      def line?
+        @type == 1 && @arrow_id.nil? && (@arrow_head.nil? || @arrow_head.zero?)
+      end
+
+      def segment
+        Geometry::Segment.new_by_arrays(
+          [@tail[:x], @tail[:y]],
+          [@head[:x], @head[:y]],
+        )
+      end
+
+      def vector
+        segment.to_vector
+      end
+
+      def line
+        segment.to_line
+      end
+
+      def cross?
+        false
+      end
+    end
+  end
+end

data/lib/chem_scanner/chem_draw/node/text.rb

@@ -0,0 +1,242 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    # Text parser
+    class Text < BaseNode
+      attr_accessor :warning, :warning_data, :x, :y, :styled_text, :value,
+                    :center, :polygon, :bold_text, :non_bold_text
+
+      GREEK_CHARS = {
+        "A" => "Α",
+        "a" => "α",
+        "B" => "Β",
+        "b" => "β",
+        "G" => "Γ",
+        "g" => "γ",
+        "D" => "Δ",
+        "d" => "δ",
+        "E" => "Ε",
+        "e" => "ε",
+        "Z" => "Ζ",
+        "z" => "ζ",
+        "H" => "Η",
+        "h" => "η",
+        "Q" => "Θ",
+        "q" => "θ",
+        "I" => "Ι",
+        "i" => "ι",
+        "K" => "Κ",
+        "k" => "κ",
+        "L" => "Λ",
+        "l" => "λ",
+        "M" => "Μ",
+        "m" => "μ",
+        "N" => "Ν",
+        "n" => "ν",
+        "C" => "Ξ",
+        "c" => "ξ",
+        "O" => "Ο",
+        "o" => "ο",
+        "P" => "Π",
+        "p" => "π",
+        "R" => "Ρ",
+        "r" => "ρ",
+        "S" => "Σ",
+        "s" => "σ",
+        "T" => "Τ",
+        "t" => "τ",
+        "U" => "Υ",
+        "u" => "υ",
+        "F" => "Φ",
+        "f" => "φ",
+        "X" => "Χ",
+        "x" => "χ",
+        "Y" => "Ψ",
+        "y" => "ψ",
+        "W" => "Ω",
+        "w" => "ω",
+      }.freeze
+
+      BOLD_VAL = 0x01
+      FONT_KEY = "face"
+      COLOR_KEY = "color"
+
+      def initialize(parser, parser_type, id, is_alias = false)
+        super(parser, parser_type, id)
+
+        @warning = false
+        @is_alias = is_alias
+
+        @bold_text = ""
+        @value = ""
+      end
+
+      def parse_node(tag, _id, data)
+        # NOTE: CDXML text does not have tag
+        # "Text" below only happens for CDX
+        case @props_ref[tag]
+        when "Text" then @styled_text = cdx_text(data)
+        when "2DPosition" then @x, @y = read_value(tag, data)
+        when "BoundingBox" then @polygon = read_value(tag, data)
+        when "ChemicalWarning"
+          @warning = true
+          @warning_data = data
+        else do_unhandled(tag)
+        end
+      end
+
+      def pre_parse_node
+        return if @parser_type == "cdx"
+
+        @styled_text = cdxml_text(@parser.reader)
+      end
+
+      def post_parse_node
+        process_style
+        retrieve_bold_text
+
+        @center = Geometry::Point.new(@x, @y)
+      end
+
+      def remove_bold
+        @styled_text.delete_if { |s| (s[:face] & 1) == 1 }
+        process_style
+      end
+
+      def markdown
+        @styled_text.reduce("") do |md, style|
+          md += style[:bold] ? "**#{style[:text]}**" : style[:text]
+          md
+        end
+      end
+
+      def bolded_styles
+        @styled_text.select { |s| s[:bold] }
+      end
+
+      private
+
+      def process_style
+        pos_cur = 0
+        @styled_text.each do |style|
+          style[:text] = to_unicode(style[:text])
+          style[:text].gsub!(/\r\n?/, "\n")
+
+          style[:position] = pos_cur
+          tlength = style[:text].size
+          style[:length] = tlength
+          pos_cur += tlength
+
+          fidx = @parser.font_table.find_index { |f| f[:id] == style[:font] }
+          next if fidx.nil?
+
+          font = @parser.font_table[fidx]
+          if font[:name] == "Symbol" && style[:face] & 1 != 1
+            t = style[:text].gsub(Regexp.union(GREEK_CHARS.keys), GREEK_CHARS)
+            style[:text] = t + " "
+          end
+
+          # User use superscript "_" as minus
+          style[:text] = "-" if style[:face] == 64 && style[:text] == "_"
+          style[:text] = style[:text].gsub("–", "-")
+
+          style[:bold] = (style[:face] & 1) == 1
+        end
+
+        # If "3-6" bold, "-" is originally not BOLD. Same for bolded "2a,b"
+        # Set bold for single "middle" character
+        set_special_bold
+
+        # Merge previous continuous bold text
+        merge_bold
+      end
+
+      def set_special_bold
+        return if @styled_text.count < 2
+
+        bold_ids = []
+        @styled_text.each_with_index do |style, idx|
+          next unless style[:bold]
+
+          prev_idx = bold_ids.last
+          bold_ids.push(idx)
+          next if idx.zero?
+
+          prev = @styled_text[idx - 1]
+          check = (
+            style[:position] == (prev[:position] + prev[:length]) &&
+            prev[:text].strip.length == 1 &&
+            prev_idx == idx - 2
+          )
+          next unless check
+
+          prev[:bold] = true
+        end
+      end
+
+      def merge_bold
+        bold_ids = @styled_text.each_with_index.reduce([]) do |arr, (s, idx)|
+          arr.push(idx) if s[:bold]
+
+          arr
+        end
+        return if bold_ids.empty?
+
+        consecutive = [[bold_ids.last]]
+        bold_ids.reverse[1..-1].each do |idx|
+          sub_arr = consecutive.last
+
+          if sub_arr.last == idx + 1
+            sub_arr.push(idx)
+          else
+            consecutive.push([idx])
+          end
+        end
+        consecutive.reject! { |arr| arr.count == 1 }
+
+        consecutive.each do |ids|
+          ids[0..-2].each do |idx|
+            @styled_text[idx - 1][:text] += @styled_text[idx][:text]
+            @styled_text.delete_at(idx)
+          end
+        end
+      end
+
+      def to_unicode(text)
+        return text if text.encoding == Encoding::UTF_8
+
+        text.force_encoding(Encoding::CP1252)
+        text.encode(
+          Encoding::UTF_8,
+          invalid: :replace,
+          undef: :replace,
+          replace: "??",
+        )
+      end
+
+      def retrieve_bold_text
+        bold_arr, non_bold_arr = @styled_text.partition { |s| s[:bold] }
+        @bold_text = bold_arr.map { |x| x[:text] }.join(" ")
+        @bold_text.gsub!(/[,:\.] *$/, "")
+        @non_bold_text = non_bold_arr.map { |x| x[:text] }.join("")
+        @value = @styled_text.reduce("") { |mem, obj| "#{mem}#{obj[:text]}" }
+
+        # NOTE: Replace U+2219 to U+00B7
+        @bold_text = @bold_text.strip.gsub(/\r|\r\n/, "\n").gsub("∙", "·")
+        @non_bold_text = @non_bold_text.strip.
+          gsub(/\r|\r\n/, "\n").gsub("∙", "·")
+        @value = @value.strip.gsub(/\r|\r\n/, "\n").gsub("∙", "·")
+      end
+
+      def inspect
+        (
+          "#<Text: id=#{@id}, " +
+            "bold: #{@bold_text}, " +
+            "value: #{@value} >"
+        )
+      end
+    end
+  end
+end