posxml_parser 1.3.1 → 2.0.0

data/lib/posxml_compiler/variable_limit_error.rb

@@ -0,0 +1,5 @@
+module PosxmlCompiler
+  class VariableLimitError < PosxmlCompilerError
+  end
+end
+

data/lib/posxml_compiler/variable_name_error.rb

@@ -0,0 +1,5 @@
+module PosxmlCompiler
+  class VariableNameError < PosxmlCompilerError
+  end
+end
+

data/lib/posxml_compiler/variable_string_limit_error.rb

@@ -0,0 +1,5 @@
+module PosxmlCompiler
+  class VariableStringLimitError < PosxmlCompilerError
+  end
+end
+

data/lib/posxml_compiler/variable_type_error.rb

@@ -0,0 +1,5 @@
+module PosxmlCompiler
+  class VariableTypeError < PosxmlCompilerError
+  end
+end
+

data/lib/posxml_compiler/variable_undefined_error.rb

@@ -0,0 +1,5 @@
+module PosxmlCompiler
+  class VariableUndefinedError < PosxmlCompilerError
+  end
+end
+

data/lib/posxml_compiler/xsd_parser.rb

@@ -0,0 +1,161 @@
+module PosxmlCompiler
+  class XsdParser
+    DELIMITER_END_INSTRUCTION = "\r"
+    DELIMITER_END_PARAMETER   = "\n"
+
+    attr_accessor :text, :instructions
+
+    def initialize(text)
+      @text = text
+      index_start = text.index("<xs:group name=\"comandos\">")
+      index_end = text.index("<\/xs:group>")
+      groups = text[index_start..index_end] # select only group text
+
+      complex = text[index_end..-1] # select only complex text
+
+      commands = parse_bytecodes(groups)
+      @instructions = parse_parameters(commands, complex)
+      # => {"if" => {:bytecode => "I", :order => ["variable", "operator", "value"], :parameters => {"variable" => :string_or_integer, "operator" => :string, "value" => :string_or_integer}}
+    end
+
+    def valid?
+      !! @instructions
+    end
+
+    def parameter_type(instruction, parameter)
+      self.instructions[instruction][:parameters][parameter.to_s]
+    end
+
+    # Receive:
+    #   ("if", {"variable" => {:original => "$(sKeyTouchScreen)", :value => "$(1)", :type => :string}, "operator" => {:original => "equalto", :value => "equalto", :type => :string}, "value" => {:original => "KEY_CLEAR", :value => "KEY_CLEAR", :type => :string})
+    # Return:
+    #   "I$(1)\nequalto\nKEY_CLEAR"
+    def to_bytecode(name, parameters)
+      instruction = self.find(name) # => {:bytecode => "I", :order => ["variable", "operator", "value"], :parameters => {"variable" => :string_or_integer, "operator" => :string, "value" => :string_or_integer}
+      raise InstructionNotFoundError.new("Instruction #{name.inspect} not found") unless instruction
+
+      line = instruction[:order].collect { |param| parameters[param][:value] || parameters[param][:value]}
+
+      if line.empty?
+        instruction[:bytecode].chr + DELIMITER_END_INSTRUCTION
+      else
+        instruction[:bytecode].chr + line.join(DELIMITER_END_PARAMETER) + DELIMITER_END_PARAMETER + DELIMITER_END_INSTRUCTION
+      end
+    end
+
+    def find(name)
+      self.instructions[name] # => {:bytecode => "I", :order => ["variable", "operator", "value"], :parameters => {"variable" => :string_or_integer, "operator" => :string, "value" => :string_or_integer}
+    end
+
+    private
+    def string2byte(str)
+      value = str.gsub(";", "").gsub("true", "").gsub("false", "")
+      if value == "\\x0B"
+        "\x0B"
+      elsif value.include?("\\x")
+        value.sub("\\x", "").to_i(16).chr
+      elsif value == "&gt"
+        ">"
+      elsif value == "&lt"
+        "<"
+      else
+        value
+      end
+    end
+
+    # Will return a hash with instruction name and bytecode in array
+    #   {
+    #     "if" => {:bytecode => "I", :order => ["variable", "operator", "value"]},
+    #     "/if" => {:bytecode => "E"}
+    #   }
+    #
+    def parse_bytecodes(str)
+      last, end_element = nil
+      str.split("\n").inject({}) do |hash, str|
+        key = str.match(/<xs:element name="(.*)" type="/)
+        if key
+          last = key[1]
+          hash[last] ||= {:order => []}
+          end_element = false
+        end
+
+        value = str.match(/<xs:appinfo>(.*)<\/xs:appinfo>/)
+        value = value[1] if value
+
+        if value
+          if end_element
+            hash["/" + last] = {:order => [], :bytecode => string2byte(value)}
+          elsif ! value.include?(";")
+            hash[last][:order] = value.split(",")
+          else
+            end_element = true
+            hash[last][:bytecode] = string2byte(value)
+          end
+        end
+        hash
+      end
+    end
+
+    # With commands generate by parse_bytecodes:
+    #   {"if" => ["I"], "/if" => ["E"]}
+    #   {
+    #     "if" => {:bytecode => "I", :order => ["variable", "operator", "value"]},
+    #     "/if" => {:bytecode => "E"}
+    #   }
+    #
+    #
+    # this method parse parameters and types:
+    #   {
+    #     "if" => {
+    #       :bytecode => "I",
+    #       :order => ["variable", "operator", "value"],
+    #       :parameters => {"variable" => :string_or_integer, "operator" => :string, "value" => :string_or_integer}
+    #     },
+    #     "/if" => {:bytecode => "E"}
+    #   }
+    def parse_parameters(bytecodes, str)
+      commands = bytecodes.dup
+      last_byte  = nil
+      last_param = nil
+      str.split("\n").each do |str|
+        key = str.match(/<xs:complexType name="(.*)">/)
+        last_byte = key[1] if key
+
+        value = str.match(/<xs:attribute name="(.*)" type/)
+        last_param = value[1] if value
+
+        value = check_type(str)
+        if value && last_byte
+          commands[last_byte][:parameters] ||= {}
+          commands[last_byte][:parameters][last_param]    = value
+        end
+      end
+      commands
+    end
+
+    def check_type(str)
+      if str.include? "<xs:documentation>"
+        if type_string_or_integer?(str)
+          :string_or_integer
+        elsif type_integer?(str)
+          :integer
+        else
+          :string
+        end
+      end
+    end
+
+    def type_string_or_integer?(str)
+      str.match(/(string ou inteiro|string or integer)/)
+    end
+
+    #def type_string?(str)
+      #data = str.match(/(string)/)
+    #end
+
+    def type_integer?(str)
+      data = str.match(/(integer|inteiro)/)
+    end
+  end
+end
+

data/lib/posxml_parser/version.rb

@@ -1,5 +1,5 @@
 
 module PosxmlParser
-  VERSION = "1.3.1"
+  VERSION = "2.0.0"
 end
 

data/posxml_parser.gemspec

@@ -14,6 +14,8 @@ Gem::Specification.new do |gem|
   gem.license       = "MIT"
 
   gem.files         = %w(.gitignore Gemfile Gemfile.lock README.md RELEASE_NOTES.md Rakefile posxml_parser.gemspec lib/posxml_parser/version.rb out/posxml_parser/main.mrb)
+  gem.files        << "lib/posxml_compiler.rb"
+  gem.files        << Dir["./lib/posxml_compiler/*.rb"]
   gem.executables   = []
   gem.test_files    = gem.files.grep(%r{^(test)/})
   gem.require_paths = ["lib"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: posxml_parser
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.0.0
 platform: ruby
 authors:
 - CloudWalk Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-15 00:00:00.000000000 Z
+date: 2018-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -59,12 +59,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- "./lib/posxml_compiler/en_xsd.rb"
+- "./lib/posxml_compiler/function.rb"
+- "./lib/posxml_compiler/instruction_not_found_error.rb"
+- "./lib/posxml_compiler/jump.rb"
+- "./lib/posxml_compiler/jump_point.rb"
+- "./lib/posxml_compiler/parser.rb"
+- "./lib/posxml_compiler/posxml_compiler_error.rb"
+- "./lib/posxml_compiler/string_size_error.rb"
+- "./lib/posxml_compiler/variable.rb"
+- "./lib/posxml_compiler/variable_limit_error.rb"
+- "./lib/posxml_compiler/variable_name_error.rb"
+- "./lib/posxml_compiler/variable_string_limit_error.rb"
+- "./lib/posxml_compiler/variable_type_error.rb"
+- "./lib/posxml_compiler/variable_undefined_error.rb"
+- "./lib/posxml_compiler/xsd_parser.rb"
 - ".gitignore"
 - Gemfile
 - Gemfile.lock
 - README.md
 - RELEASE_NOTES.md
 - Rakefile
+- lib/posxml_compiler.rb
 - lib/posxml_parser/version.rb
 - out/posxml_parser/main.mrb
 - posxml_parser.gemspec