zotica 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 768244b2c952c5326c6a245d54e51b6103f8a5e6d072f2155cc76cc49f652176
-  data.tar.gz: ef29e149f6fe8ddf376e9eff1f0da778fd17fa572860bb53af7e4c4388992ece
+  metadata.gz: 46424f38382db4c95bd3a2a11ea8a51702749b173031b9c3a5ea34db5236e410
+  data.tar.gz: e31907a1bbe6768ab69fd8341e461c94f0889bdb78616ec5fbc77bb858c2252a
 SHA512:
-  metadata.gz: 4b08b255e685e21aa9f401538a2997990672f80d8757f712efe65a0507923019e3af89b6b015aa69f3e5caffb2b5df2655c51ef63429a54da18cf4be5dd010e3
-  data.tar.gz: b807e3c24c149a0984fd5ad8eab7cbba49897b79c54eedb845a6afd57f90271403ba98d49d7ce2a8ae8254ec0ef66ad8f53681d185a5a8b8617ca2c71b432fa7
+  metadata.gz: 5e0f6c7468c73604664eca91f23c8a9e9ac26edde468b20c0dadaee5ed1c32682478cdc688d58ef37cc6e17914eee1897b312ad73c344b0be5c88a06a659e3a5
+  data.tar.gz: 9c5a39b83b6c6d39650836d89915b26f5f09713f03b9c7c85627f5fef310a52decaaacd55c2456e3f34e49d5baa46d0dec904afaf4133d31e841d2d3e424c5ef

data/source/zotica/builder.rb

@@ -1,15 +1,7 @@
 # coding: utf-8
 
 
-require 'json'
-require 'pp'
-require 'rexml/document'
-require 'sassc'
-require 'ttfunk'
-include REXML
-
-
-module ZoticaBuilder
+module Zenithal::ZoticaBuilder
 
   DATA_PATH = "resource/math.json"
   COMMON_STYLE_PATH = "resource/style/math.scss"
@@ -36,7 +28,7 @@ module ZoticaBuilder
 
   def apply_options(nodes, options)
     nodes.each do |node|
-      if node.is_a?(Element) && options[:role]
+      if node.is_a?(REXML::Element) && options[:role]
         classes = node["class"].split(" ") - ROLES
         classes << options[:role]
         node["class"] = classes.join(" ")
@@ -62,9 +54,9 @@ module ZoticaBuilder
   end
 
   def build_number(text, options = {})
-    this = Nodes[]
+    this = REXML::Nodes[]
     element = nil
-    this << Element.build("math-n") do |this|
+    this << REXML::Element.build("math-n") do |this|
       this << ~text
       element = this
     end
@@ -84,10 +76,10 @@ module ZoticaBuilder
   end
 
   def build_identifier(text, types, options = {})
-    this = Nodes[]
+    this = REXML::Nodes[]
     element = nil
     font_type = (types.include?("alt")) ? "math" : "main"
-    this << Element.build("math-i") do |this|
+    this << REXML::Element.build("math-i") do |this|
       this["class"] = types.join(" ")
       this["data-cont"] = text
       this << ~text
