scheme_parser 0.1.99

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d1c253509ba415213a2964fca1d0e8b1ffd15013
+  data.tar.gz: a7245eba36867d0676dc1c718a201b93369d5904
+SHA512:
+  metadata.gz: '086e8be2e128d97afb198d9a1483c8e66ae4f0346519849523ae7125c3f11baec56c2c0b9140954e2f0b33f08bbfffccc6e8e3dccb7d8cac477f7c0d965440d2'
+  data.tar.gz: 36814471e1926dac2a2bcf79c8dde1e0497332c30124a0484902365e9bb1071e7fbf3e87a7887965de8d2e7aeda8ce337981163b1aa79d5339ef43c5c2622042

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+*~
+*.sw*

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rvmrc

@@ -0,0 +1,53 @@
+#!/bin/bash -l
+
+set -x
+gemruby=$(cat Gemfile|grep ^ruby)
+if [[ "$gemruby" == *engine* ]]; then
+   ruby_type=$(echo "$gemruby"|sed "s/.*engine[: ][^\"']\+.\([^\"']\+\).*/\1/")
+   ruby_version=$(echo "$gemruby"|sed "s/.*engine_version[: ][^\"']\+.\([^\"']\+\).*/\1/")
+fi
+
+if [ -z "$ruby_version" -o -z "$ruby_type" ]; then
+   set -
+   info=$(rvm info)
+   set -x
+   ruby_type=$(echo "$info"|grep "^  ruby:" -A 6|grep " interpreter"|sed "s/[^\"]*\"\([^\"]*\)\"/\1/")
+
+   ruby_version=$(echo "$info"|grep "^  ruby:" -A 6|grep " version"|sed "s/[^\"]*\"\([^\"]*\)\"/\1/")
+   if [ -z "$ruby_version" ]; then
+      ruby_path=$(echo "$info"|grep "^  homes:" -A 2|grep " ruby:"|sed "s/[^\"]*\"\([^\"]*\)\"/\1/")
+      ruby_type=$(basename "$ruby_path"|sed "s/^\([^\[]\+\)-.*/\1/")
+      ruby_version=$(basename "$ruby_path"|sed "s/.*-\([^\[]\+\)/\1/")
+   fi
+fi
+
+ruby_gemset=$(basename $(pwd))
+if [ "$ruby_version" = 'not set' ]; then
+   # selecting first ruby
+   set -
+   list=$(rvm list)
+   set -x
+   ruby_type=$(echo "$list"|grep rubies -A 2|grep "\[.*\]"|sed "s/.* \([^\[]\+\)-.*/\1/")
+   ruby_version=$(echo "$list"|grep rubies -A 2|grep "\[.*\]"|sed "s/.*-\([^\[]\+\)\[.*/\1/")
+fi
+
+if [ -z "$(cat ~/.rvm/config/known_strings|grep ${ruby_type}-$ruby_version)" ]; then
+   echo ${ruby_type}-$ruby_version >> ~/.rvm/config/known_strings
+fi
+echo will use ${ruby_type}-$ruby_version@$ruby_gemset with create flag
+set -
+rvm use ${ruby_type}-$ruby_version@$ruby_gemset --create
+
+set -x
+if [ -z "$(echo "$PATH"|grep "$(pwd)/.bundle/bin")" ]; then
+   if [ -z "$_ORIGINAL_GEM_PATH" ]; then
+      export _ORIGINAL_GEM_PATH=$GEM_PATH
+   fi
+   export PATH=$(pwd)/bin:$(pwd)/.bundle/bin:$PATH
+   export GEM_HOME=$(pwd)/.bundle
+   export GEM_PATH=$GEM_HOME:$GEM_PATH
+   bundler=$(gem which bundler)
+   export RUBYLIB=$(dirname $bundler)
+fi
+set -
+

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.12.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at majioa@yandex.ru. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xparser.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Malo Skrylevo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# XParser
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/x_parser`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'x_parser'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install x_parser
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/x_parser. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "xparser"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/scheme/parser.rb

@@ -0,0 +1,13 @@
+require "scheme/parser/version"
+require "scheme/parser/methods"
+require "scheme/parser/base"
+
+module Scheme::Parser
+   class << self
+      def included kls
+         kls.extend Scheme::Parser::Base
+         kls.extend Scheme::Parser::Methods
+      end
+   end
+end
+

data/lib/scheme/parser/base.rb

@@ -0,0 +1,445 @@
+require 'scheme/parser/version'
+
+require 'nokogiri'
+
+module Scheme::Parser::Base
+   class ParameterError < StandardError;end
+
+   attr_reader :errors, :this
+
+   Struct.new('Value', :text)
+
+   def import xml
+      model_attrs = parse(xml)
+      #name = File.basename(attrs.keys.first, '_attributes')
+      #model = name.singularize.camelize.constantize
+      #model_attrs = attrs.values.first
+
+      model = self
+      key = current_options[:key].to_s || 'id'
+
+      if model_attrs[key]
+         if instance = model.where(key => model_attrs[key]).first
+            instance.update!(model_attrs)
+         else
+            instance = model.new(model_attrs)
+            instance.save!
+         end
+#         binding.pry
+#         model_attrs.each do |name, value|
+#            if value.is_a?(Array)
+#               _update_array(name, value)
+#            end
+#         end
+
+#         binding.pry
+      end
+#   rescue => e
+#      err_text = "Failed to import record #{name} with messages '#{e.message}'"
+#      if instance && !(errs = show_errors(instance.errors)).empty?
+#         err_text += " and #{errs}"
+#      end
+#      err_text += " at #{e.backtrace.first}"
+#
+#      Rails.logger.error(err_text)
+#      error "", err_text
+   end
+
+   def parse xml
+      clean_errors
+      filtered = xml.is_a?(String) && xml.gsub(/[\r\u{feff}]/,"") || xml
+      doc = filtered.kind_of?(Nokogiri::XML::Element) && filtered || Nokogiri::XML.parse(filtered)
+      @this = {}
+      attrs = each_field_for(self.schemes[nil], doc)
+      #binding.pry
+      raise ParameterError if errors.present?
+      attrs
+   end
+
+#      def _update_array name, array
+#        array.each do |value|
+#          if value['id']
+#            name = File.basename(name, '_attributes')
+#            m = name.singularize.camelize.constantize
+#            i = m.where(id: value['id']).first
+#            binding.pry
+#            i.update!(value)
+#          end
+#        end
+#
+#        array.delete_if { |value | value['id'] }
+#      end
+#
+   def import_attrs attrs
+   end
+
+   protected
+
+   def clean_errors
+      @errors = {}
+   end
+
+   def show_errors errors
+      errors.messages.map do |field, msgs|
+         msgs.map do |msg|
+         "#{field} #{msg}"
+         end
+      end.flatten.join(", ")
+   end
+
+   def touch_file file
+      if file =~ /\.zip$/i
+         Dir.mktmpdir do |dir|
+            unzip(dir, file).each do |xml|
+               Rails.logger.info("Xml file to proceed #{xml}")
+
+               yield(IO.read(xml))
+            end
+         end
+      else
+         yield(IO.read(file))
+      end
+   end
+
+   def unzip dir, file
+      if defined?(Zip)
+         Zip::File.open(file) do |zip_file|
+            zip_file.map do |entry|
+               tname = File.join(dir, file, entry.name)
+               FileUtils.mkdir_p(File.dirname(tname))
+               entry.extract(tname)
+               tname
+            end
+         end
+      end
+   end
+
+   def each_field_for schema, xml_context
+      schema.map do |name, options|
+         next unless name # skip settings
+
+         v = type_value(name, options, xml_context)
+
+         real_name = options[:multiple] && name.pluralize || name
+         is_assign = [Array, Hash].any? { |x| x === v }
+         key = is_assign && "#{real_name}_attributes" || real_name
+
+         if handler = handler_for(options[:if])
+            v = handler[v]
+         end
+
+         @this[name] ||= []
+         @this[name] << v
+
+         [ key, v ]
+      end.compact.select {|_, v| !v.nil? }.to_h
+   end
+
+   def type_value name, options, xml_context
+      value = case options[:type]
+      when :field
+         v = select_value(name, xml_context, options[:contexts], options).first
+         v = ! v.respond_to?(:text) && v || v.text
+         v = v.respond_to?(:strip) && v.strip || v
+         v.present? && v || nil
+
+      when :scheme
+         scheme_value(name, options, xml_context)
+
+      when :reference
+         reference_value(name, options, xml_context)
+      end
+
+      if options[:on_complete]
+         value = handled_value(options[:on_complete], value, name, xml_context, options).text
+      end
+
+      if options[:required] && value.nil?
+         error(name, "field is required")
+      end
+
+      ### apply method defined by :map to the value
+      if value && options[:map]
+         value = value.send(options[:map].to_s)
+      end
+
+      value
+   end
+
+   def is_update_required(name, xml_context, options, object)
+      base = object.send(options[:update_field])
+      inx, inc = find_new_contexts(name, xml_context, options)
+      o = select_value(options[:update], inx, this_contexts(inc), options).first
+
+      base < Time.parse(o.text)
+   end
+
+   def attributes_update name, options, xml_context
+      if options[:update] && options[:update_field] &&
+            ref = reference_value(name, options, xml_context)
+         if is_update_required(name, xml_context, options, ref)
+            { "id" => ref.id }
+         else
+            nil
+         end
+      elsif ref = reference_value(name, options, xml_context)
+#         binding.pry if name =~ /lot/
+         if ref.is_a?(Array)
+            ref.map { |r| { "id" => r.id } }
+         else
+            { "id" => ref.id }
+         end
+      else
+         {}
+      end
+   end
+
+   def scheme_value name, options, xml_context
+      if attrs = attributes_update(name, options, xml_context)
+#         binding.pry if name.to_s =~ /lot_apps/
+
+         value, i = select_value(name, xml_context, options[:contexts], options)
+#         binding.pry if name =~ /lot/
+         if value.text.present?
+            as = options[:contexts][i][:scheme] || options[:as] || name
+#            binding.pry if name.to_s =~ /lot_item/
+            scheme_name = self.scheme_name(as)
+            vvv = 
+            if options[:multiple]
+
+               if attrs.is_a?(Array)
+                  values = [ value, attrs ].transpose
+                  values.map do |(v, attr)|
+#                     binding.pry
+                     each_field_for(self.schemes[scheme_name], v).merge(attr)
+                  end
+               else
+                  value.map { |v| each_field_for(self.schemes[scheme_name], v) }
+               end
+            else
+               each_field_for(self.schemes[scheme_name], value).merge(attrs)
+            end
+#               binding.pry if name =~ /lots?/
+               vvv
+         end
+      end
+   end
+
+   def find_new_contexts name, xml_context, options
+      new_contexts = self.filter_hashes(options[:contexts],
+         Scheme::Parser::Methods::PURE_CONTEXT_KEYS)
+      inx, index = select_value(name, xml_context, new_contexts, options)
+
+      if inx.text
+         inc = options[:contexts][index]
+      end
+
+      [inx, inc]
+   end
+
+   def reference_value name, options, xml_context
+      inx, inc = find_new_contexts(name, xml_context, options)
+
+      if inc && inc[:by]
+         begin
+            value, = select_value(inc[:by], inx, this_contexts(inc), options)
+         rescue NoMethodError
+            error(name, "field error for '#{inc[:by]}' in context: #{inx.inspect}")
+         end
+
+         model = model_for(name, options)
+
+         if field = inc[:field] || inc[:by]
+#            binding.pry
+            if options[:multiple] && value.respond_to?(:size)
+               rela = model.where(field => value.map(&:text))
+            else
+               rela = model.where(field => value.text)
+            end
+         end
+
+#         binding.pry if name.to_s =~ /placing_method/
+         if rela.empty? && field = inc[:re_field]
+            begin
+               rela = model.where("? ~* #{field}", value.text).order(code: :desc)
+            rescue Java::JavaLang::NoSuchMethodError
+               error(name, "reference is unavailable to find out via referenced field" +
+                  " '#{field}' with data: #{value.text}")
+               []
+            end
+         end
+
+#         binding.pry if name =~ /lot/
+         if options[:multiple]
+            rela_a = rela.empty? && [nil] || rela
+            value =
+            rela_a.map do |rela_v|
+               if inc[:on_found]
+                  handled_value(inc[:on_found], rela_v, name, xml_context, options).text
+               else
+                  rela_v
+               end
+            end
+         else
+            value = rela.first
+            if inc[:on_found]
+               value = handled_value(inc[:on_found], value, name, xml_context, options).text
+            end
+         end
+
+         this['relations'] ||= {}
+         this['relations'][name] ||= []
+         this['relations'][name] << value
+
+#         binding.pry if name =~ /lot/
+         value
+      end
+   end
+
+   def error name, error
+#      binding.pry
+      @errors ||= {}
+      @errors[name] ||= []
+      @errors[name] << error
+
+      nil
+   end
+
+   def this_contexts in_context = {}
+      [ in_context.merge({context: [""], from: nil}) ]
+   end
+
+   def model_for name, options
+      (options[:as] || name).to_s.singularize.camelize.constantize
+   end
+
+   def search_in xml_context, path, options
+      # TODO since nokogiri 1.8.2 dones not understand namespaces in attribute names
+      # we shold crop it from path, and traverse manually
+      res = xml_context.xpath(path)
+
+      options[:multiple] && res || res.first
+   rescue Nokogiri::XML::XPath::SyntaxError => e
+      err_text = "Failed to navigate path with messages '#{e.message}'"
+      error path, err_text
+      Rails.logger.error(err_text)
+      nil
+   end
+
+   # +select_value+ выборка общего обработчика контекста для заданного атрибута.
+   # Осуществляет выбор между обработчиками встроенным и заданным пользователем в
+   # подробностях (options).
+   #
+   def select_value name, xml_context, contexts, options
+      contexts.map.with_index do |c, i|
+         [ c, i ]
+      end.reduce([nil, nil]) do |(value, val_index), (context, index)|
+         next [value, val_index] if value && value.text.present?
+
+         new =
+         if context[:on_proceed]
+            midvalue = value(name, xml_context, context, options)
+            handled_value(context[:on_proceed], midvalue, name, xml_context, options)
+         else
+            value(name, xml_context, context, options)
+         end
+
+#         binding.pry if name =~ /lot/
+         [ new, index ]
+      end
+   end
+
+   def handler_for handler
+      case handler
+      when Proc, Method
+         handler
+      when NilClass
+         nil
+      else
+         self.methods.include?(handler) && self.method(handler)
+      end
+   end
+
+   def handled_value handler, value, name, xml_context, options
+      method = handler_for(handler)
+
+#      new_value =
+#      if context[:by]
+#         c = [ this_contexts(context).first.merge(handler: nil) ]
+#         select_value(context[:by], value, c, options).first
+#      else
+#         value
+#      end
+#
+      if method
+         new_value =
+         if value.is_a?(Nokogiri::XML::NodeSet)
+            new = Nokogiri::XML::NodeSet.new(value.document)
+            new_value = value.map do |subvalue|
+               args = [ subvalue, name, xml_context, options ]
+               method[*args[0...method.arity]]
+#               if subvalue.nil? || subvalue.is_a?(Nokogiri::XML::Searchable)
+#                  subvalue
+#               else
+#                  binding.pry
+#                  Struct::Value.new(method[*args[0...method.arity]])
+#               end
+            end.compact.reduce(new) { |new, x| new << x }
+            new_value
+         else
+            args = [ value, name, xml_context, options ]
+            Struct::Value.new(method[*args[0...method.arity]])
+         end
+      else
+         value
+      end
+   end
+
+   def value name, xml_context, context, options
+      paths = paths(name, context)
+      new_context = paths.reduce(nil) do |new_context, path|
+         new_context.blank? && search_in(xml_context, path, options) || new_context
+      end
+
+      if new_context.respond_to?(:text)
+         new_context
+      else
+         Struct::Value.new(new_context)
+      end
+   end
+
+   # [1,2].map { |x| [3,4].map { |y| [x, y] } }.flatten(1)
+   #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
+   def integrate ary1, ary2
+      ary1.map { |x| ary2.map { |y| [x, y] } }.flatten(1)
+   end
+
+   # +join_context+ объединяет переданные строки контекста в единую строку в
+   # формате xpath.
+   #
+   # Пример 1:
+   #    args: "ns2:documentationDelivery", "deliveryEndDateTime"
+   #    out: ".//ns2:documentationDelivery//:deliveryEndDateTime"]
+   #
+   # Пример 2:
+   #    args: "", "ns2:contact"
+   #    out: ".//ns2:contact"
+   #
+   # Пример 3:
+   #    args: nil, "contact", nil
+   #    out: ".//:contact"
+   #
+   def paths name, context
+      froms = [ context[:from] || name ].flatten.compact
+      ctxs = [ context[:reset_context] || context[:context] ].flatten.compact
+      prefix = context[:reset_context] && "" || "."
+
+      integrate(ctxs, froms).map do |from|
+         from.map do |a|
+            a.split('/')
+         end.flatten.map do |a|
+            /(:|\A..\z)/ =~ a && a || "#{a}"
+         end.unshift(prefix).join("//")
+      end
+   end
+end

data/lib/scheme/parser/methods.rb

@@ -0,0 +1,98 @@
+module Scheme::Parser::Methods
+   CONTEXT_KEYS = [ :by, :re, :from, :context, :field, :reset_context, :on_proceed, :scheme, :on_found ]
+   FIELD_KEYS = [ :required, :as, :if, :update, :update_field, :on_complete, :map ]
+   PURE_CONTEXT_KEYS = [ :from, :context, :reset_context ]
+
+   def scheme name, &block
+      current_scheme_path << name.to_s
+      yield
+      current_scheme_path.pop
+   end
+
+   def context name, &block
+      current_context << name.to_s
+      yield
+      current_context.pop
+   end
+
+   def scheme_name name
+      name.to_s.singularize
+   end
+
+   def use_default_key name
+      current_options[:key] = name
+   end
+
+   def has_field name, *args
+      current_scheme[scheme_name(name)] = make_options(:field, args)
+   end
+
+   def has_scheme name, *args
+      current_scheme[scheme_name(name)] = make_options(:scheme, args)
+   end
+
+   def has_schemes name, *args
+      current_scheme[scheme_name(name)] = make_options(:scheme, args, true)
+   end
+
+   def has_reference name, *args
+      current_scheme[scheme_name(name)] = make_options(:reference, args)
+   end
+
+#    has_reference :lot, [
+#    { by: 'guid', from: 'ns2:lot', reset_context: 'ns2:protocolLotApplications' },
+#    { by: 'ns2:guid', from: 'ns2:protocolLotApplications', reset_context: 'ns2:lotApplicationsList' },
+#    ], required: true
+#
+#    has_field :rate, { required: true },
+#    { from: [ 'ns2:winnerIndication' ], handler: proc { |value| ! (value !~ /W/) } },
+#    { from: [ 'ns2:applicationPlace' ], handler: proc { |value| ! (value !~ /F/) } },
+#    { from: [ 'ns2:applicationRate' ], handler: proc { |value| ! (value !~ /1/) } }
+
+   # TODO move to protected
+   #
+   def make_options type, args, multiple = false
+      contexts = make_contexts(filter_hashes(args, CONTEXT_KEYS))
+      local = filter_hashes(args, FIELD_KEYS).reduce({}) { |r, x| r.merge(x) }
+      { type: type, multiple: multiple, contexts: contexts }.merge(local)
+   end
+
+   def filter_hashes hashes, by
+      hashes.flatten.map do |hash|
+         (hash.keys & by).map { |x| [ x, hash[x] ] }.to_h
+      end.select do |hash|
+         hash.any?
+      end
+   end
+
+   def make_contexts contexts
+      (contexts.empty? && [{}] || contexts).map do |options|
+         ctxs = [ options[:context] || "" ].flatten
+         options[:context] = ctxs.map do |ctx|
+            [ current_context, ctx ].flatten.compact.join('/')
+         end
+
+         options
+      end
+   end
+
+   def current_context
+      @current_context ||= []
+   end
+
+   def current_scheme_path
+      @current_scheme_path ||= []
+   end
+
+   def schemes
+      @schemes ||= {}
+   end
+
+   def current_options
+      current_scheme[nil] ||= {}
+   end
+
+   def current_scheme
+      schemes[current_scheme_path.last] ||= {}
+   end
+end

data/lib/scheme/parser/version.rb

@@ -0,0 +1,5 @@
+module Scheme
+   module Parser
+      VERSION = "0.1.99"
+   end
+end

data/scheme_parser.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'scheme/parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "scheme_parser"
+  spec.version       = Scheme::Parser::VERSION
+  spec.authors       = ["Malo Skrylevo"]
+  spec.email         = ["majioa@yandex.ru"]
+
+  spec.summary       = %q{Scheme Parser parse an XML/HTML document to hashly-structured format}
+  spec.description   = %q{Scheme Parser parse an XML/HTML document to hashly-structured format,
+                          prepared to import to a DB, or just serialize it and save it as is}
+  spec.homepage      = "https://github.com/majioa/scheme_parser"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "nokogiri", "~> 1.8.2", '>= 1.8.2'
+  # spec.add_dependency "ox", platform: ruby
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: scheme_parser
+version: !ruby/object:Gem::Version
+  version: 0.1.99
+platform: ruby
+authors:
+- Malo Skrylevo
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |-
+  Scheme Parser parse an XML/HTML document to hashly-structured format,
+                            prepared to import to a DB, or just serialize it and save it as is
+email:
+- majioa@yandex.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rvmrc"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/scheme/parser.rb
+- lib/scheme/parser/base.rb
+- lib/scheme/parser/methods.rb
+- lib/scheme/parser/version.rb
+- scheme_parser.gemspec
+homepage: https://github.com/majioa/scheme_parser
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Scheme Parser parse an XML/HTML document to hashly-structured format
+test_files: []