nokogiri_schematron_builder 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 24f02a10a7493555198daad2202e63376d1e7bbc9af7b91c79318d4c36239c41
+  data.tar.gz: 9bf5e2b1ac5e0e6a7949bcef45331e8277a823a13cecb5b8c387ccdadee41c34
+SHA512:
+  metadata.gz: babe38706760546dfbb24513d9a9453c4156769837279c75967a253e8fd5bea48fb101c014c25299973e960d59d280dc5de5413a2ce63aac80de9a64320a4928
+  data.tar.gz: 175f4df54fa99d350c8823519c3d22c68be65c5912f98bf4605b949580bbd803590ffe703a6aa662d4a47509aff00a0439b65ca5b455e9f8c05e94b908b0bce7

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in nokogiri_schematron_builder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,32 @@
+nokogiri_schematron_builder
+
+Copyright (c) 2019, Battelle Memorial Institute
+All rights reserved.
+
+1. Battelle Memorial Institute (hereinafter Battelle) hereby grants permission
+   to any person or entity lawfully obtaining a copy of this software and
+   associated documentation files (hereinafter "the Software") to redistribute
+   and use the Software in source and binary forms, with or without
+   modification.  Such person or entity may use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and may permit
+   others to do so, subject to the following conditions:
+
+   * Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimers.
+   * Redistributions in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+   * Other than as used herein, neither the name Battelle Memorial Institute or
+     Battelle may be used in any form whatsoever without the express written
+     consent of Battelle.
+
+2. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL BATTELLE OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,109 @@
+# nokogiri_schematron_builder
+
+Build [Schematron](http://schematron.com) XML documents using [Nokogiri](https://nokogiri.org).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "nokogiri_schematron_builder"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nokogiri_schematron_builder
+
+## Usage
+
+Add this line to your application:
+
+```ruby
+require "nokogiri/xml/schematron/schema"
+```
+
+Create the schema using the domain-specific language:
+
+```ruby
+schema = Nokogiri::XML::Schematron::Schema.new(title: "Example schema") do
+  ns(prefix: "ex", uri: "http://example.com/ns#")
+  pattern(name: "Example pattern") do
+    rule(context: "/") do
+      assert(test: "count(ex:A) >= 1", message: "element \"ex:A\" is REQUIRED")
+    end
+    rule(context: "/ex:A") do
+      assert(test: "count(ex:B) >= 0", message: "element \"ex:B\" is OPTIONAL")
+    end
+    rule(context: "/ex:A/ex:B") do
+      assert(test: "not(ex:C)", message: "element \"ex:C\" is NOT RECOMMENDED")
+    end
+  end
+end
+```
+
+Or, equivalently:
+
+```ruby
+schema = Nokogiri::XML::Schematron::Schema.new(title: "Example schema") do
+  ns(prefix: "ex", uri: "http://example.com/ns#")
+  pattern(name: "Example pattern") do
+    context("/") do
+      require("ex:A") do
+        permit("ex:B") do
+          reject("ex:C")
+        end
+      end
+    end
+  end
+end
+```
+
+Next, construct a [`Nokogiri::XML::Builder`](https://nokogiri.org/rdoc/Nokogiri/XML/Builder.html) object:
+
+```ruby
+builder = schema.to_builder(encoding: "UTF-8")
+```
+
+Finally, generate the XML:
+
+```ruby
+xml = builder.to_xml
+```
+
+The result is:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron" title="Example schema">
+  <sch:ns prefix="ex" uri="http://example.com/ns#"/>
+  <sch:pattern name="Example pattern">
+    <sch:rule context="/">
+      <sch:assert test="count(ex:A) &gt;= 1">element "ex:A" is REQUIRED</sch:assert>
+    </sch:rule>
+    <sch:rule context="/ex:A">
+      <sch:assert test="count(ex:B) &gt;= 0">element "ex:B" is OPTIONAL</sch:assert>
+    </sch:rule>
+    <sch:rule context="/ex:A/ex:B">
+      <sch:assert test="not(ex:C)">element "ex:C" is NOT RECOMMENDED</sch:assert>
+    </sch:rule>
+  </sch:pattern>
+</sch:schema>
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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).
+
+## License
+
+[The 2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/pnnl/nokogiri_schematron_builder.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/WARRANTY.txt

@@ -0,0 +1,22 @@
+This material was prepared as an account of work sponsored by an agency of the
+United States Government.  Neither the United States Government nor the United
+States Department of Energy, nor Battelle, nor any of their employees, nor any
+jurisdiction or organization that has cooperated in the development of these
+materials, makes any warranty, express or implied, or assumes any legal
+liability or responsibility for the accuracy, completeness, or usefulness or any
+information, apparatus, product, software, or process disclosed, or represents
+that its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service by
+trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the United
+States Government or any agency thereof, or Battelle Memorial Institute. The
+views and opinions of authors expressed herein do not necessarily state or
+reflect those of the United States Government or any agency thereof.
+
+                      PACIFIC NORTHWEST NATIONAL LABORATORY
+                                   operated by
+                                    BATTELLE
+                                     for the
+                       UNITED STATES DEPARTMENT OF ENERGY
+                        under Contract DE-AC05-76RL01830

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nokogiri/xml/schematron"
+
+# 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(__FILE__)

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/nokogiri/xml/schematron.rb

@@ -0,0 +1,8 @@
+require "nokogiri/xml/schematron/version"
+
+module Nokogiri
+  module XML
+    module Schematron
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/assertion.rb

@@ -0,0 +1,46 @@
+require "nokogiri/xml/schematron/base"
+
+module Nokogiri
+  module XML
+    module Schematron
+      # The internal representation of the +<sch:assert>+ XML element.
+      #
+      # For example:
+      #
+      #   assertion = Nokogiri::XML::Schematron::Assertion.new(nil, test: "not(ex:Example)", message: "element \"ex:Example\" is NOT RECOMMENDED")
+      #   # => #<Nokogiri::XML::Schematron::Assertion:0x00007fa739a55dd8 @parent=nil, @children=[], @options={:test=>"not(ex:Example)", :message=>"element \"ex:Example\" is NOT RECOMMENDED"}>
+      #   assertion.to_builder.to_xml
+      #   # => "<?xml version=\"1.0\"?>\n<sch:assert xmlns:sch=\"http://purl.oclc.org/dsdl/schematron\" test=\"not(ex:Example)\">element \"ex:Example\" is NOT RECOMMENDED</sch:assert>\n"
+      #
+      class Assertion < Nokogiri::XML::Schematron::Base
+        # @!attribute [rw] message
+        #   @return [String] the text content of the +<sch:assert>+ XML element.
+        attribute :message
+
+        # @!attribute [rw] test
+        #   @return [String] the value of the +@test+ XML attribute.
+        attribute :test
+
+        protected
+
+        def build!(xml)
+          xml["sch"].send(:assert, %w(test).inject(xmlns) { |acc, method_name|
+            unless (s = send(method_name.to_sym)).nil?
+              acc[method_name.to_s] = s
+            end
+
+            acc
+          }) do
+            unless (s = send(:message)).nil?
+              xml.text(s)
+            end
+
+            super(xml)
+          end
+
+          return
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/base.rb

@@ -0,0 +1,143 @@
+require "nokogiri"
+
+module Nokogiri
+  module XML
+    module Schematron
+      # The base class for internal representations of Schematron types.
+      # @abstract
+      class Base
+        class << self
+          # Defines methods for a named XML attribute.
+          #
+          # For example:
+          #
+          #   attribute :name
+          #
+          # defines reader and writer methods that are equivalent to:
+          #
+          #   def name
+          #     @options[:name]
+          #   end
+          #
+          #   def name=(value)
+          #     @options[:name] = value
+          #   end
+          #
+          # @param name [#to_sym] the method name.
+          # @param options [Hash<Symbol, Object>] the options.
+          # @option options [Boolean] :reader (true) define the reader method?
+          # @option options [Boolean] :writer (true) define the writer method?
+          # @return [void]
+          def attribute(name, **options)
+            unless options[:reader] == false
+              define_method(name.to_sym) do
+                instance_variable_get(:@options).send(:[], name.to_sym)
+              end
+            end
+
+            unless options[:writer] == false
+              define_method(:"#{name.to_sym}=") do |value|
+                instance_variable_get(:@options).send(:[]=, name.to_sym, value)
+              end
+            end
+
+            return
+          end
+
+          # Defines methods for a named XML element.
+          #
+          # For example:
+          #
+          #   element :name, DescendentOfBase
+          #
+          # where
+          #
+          #   class DescendentOfBase < Base; end
+          #
+          # is a descendent of this class, defines methods that are equivalent to:
+          #
+          #   def name(*args, &block)
+          #     base = DescendentOfBase.new(self, *args, &block)
+          #     @children << base
+          #     base
+          #   end
+          #
+          # @param name [#to_sym] the method name.
+          # @param klass [Class] the class.
+          # @return [void]
+          def element(name, klass)
+            define_method(name.to_sym) do |*args, &block|
+              base = klass.send(:new, self, *args, &block)
+              instance_variable_get(:@children) << base
+              base
+            end
+          end
+        end
+
+        # @return [Nokogiri::XML::Schematron::Base] the parent object.
+        attr_reader :parent
+
+        # @return [Array<Nokogiri::XML::Schematron::Base>] the children of the internal representation of the Schematron type.
+        attr_reader :children
+
+        # @return [Hash<Symbol, Object>] the options.
+        attr_reader :options
+
+        # Create a new +Base+ object.
+        #
+        # @param parent [Nokogiri::XML::Schematron::Base] the parent object.
+        # @param options [Hash<Symbol, Object>] the options.
+        # @yieldparam base [Nokogiri::XML::Schematron::Base] the internal representation of the Schematron type.
+        # @yieldreturn [void]
+        def initialize(parent, **options, &block)
+          @parent = parent
+          @children = []
+
+          @options = options
+
+          if block_given?
+            case block.arity
+              when 1 then block.call(self)
+              else instance_eval(&block)
+            end
+          end
+        end
+
+        # Convert this +Base+ object to a +Builder+ object.
+        #
+        # @return [Nokogiri::XML::Builder]
+        # @see https://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/Builder#initialize-instance_method
+        def to_builder(*args)
+          ::Nokogiri::XML::Builder.new(*args) do |xml|
+            build!(xml)
+          end
+        end
+
+        protected
+
+        # Build the XML representation of the Schematron type.
+        #
+        # @param xml [Nokogiri::XML::Builder] the XML builder.
+        # @return [void]
+        def build!(xml)
+          @children.each do |base|
+            base.send(:build!, xml)
+          end
+
+          return
+        end
+
+        # @return [Hash<String, String>] the hash of XML namespaces (URI by prefix).
+        def xmlns
+          if @parent.nil?
+            {
+              "xmlns:sch" => "http://purl.oclc.org/dsdl/schematron",
+            }
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/schematron/internal/core_ext/array.rb

@@ -0,0 +1,33 @@
+module Nokogiri
+  module XML
+    module Schematron
+      module Internal
+        module CoreExt
+          module Array
+            # Converts the array to a comma-separated sentence where the last
+            # element is joined by the connector word.
+            #
+            # @param array [Array<String>] the array of strings.
+            # @param options [Hash<Symbol, Object>] the options.
+            # @option options [String] :words_connector the sign or word used to join the elements in arrays with two or more elements.
+            # @option options [String] :two_words_connector the sign or word used to join the elements in arrays with two elements.
+            # @option options [String] :last_word_connector the sign or word used to join the last element in arrays with three or more elements.
+            # @return [String] the comma-separated sentence.
+            def self.to_sentence(array, options = {})
+              case array.length
+              when 0
+                ''
+              when 1
+                array[0].to_s.dup
+              when 2
+                "#{array[0]}#{options[:two_words_connector]}#{array[1]}"
+              else
+                "#{array[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{array[-1]}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end