@@ -104,10 +96,10 @@ module ZoticaBuilder
   end
 
   def build_operator(symbol, types, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     element = nil
     font_type = (types.include?("txt")) ? "main" : "math"
-    this << Element.build("math-o") do |this|
+    this << REXML::Element.build("math-o") do |this|
       this["class"] = types.join(" ")
       this << ~symbol
       element = this
@@ -136,8 +128,8 @@ module ZoticaBuilder
   end
 
   def build_strut(type, options = {})
-    this = Nodes[]
-    this << Element.build("math-strut") do |this|
+    this = REXML::Nodes[]
+    this << REXML::Element.build("math-strut") do |this|
       if type == "upper" || type == "dupper"
         this["style"] += "margin-bottom: -0.5em;"
       elsif type == "dlower" || type == "dfull"
@@ -154,7 +146,7 @@ module ZoticaBuilder
         top_margin = options[:fonts]&.dig(:main, "72", 1) || DEFAULT_FONTS.dig(:main, "72", 1)
         this["style"] += "margin-top: #{top_margin}em;"
       end
-      this << Element.build("math-text") do |this|
+      this << REXML::Element.build("math-text") do |this|
         this["style"] += "line-height: 1;"
         this << ~" "
       end
@@ -164,24 +156,24 @@ module ZoticaBuilder
   end
 
   def build_subsuper(options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     base_element, sub_element, super_element, left_sub_element, left_super_element = nil
     main_element = nil
-    this << Element.build("math-subsup") do |this|
+    this << REXML::Element.build("math-subsup") do |this|
       main_element = this
-      this << Element.build("math-lsub") do |this|
+      this << REXML::Element.build("math-lsub") do |this|
         left_sub_element = this
       end
-      this << Element.build("math-lsup") do |this|
+      this << REXML::Element.build("math-lsup") do |this|
         left_super_element = this
       end
-      this << Element.build("math-base") do |this|
+      this << REXML::Element.build("math-base") do |this|
         base_element = this
       end
-      this << Element.build("math-sub") do |this|
+      this << REXML::Element.build("math-sub") do |this|
         sub_element = this
       end
-      this << Element.build("math-sup") do |this|
+      this << REXML::Element.build("math-sup") do |this|
         super_element = this
       end
     end
@@ -208,19 +200,19 @@ module ZoticaBuilder
   end
 
   def build_underover(options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     base_element, under_element, over_element = nil
     main_element = nil
-    this << Element.build("math-underover") do |this|
+    this << REXML::Element.build("math-underover") do |this|
       main_element = this
-      this << Element.build("math-over") do |this|
+      this << REXML::Element.build("math-over") do |this|
         over_element = this
       end
-      this << Element.build("math-basewrap") do |this|
-        this << Element.build("math-base") do |this|
+      this << REXML::Element.build("math-basewrap") do |this|
+        this << REXML::Element.build("math-base") do |this|
           base_element = this
         end
-        this << Element.build("math-under") do |this|
+        this << REXML::Element.build("math-under") do |this|
           under_element = this
         end
       end
@@ -242,15 +234,15 @@ module ZoticaBuilder
   end
 
   def build_fraction(options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     numerator_element, denominator_element = nil
-    this << Element.build("math-frac") do |this|
-      this << Element.build("math-num") do |this|
+    this << REXML::Element.build("math-frac") do |this|
+      this << REXML::Element.build("math-num") do |this|
         numerator_element = this
       end
-      this << Element.build("math-denwrap") do |this|
-        this << Element.new("math-line")
-        this << Element.build("math-den") do |this|
+      this << REXML::Element.build("math-denwrap") do |this|
+        this << REXML::Element.new("math-line")
+        this << REXML::Element.build("math-den") do |this|
           denominator_element = this
         end
       end
@@ -273,22 +265,22 @@ module ZoticaBuilder
   end
 
   def build_radical(symbol, modify, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     content_element, index_element = nil
-    this << Element.build("math-rad") do |this|
+    this << REXML::Element.build("math-rad") do |this|
       if modify
         this["class"] = "mod" 
       end
-      this << Element.build("math-index") do |this|
+      this << REXML::Element.build("math-index") do |this|
         index_element = this
       end
-      this << Element.build("math-sqrt") do |this|
-        this << Element.build("math-surd") do |this|
-          this << Element.build("math-o") do |this|
-            this << Text.new(symbol, true, nil, false)
+      this << REXML::Element.build("math-sqrt") do |this|
+        this << REXML::Element.build("math-surd") do |this|
+          this << REXML::Element.build("math-o") do |this|
+            this << REXML::Text.new(symbol, true, nil, false)
           end
         end
-        this << Element.build("math-cont") do |this|
+        this << REXML::Element.build("math-cont") do |this|
           content_element = this
         end
       end
@@ -313,26 +305,26 @@ module ZoticaBuilder
   end
 
   def build_fence(left_kind, right_kind, left_symbol, right_symbol, modify, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     content_element = nil
-    this << Element.build("math-fence") do |this|
+    this << REXML::Element.build("math-fence") do |this|
       this["class"] = "par"
       if modify
         this["class"] = [*this["class"].split(" "), "mod"].join(" ")
         this["data-left"] = left_kind
         this["data-right"] = right_kind
       end
-      this << Element.build("math-left") do |this|
-        this << Element.build("math-o") do |this|
-          this << Text.new(left_symbol, true, nil, false)
+      this << REXML::Element.build("math-left") do |this|
+        this << REXML::Element.build("math-o") do |this|
+          this << REXML::Text.new(left_symbol, true, nil, false)
         end
       end
-      this << Element.build("math-cont") do |this|
+      this << REXML::Element.build("math-cont") do |this|
         content_element = this
       end
-      this << Element.build("math-right") do |this|
-        this << Element.build("math-o") do |this|
-          this << Text.new(right_symbol, true, nil, false)
+      this << REXML::Element.build("math-right") do |this|
+        this << REXML::Element.build("math-o") do |this|
+          this << REXML::Text.new(right_symbol, true, nil, false)
         end
       end
     end
@@ -342,9 +334,9 @@ module ZoticaBuilder
   end
 
   def build_set(left_kind, right_kind, center_kind, left_symbol, right_symbol, center_symbol, modify, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     left_element, right_element = nil
-    this << Element.build("math-fence") do |this|
+    this << REXML::Element.build("math-fence") do |this|
       this["class"] = "par"
       if modify
         this["class"] = [*this["class"].split(" "), "mod"].join(" ")
@@ -352,26 +344,26 @@ module ZoticaBuilder
         this["data-right"] = right_kind
         this["data-center"] = center_kind
       end
-      this << Element.build("math-left") do |this|
-        this << Element.build("math-o") do |this|
-          this << Text.new(left_symbol, true, nil, false)
+      this << REXML::Element.build("math-left") do |this|
+        this << REXML::Element.build("math-o") do |this|
+          this << REXML::Text.new(left_symbol, true, nil, false)
         end
       end
-      this << Element.build("math-cont") do |this|
+      this << REXML::Element.build("math-cont") do |this|
         left_element = this
       end
-      this << Element.build("math-center") do |this|
+      this << REXML::Element.build("math-center") do |this|
         this["class"] = "cpar"
-        this << Element.build("math-o") do |this|
-          this << Text.new(right_symbol, true, nil, false)
+        this << REXML::Element.build("math-o") do |this|
+          this << REXML::Text.new(right_symbol, true, nil, false)
         end
       end
-      this << Element.build("math-cont") do |this|
+      this << REXML::Element.build("math-cont") do |this|
         right_element = this
       end
-      this << Element.build("math-right") do |this|
-        this << Element.build("math-o") do |this|
-          this << Text.new(right_symbol, true, nil, false)
+      this << REXML::Element.build("math-right") do |this|
+        this << REXML::Element.build("math-o") do |this|
+          this << REXML::Text.new(right_symbol, true, nil, false)
         end
       end
     end
@@ -387,27 +379,27 @@ module ZoticaBuilder
   end
 
   def build_integral(symbol, size, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     base_element, sub_element, super_element = nil
-    this << Element.build("math-subsup") do |this|
+    this << REXML::Element.build("math-subsup") do |this|
       this["class"] = "int"
       unless size == "lrg"
         this["class"] = [*this["class"].split(" "), size].join(" ")
       end
-      this << Element.build("math-base") do |this|
+      this << REXML::Element.build("math-base") do |this|
         base_element = this
-        this << Element.build("math-o") do |this|
+        this << REXML::Element.build("math-o") do |this|
           this["class"] = "int"
           unless size == "lrg"
             this["class"] = [*this["class"].split(" "), size].join(" ")
           end
-          this << Text.new(symbol, true, nil, false)
+          this << REXML::Text.new(symbol, true, nil, false)
         end
       end
-      this << Element.build("math-sub") do |this|
+      this << REXML::Element.build("math-sub") do |this|
         sub_element = this
       end
-      this << Element.build("math-sup") do |this|
+      this << REXML::Element.build("math-sup") do |this|
         super_element = this
       end
     end
@@ -424,22 +416,22 @@ module ZoticaBuilder
   end
 
   def build_sum(symbol, size, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     if size == "lrg"
       under_element, over_element = nil
-      this << Element.build("math-underover") do |this|
+      this << REXML::Element.build("math-underover") do |this|
         this["class"] = "sum"
-        this << Element.build("math-over") do |this|
+        this << REXML::Element.build("math-over") do |this|
           over_element = this
         end
-        this << Element.build("math-basewrap") do |this|
-          this << Element.build("math-base") do |this|
-            this << Element.build("math-o") do |this|
+        this << REXML::Element.build("math-basewrap") do |this|
+          this << REXML::Element.build("math-base") do |this|
+            this << REXML::Element.build("math-o") do |this|
               this["class"] = "sum"
-              this << Text.new(symbol, true, nil, false)
+              this << REXML::Text.new(symbol, true, nil, false)
             end
           end
-          this << Element.build("math-under") do |this|
+          this << REXML::Element.build("math-under") do |this|
             under_element = this
           end
         end
@@ -449,19 +441,19 @@ module ZoticaBuilder
       modify_underover(under_element, over_element)
     else
       base_element, sub_element, super_element = nil
-      this << Element.build("math-subsup") do |this|
+      this << REXML::Element.build("math-subsup") do |this|
         this["class"] = "sum inl"
-        this << Element.build("math-base") do |this|
+        this << REXML::Element.build("math-base") do |this|
           base_element = this
-          this << Element.build("math-o") do |this|
+          this << REXML::Element.build("math-o") do |this|
             this["class"] = "sum inl"
-            this << Text.new(symbol, true, nil, false)
+            this << REXML::Text.new(symbol, true, nil, false)
           end
         end
-        this << Element.build("math-sub") do |this|
+        this << REXML::Element.build("math-sub") do |this|
           sub_element = this
         end
-        this << Element.build("math-sup") do |this|
+        this << REXML::Element.build("math-sup") do |this|
           super_element = this
         end
       end
@@ -473,31 +465,31 @@ module ZoticaBuilder
   end
 
   def build_accent(under_symbol, over_symbol, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     base_element, under_element, over_element = nil
     main_element = nil
-    this << Element.build("math-underover") do |this|
+    this << REXML::Element.build("math-underover") do |this|
       main_element = this
       this["class"] = "acc"
-      this << Element.build("math-over") do |this|
+      this << REXML::Element.build("math-over") do |this|
         over_element = this
         if over_symbol
-          this << Element.build("math-o") do |this|
+          this << REXML::Element.build("math-o") do |this|
             this["class"] = "acc"
-            this << Text.new(over_symbol, true, nil, false)
+            this << REXML::Text.new(over_symbol, true, nil, false)
           end
         end
       end
-      this << Element.build("math-basewrap") do |this|
-        this << Element.build("math-base") do |this|
+      this << REXML::Element.build("math-basewrap") do |this|
+        this << REXML::Element.build("math-base") do |this|
           base_element = this
         end
-        this << Element.build("math-under") do |this|
+        this << REXML::Element.build("math-under") do |this|
           under_element = this
           if under_symbol
-            this << Element.build("math-o") do |this|
+            this << REXML::Element.build("math-o") do |this|
               this["class"] = "acc"
-              this << Text.new(under_symbol, true, nil, false)
+              this << REXML::Text.new(under_symbol, true, nil, false)
             end
           end
         end
@@ -540,34 +532,34 @@ module ZoticaBuilder
   end
 
   def build_wide(kind, under_symbol, over_symbol, modify, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     base_element, under_element, over_element = nil
     main_element = nil
-    this << Element.build("math-underover") do |this|
+    this << REXML::Element.build("math-underover") do |this|
       this["class"] = "wid"
       if modify
         this["class"] = [*this["class"].split(" "), "mod"].join(" ")
         this["data-kind"] = kind
       end
       main_element = this
-      this << Element.build("math-over") do |this|
+      this << REXML::Element.build("math-over") do |this|
         if over_symbol
-          this << Element.build("math-o") do |this|
+          this << REXML::Element.build("math-o") do |this|
             this["class"] = "wid"
-            this << Text.new(over_symbol, true, nil, false)
+            this << REXML::Text.new(over_symbol, true, nil, false)
           end
         end
         over_element = this
       end
-      this << Element.build("math-basewrap") do |this|
-        this << Element.build("math-base") do |this|
+      this << REXML::Element.build("math-basewrap") do |this|
+        this << REXML::Element.build("math-base") do |this|
           base_element = this
         end
-        this << Element.build("math-under") do |this|
+        this << REXML::Element.build("math-under") do |this|
           if under_symbol
-            this << Element.build("math-o") do |this|
+            this << REXML::Element.build("math-o") do |this|
               this["class"] = "wid"
-              this << Text.new(under_symbol, true, nil, false)
+              this << REXML::Text.new(under_symbol, true, nil, false)
             end
           end
           under_element = this
@@ -582,9 +574,9 @@ module ZoticaBuilder
   end
 
   def build_table(type, align_config, raw, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     table_element = nil
-    this << Element.build("math-table") do |this|
+    this << REXML::Element.build("math-table") do |this|
       this["class"] = type
       table_element = this
     end
@@ -595,9 +587,9 @@ module ZoticaBuilder
   end
 
   def build_diagram(vertical_gaps_string, horizontal_gaps_string, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     table_element = nil
-    this << Element.build("math-diagram") do |this|
+    this << REXML::Element.build("math-diagram") do |this|
       if vertical_gaps_string
         this["class"] = [*this["class"].split(" "), "vnon"].join(" ")
       end
@@ -674,9 +666,9 @@ module ZoticaBuilder
   end
 
   def build_table_cell(options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     cell_element = nil
-    this << Element.build("math-cell") do |this|
+    this << REXML::Element.build("math-cell") do |this|
       cell_element = this
     end
     apply_options(this, options)
@@ -685,13 +677,13 @@ module ZoticaBuilder
   end
 
   def build_diagram_vertex(name, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     vertex_element = nil
-    this << Element.build("math-cellwrap") do |this|
+    this << REXML::Element.build("math-cellwrap") do |this|
       if name
         this["data-name"] = name
       end
-      this << Element.build("math-cell") do |this|
+      this << REXML::Element.build("math-cell") do |this|
         vertex_element = this
       end
     end
@@ -701,9 +693,9 @@ module ZoticaBuilder
   end
 
   def build_arrow(name, configs, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     label_element = nil
-    this << Element.build("math-arrow") do |this|
+    this << REXML::Element.build("math-arrow") do |this|
       this["data-start"] = configs[:start_config]
       this["data-end"] = configs[:end_config]
       if configs[:tip_kinds]
@@ -741,9 +733,9 @@ module ZoticaBuilder
   end
 
   def build_tree(options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     content_element = nil
-    this << Element.build("math-tree") do |this|
+    this << REXML::Element.build("math-tree") do |this|
       content_element = this
     end
     apply_options(this, options)
@@ -764,8 +756,8 @@ module ZoticaBuilder
         left_label_element = child.get_elements("math-sys-llabel").first
         right_label_element = child.get_elements("math-sys-rlabel").first
         antecedent_elements = stack.pop(number)
-        inference_element = Element.build("math-infer") do |this|
-          this << Element.build("math-label") do |this|
+        inference_element = REXML::Element.build("math-infer") do |this|
+          this << REXML::Element.build("math-label") do |this|
             if left_label_element.to_a.empty?
               this["class"] = "non"
             end
@@ -773,22 +765,22 @@ module ZoticaBuilder
               this << each_element
             end
           end
-          this << Element.build("math-step") do |this|
-            this << Element.build("math-ant") do |this|
+          this << REXML::Element.build("math-step") do |this|
+            this << REXML::Element.build("math-ant") do |this|
               antecedent_elements.each do |antecedent_element|
                 this << antecedent_element
               end
             end
-            this << Element.build("math-conwrap") do |this|
-              this << Element.new("math-line")
-              this << Element.build("math-con") do |this|
+            this << REXML::Element.build("math-conwrap") do |this|
+              this << REXML::Element.new("math-line")
+              this << REXML::Element.build("math-con") do |this|
                 this << ZoticaBuilder.build_strut("upper").first
                 this << ZoticaBuilder.build_strut("dlower").first
                 this << child.get_elements("math-cont").first
               end
             end
           end
-          this << Element.build("math-label") do |this|
+          this << REXML::Element.build("math-label") do |this|
             if right_label_element.to_a.empty?
               this["class"] = "non"
             end
@@ -807,9 +799,9 @@ module ZoticaBuilder
   end
 
   def build_tree_axiom(options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     content_element = nil
-    this << Element.build("math-axiom") do |this|
+    this << REXML::Element.build("math-axiom") do |this|
       content_element = this
     end
     apply_options(this, options)
@@ -818,17 +810,17 @@ module ZoticaBuilder
   end
 
   def build_tree_inference(number, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     content_element, right_label_element, left_label_element = nil
-    this << Element.build("math-sys-infer") do |this|
+    this << REXML::Element.build("math-sys-infer") do |this|
       this["data-num"] = number.to_s
-      this << Element.build("math-cont") do |this|
+      this << REXML::Element.build("math-cont") do |this|
         content_element = this
       end
-      this << Element.build("math-sys-rlabel") do |this|
+      this << REXML::Element.build("math-sys-rlabel") do |this|
         right_label_element = this
       end
-      this << Element.build("math-sys-llabel") do |this|
+      this << REXML::Element.build("math-sys-llabel") do |this|
         left_label_element = this
       end
     end
@@ -838,9 +830,9 @@ module ZoticaBuilder
   end
 
   def build_group(transform_configs, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     content_element = nil
-    this << Element.build("math-group") do |this|
+    this << REXML::Element.build("math-group") do |this|
       transforms = []
       if transform_configs[:rotate]
         transforms << "rotate(#{transform_configs[:rotate]}deg)"
@@ -856,8 +848,8 @@ module ZoticaBuilder
   end
 
   def build_space(type, options = {})
-    this = Nodes[]
-    this << Element.build("math-space") do |this|
+    this = REXML::Nodes[]
+    this << REXML::Element.build("math-space") do |this|
       this["class"] = type
     end
     apply_options(this, options)
@@ -865,9 +857,9 @@ module ZoticaBuilder
   end
 
   def build_phantom(type, options = {}, &block)
-    this = Nodes[]
+    this = REXML::Nodes[]
     content_element = nil
-    this << Element.build("math-phantom") do |this|
+    this << REXML::Element.build("math-phantom") do |this|
       this["class"] = ["lpres", "rpres"].join(" ")
       unless type == "bth"
         this["class"] = [*this["class"].split(" "), type].join(" ")
@@ -880,9 +872,9 @@ module ZoticaBuilder
   end
 
   def build_text(text, options = {}, &block)
-    this = Nodes[]
-    this << Element.build("math-text") do |this|
-      this << Text.new(text, true, nil, false)
+    this = REXML::Nodes[]
+    this << REXML::Element.build("math-text") do |this|
+      this << REXML::Text.new(text, true, nil, false)
     end
     apply_options(this, options)
     return this
@@ -901,7 +893,7 @@ module ZoticaBuilder
   def create_script_string
     dir = File.expand_path("../" + SCRIPT_DIR, __FILE__)
     string = "const DATA = "
-    string << JSON.generate(ZoticaBuilder::DATA.slice("radical", "fence", "wide", "shift", "arrow"))
+    string << JSON.generate(Zenithal::ZoticaBuilder::DATA.slice("radical", "fence", "wide", "shift", "arrow"))
     string << ";\n"
     string << File.read(dir + "/main.js")
     string << "\n"
@@ -949,10 +941,10 @@ module ZoticaBuilder
     main_font_path = File.expand_path("../" + DEFAULT_FONT_PATHS[:main], __FILE__)
     math_font_path = File.expand_path("../" + DEFAULT_FONT_PATHS[:math], __FILE__)
     File.open(main_font_path, "w") do |file|
-      file.write(ZoticaBuilder.create_font_string(:main))
+      file.write(Zenithal::ZoticaBuilder.create_font_string(:main))
     end
     File.open(math_font_path, "w") do |file|
-      file.write(ZoticaBuilder.create_font_string(:math))
+      file.write(Zenithal::ZoticaBuilder.create_font_string(:math))
     end
   end
 

data/source/zotica/parser.rb

@@ -1,14 +1,7 @@
 # coding: utf-8
 
 
-require 'pp'
-require 'rexml/document'
-include REXML
-
-
-module ZoticaSingleParserMethod
-
-  DATA = ZoticaBuilder::DATA
+module Zenithal::ZoticaSingleParserMethod
 
   SPACE_ALTERNATIVES = {"sfun" => "afun", "sbin" => "abin", "srel" => "arel", "ssbin" => "asbin", "ssrel" => "asrel", "scas" => "acas", "quad" => "sgl", "qquad" => "dbl"}
   PHANTOM_TYPES = {"ph" => "bth", "vph" => "ver", "hph" => "hor"}
@@ -17,7 +10,7 @@ module ZoticaSingleParserMethod
     if @block
       inner_element = parse_math_root
       raw_nodes = @block.call(@attributes, [inner_element])
-      nodes = raw_nodes.inject(Nodes[], :<<)
+      nodes = raw_nodes.inject(REXML::Nodes[], :<<)
     else
       nodes = parse_math_root
     end
@@ -27,7 +20,7 @@ module ZoticaSingleParserMethod
   private
 
   def create_math_element(name, attributes, children_list, options = {})
-    this = Nodes[]
+    this = REXML::Nodes[]
     options[:role] = determine_role(attributes)
     options[:class] = attributes["class"]
     options[:fonts] = @fonts
@@ -81,7 +74,7 @@ module ZoticaSingleParserMethod
       right_symbol = ZoticaBuilder.fetch_fence_symbol(right_kind, 1, stretch_level)
       modify = !stretch_level
       this << ZoticaBuilder.build_fence(left_kind, right_kind, left_symbol, right_symbol, modify, options) do |content_this|
-        content_this << children_list.fetch(0, Nodes[])
+        content_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "set"
       stretch_level = attributes["s"]
@@ -93,8 +86,8 @@ module ZoticaSingleParserMethod
       center_symbol = ZoticaBuilder.fetch_fence_symbol(center_kind, 0, stretch_level)
       modify = !stretch_level
       this << ZoticaBuilder.build_set(left_kind, right_kind, center_kind, left_symbol, right_symbol, center_symbol, modify, options) do |left_this, right_this|
-        left_this << children_list.fetch(0, Nodes[])
-        right_this << children_list.fetch(1, Nodes[])
+        left_this << children_list.fetch(0, REXML::Nodes[])
+        right_this << children_list.fetch(1, REXML::Nodes[])
       end
     when DATA["fence"].method(:key?)
       stretch_level = attributes["s"]
@@ -102,50 +95,50 @@ module ZoticaSingleParserMethod
       right_symbol = ZoticaBuilder.fetch_fence_symbol(name, 1, stretch_level)
       modify = !stretch_level
       this << ZoticaBuilder.build_fence(name, name, left_symbol, right_symbol, modify, options) do |content_this|
-        content_this << children_list.fetch(0, Nodes[])
+        content_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "intlike"
       kind = attributes["k"] || "int"
       size = (attributes["in"]) ? "inl" : "lrg"
       symbol = ZoticaBuilder.fetch_integral_symbol(kind, size)
       this << ZoticaBuilder.build_integral(symbol, size, options) do |sub_this, super_this|
-        sub_this << children_list.fetch(0, Nodes[])
-        super_this << children_list.fetch(1, Nodes[])
+        sub_this << children_list.fetch(0, REXML::Nodes[])
+        super_this << children_list.fetch(1, REXML::Nodes[])
       end
     when DATA["integral"].method(:key?)
       size = (attributes["in"]) ? "inl" : "lrg"
       symbol = ZoticaBuilder.fetch_integral_symbol(name, size)
       this << ZoticaBuilder.build_integral(symbol, size, options) do |sub_this, super_this|
-        sub_this << children_list.fetch(0, Nodes[])
-        super_this << children_list.fetch(1, Nodes[])
+        sub_this << children_list.fetch(0, REXML::Nodes[])
+        super_this << children_list.fetch(1, REXML::Nodes[])
       end
     when "sumlike"
       kind = attributes["k"] || "sum"
       size = (attributes["in"]) ? "inl" : "lrg"
       symbol = ZoticaBuilder.fetch_sum_symbol(kind, size)
       this << ZoticaBuilder.build_sum(symbol, size, options) do |under_this, over_this|
-        under_this << children_list.fetch(0, Nodes[])
-        over_this << children_list.fetch(1, Nodes[])
+        under_this << children_list.fetch(0, REXML::Nodes[])
+        over_this << children_list.fetch(1, REXML::Nodes[])
       end
     when DATA["sum"].method(:key?)
       size = (attributes["in"]) ? "inl" : "lrg"
       symbol = ZoticaBuilder.fetch_sum_symbol(name, size)
       this << ZoticaBuilder.build_sum(symbol, size, options) do |under_this, over_this|
-        under_this << children_list.fetch(0, Nodes[])
-        over_this << children_list.fetch(1, Nodes[])
+        under_this << children_list.fetch(0, REXML::Nodes[])
+        over_this << children_list.fetch(1, REXML::Nodes[])
       end
     when "accent"
       kind = attributes["k"]
       under_symbol = ZoticaBuilder.fetch_accent_symbol(kind, 0)
       over_symbol = ZoticaBuilder.fetch_accent_symbol(kind, 1)
       this << ZoticaBuilder.build_accent(under_symbol, over_symbol, options) do |base_this|
-        base_this << children_list.fetch(0, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
       end
     when DATA["accent"].method(:key?)
       under_symbol = ZoticaBuilder.fetch_accent_symbol(name, 0)
       over_symbol = ZoticaBuilder.fetch_accent_symbol(name, 1)
       this << ZoticaBuilder.build_accent(under_symbol, over_symbol, options) do |base_this|
-        base_this << children_list.fetch(0, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "wide"
       kind = attributes["k"]
@@ -154,7 +147,7 @@ module ZoticaSingleParserMethod
       over_symbol  = ZoticaBuilder.fetch_wide_symbol(kind, 1, stretch_level)
       modify = !stretch_level
       this << ZoticaBuilder.build_wide(kind, under_symbol, over_symbol, modify, options) do |base_this|
-        base_this << children_list.fetch(0, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
       end
     when DATA["wide"].method(:key?)
       stretch_level = attributes["s"]
@@ -162,98 +155,98 @@ module ZoticaSingleParserMethod
       over_symbol  = ZoticaBuilder.fetch_wide_symbol(name, 1, stretch_level)
       modify = !stretch_level
       this << ZoticaBuilder.build_wide(name, under_symbol, over_symbol, modify, options) do |base_this|
-        base_this << children_list.fetch(0, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "multi"
       this << ZoticaBuilder.build_subsuper(options) do |base_this, sub_this, super_this, left_sub_this, left_super_this|
-        base_this << children_list.fetch(0, Nodes[])
-        sub_this << children_list.fetch(1, Nodes[])
-        super_this << children_list.fetch(2, Nodes[])
-        left_sub_this << children_list.fetch(3, Nodes[])
-        left_super_this << children_list.fetch(4, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
+        sub_this << children_list.fetch(1, REXML::Nodes[])
+        super_this << children_list.fetch(2, REXML::Nodes[])
+        left_sub_this << children_list.fetch(3, REXML::Nodes[])
+        left_super_this << children_list.fetch(4, REXML::Nodes[])
       end
     when "sb"
       this << ZoticaBuilder.build_subsuper(options) do |base_this, sub_this, super_this, left_sub_element, left_super_element|
-        base_this << children_list.fetch(0, Nodes[])
-        sub_this << children_list.fetch(1, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
+        sub_this << children_list.fetch(1, REXML::Nodes[])
       end
     when "sp"
       this << ZoticaBuilder.build_subsuper(options) do |base_this, sub_this, super_this, left_sub_element, left_super_element|
-        base_this << children_list.fetch(0, Nodes[])
-        super_this << children_list.fetch(1, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
+        super_this << children_list.fetch(1, REXML::Nodes[])
       end
     when "sbsp"
       this << ZoticaBuilder.build_subsuper(options) do |base_this, sub_this, super_this, left_sub_element, left_super_element|
-        base_this << children_list.fetch(0, Nodes[])
-        sub_this << children_list.fetch(1, Nodes[])
-        super_this << children_list.fetch(2, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
+        sub_this << children_list.fetch(1, REXML::Nodes[])
+        super_this << children_list.fetch(2, REXML::Nodes[])
       end
     when "unov"
       this << ZoticaBuilder.build_underover(options) do |base_this, under_this, over_this|
-        base_this << children_list.fetch(0, Nodes[])
-        under_this << children_list.fetch(1, Nodes[])
-        over_this << children_list.fetch(2, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
+        under_this << children_list.fetch(1, REXML::Nodes[])
+        over_this << children_list.fetch(2, REXML::Nodes[])
       end
     when "un"
       this << ZoticaBuilder.build_underover(options) do |base_this, under_this, over_this|
-        base_this << children_list.fetch(0, Nodes[])
-        under_this << children_list.fetch(1, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
+        under_this << children_list.fetch(1, REXML::Nodes[])
       end
     when "ov"
       this << ZoticaBuilder.build_underover(options) do |base_this, under_this, over_this|
-        base_this << children_list.fetch(0, Nodes[])
-        over_this << children_list.fetch(1, Nodes[])
+        base_this << children_list.fetch(0, REXML::Nodes[])
+        over_this << children_list.fetch(1, REXML::Nodes[])
       end
     when "frac"
       this << ZoticaBuilder.build_fraction(options) do |numerator_this, denominator_this|
-        numerator_this << children_list.fetch(0, Nodes[])
-        denominator_this << children_list.fetch(1, Nodes[])
+        numerator_this << children_list.fetch(0, REXML::Nodes[])
+        denominator_this << children_list.fetch(1, REXML::Nodes[])
       end
     when "sqrt"
       stretch_level = attributes["s"]
       symbol = ZoticaBuilder.fetch_radical_symbol(stretch_level)
       modify = !stretch_level
       this << ZoticaBuilder.build_radical(symbol, modify, options) do |content_this, index_this|
-        content_this << children_list.fetch(0, Nodes[])
-        index_this << children_list.fetch(1, Nodes[])
+        content_this << children_list.fetch(0, REXML::Nodes[])
+        index_this << children_list.fetch(1, REXML::Nodes[])
       end
     when "table"
       type = attributes["t"]
       align_config = attributes["align"]
       raw = !!attributes["raw"]
       this << ZoticaBuilder.build_table(type, align_config, raw, options) do |table_this|
-        table_this << children_list.fetch(0, Nodes[])
+        table_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "array"
       align_config = attributes["align"]
       this << ZoticaBuilder.build_table("std", align_config, true, options) do |table_this|
-        table_this << children_list.fetch(0, Nodes[])
+        table_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "stack"
       this << ZoticaBuilder.build_table("stk", nil, true, options) do |table_this|
-        table_this << children_list.fetch(0, Nodes[])
+        table_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "matrix"
       this << ZoticaBuilder.build_table("mat", nil, false, options) do |table_this|
-        table_this << children_list.fetch(0, Nodes[])
+        table_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "case"
       left_symbol = ZoticaBuilder.fetch_fence_symbol("brace", 0, nil)
       right_symbol = ZoticaBuilder.fetch_fence_symbol("none", 1, nil)
       this << ZoticaBuilder.build_fence("brace", "none", left_symbol, right_symbol, true, options) do |this|
         this << ZoticaBuilder.build_table("cas", "ll", false) do |table_this|
-          table_this << children_list.fetch(0, Nodes[])
+          table_this << children_list.fetch(0, REXML::Nodes[])
         end
       end
     when "diag"
       vertical_gaps_string = attributes["ver"]
       horizontal_gaps_string = attributes["hor"]
       this << ZoticaBuilder.build_diagram(vertical_gaps_string, horizontal_gaps_string, options) do |table_this|
-        table_this << children_list.fetch(0, Nodes[])
+        table_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "c"
       this << ZoticaBuilder.build_table_cell(options) do |cell_this|
-        cell_this << children_list.fetch(0, Nodes[])
+        cell_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "cc"
       children_list.each do |children|
@@ -261,11 +254,11 @@ module ZoticaSingleParserMethod
           cell_this << children
         end
       end
-      this << Element.new("math-sys-br")
+      this << REXML::Element.new("math-sys-br")
     when "v"
       vertex_name = attributes["name"]
       this << ZoticaBuilder.build_diagram_vertex(vertex_name, options) do |vertex_this|
-        vertex_this << children_list.fetch(0, Nodes[])
+        vertex_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "vv"
       children_list.each do |children|
@@ -273,7 +266,7 @@ module ZoticaSingleParserMethod
           vertex_this << children
         end
       end
-      this << Element.new("math-sys-br")
+      this << REXML::Element.new("math-sys-br")
     when "ar"
       configs = {}
       configs[:start_config] = attributes["s"]
@@ -288,35 +281,35 @@ module ZoticaSingleParserMethod
       configs[:mark] = attributes["mark"]
       arrow_name = attributes["name"]
       this << ZoticaBuilder.build_arrow(arrow_name, configs, options) do |label_this|
-        label_this << children_list.fetch(0, Nodes[])
+        label_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "tree"
       this << ZoticaBuilder.build_tree(options) do |content_this|
-        content_this << children_list.fetch(0, Nodes[])
+        content_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "axm"
       this << ZoticaBuilder.build_tree_axiom(options) do |content_this|
-        content_this << children_list.fetch(0, Nodes[])
+        content_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "infr"
       number = attributes["n"].to_i
       this << ZoticaBuilder.build_tree_inference(number, options) do |content_this, right_label_this, left_label_this|
-        content_this << children_list.fetch(0, Nodes[])
-        right_label_this << children_list.fetch(1, Nodes[])
-        left_label_this << children_list.fetch(2, Nodes[])
+        content_this << children_list.fetch(0, REXML::Nodes[])
+        right_label_this << children_list.fetch(1, REXML::Nodes[])
+        left_label_this << children_list.fetch(2, REXML::Nodes[])
       end
     when "br"
-      this << Element.new("math-sys-br")
+      this << REXML::Element.new("math-sys-br")
     when "g"
       transform_configs = {}
       transform_configs[:rotate] = attributes["rotate"]
       this << ZoticaBuilder.build_group(transform_configs, options) do |content_this|
-        content_this << children_list.fetch(0, Nodes[])
+        content_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "ph", "vph", "hph"
       type = PHANTOM_TYPES[name] || attributes["t"] || "bth"
       this << ZoticaBuilder.build_phantom(type, options) do |content_this|
-        content_this << children_list.fetch(0, Nodes[])
+        content_this << children_list.fetch(0, REXML::Nodes[])
       end
     when "s"
       type = attributes["t"] || "medium"
@@ -325,18 +318,18 @@ module ZoticaSingleParserMethod
       type = SPACE_ALTERNATIVES[name]
       this << ZoticaBuilder.build_space(type, options)
     else
-      this << Element.build(name) do |this|
+      this << REXML::Element.build(name) do |this|
         attributes.each do |key, value|
           this[key] = value
         end
-        this << children_list.fetch(0, Nodes[])
+        this << children_list.fetch(0, REXML::Nodes[])
       end
     end
     return this
   end
 
   def create_math_text(text, options = {})
-    this = Nodes[]
+    this = REXML::Nodes[]
     options[:fonts] = @fonts
     text.each_char do |char|
       if char =~ /\p{Number}/
@@ -367,7 +360,7 @@ module ZoticaSingleParserMethod
   end
 
   def parse_math_root
-    element = Element.new("math-root")
+    element = REXML::Element.new("math-root")
     children = parse_nodes({})
     if @exact
       parse_eof
@@ -427,12 +420,17 @@ module ZoticaSingleParserMethod
     return escape
   end
 
+  ZoticaBuilder = Zenithal::ZoticaBuilder
+
+  DATA = ZoticaBuilder::DATA
+  DEFAULT_FONTS = ZoticaBuilder::DEFAULT_FONTS
+
 end
 
 
-class ZoticaSingleParser < ZenithalParser
+class Zenithal::ZoticaSingleParser < Zenithal::ZenithalParser
 
-  include ZoticaSingleParserMethod
+  include Zenithal::ZoticaSingleParserMethod
 
   attr_accessor :exact
   attr_accessor :fonts
@@ -459,7 +457,7 @@ class ZoticaSingleParser < ZenithalParser
 end
 
 
-class ZoticaParser < ZenithalParser
+class Zenithal::ZoticaParser < Zenithal::ZenithalParser
 
   def initialize(source)
     super(source)
@@ -477,7 +475,7 @@ class ZoticaParser < ZenithalParser
   def register_math_macro(name, &block)
     outer_self = self
     register_plugin(name) do |attributes|
-      parser = ZoticaSingleParser.new(@source)
+      parser = Zenithal::ZoticaSingleParser.new(@source)
       @raw_macro_names.each do |raw_macro_name|
         parser.register_plugin(raw_macro_name) do |_|
           raw_parser = outer_self.clone
@@ -522,14 +520,14 @@ class ZoticaParser < ZenithalParser
 
   def register_resource_macro(name)
     register_macro(name) do |attributes, children_list|
-      style_string = ZoticaBuilder.create_style_string(attributes["font-url"])
-      script_string = ZoticaBuilder.create_script_string
-      nodes = Nodes[]
-      nodes << Element.build("style") do |element|
-        element << Text.new(style_string, true, nil, true)
-      end
-      nodes << Element.build("script") do |element|
-        element << CData.new(script_string)
+      style_string = Zenithal::ZoticaBuilder.create_style_string(attributes["font-url"])
+      script_string = Zenithal::ZoticaBuilder.create_script_string
+      nodes = REXML::Nodes[]
+      nodes << REXML::Element.build("style") do |element|
+        element << REXML::Text.new(style_string, true, nil, true)
+      end
+      nodes << REXML::Element.build("script") do |element|
+        element << REXML::CData.new(script_string)
       end
       next nodes
     end

data/source/zotica/resource/style/math.scss

@@ -589,6 +589,12 @@ math-space {
     }
   }
 
+  @each $name, $margin in $margins {
+    &.m#{$name} {
+      margin-left: spacing(-$margin) !important;
+    }
+  }
+
 }
 
 

data/source/zotica.rb

@@ -1,14 +1,19 @@
 # coding: utf-8
 
 
-require 'zenml'
+module Zenithal
 
+  ZOTICA_VERSION = "1.0.1"
+  ZOTICA_VERSION_ARRAY = VERSION.split(/\./).map(&:to_i)
 
-module Zenithal
+end
 
-  ZOTICA_VERSION = "1.0.0"
 
-  require_relative 'zotica/builder'
-  require_relative 'zotica/parser'
+require 'json'
+require 'rexml/document'
+require 'sassc'
+require 'ttfunk'
+require 'zenml'
 
-end
+require_relative 'zotica/builder'
+require_relative 'zotica/parser'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zotica
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Ziphil
 autorequire: 
 bindir: exec
 cert_chain: []
-date: 2020-02-07 00:00:00.000000000 Z
+date: 2020-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zenml