transformator 0.1.4 → 1.0.0.pre1

data/examples/primo_search_response_transformation.rb

@@ -1,123 +0,0 @@
-require "transformator"
-
-module Transformator::Examples
-  class PrimoSearchResponseTransformation
-    def self.apply(*args)
-      transformation.apply(*args)
-    end
-
-    def self.transformation
-      Transformator::Transformation.new do
-        def search_brief_return_transformation
-          @search_brief_return_transformation ||= Transformator::Transformation.new do
-            #
-            # setup target skeleton
-            #
-            process :document do |source, target|
-              target_skeleton = {
-                took: nil,
-                hits: {
-                  hits: []
-                },
-                facets: {}
-              }
-                
-              elements_from_hash(target_skeleton).each do |element|
-                target << element
-              end
-            end
-
-            #
-            # facets
-            #
-            process "SEGMENTS/JAGROOT/RESULT/FACETLIST/FACET" do |source_facet, target|
-              # syntactic mapping
-              find(target, "facets") << element(source_facet["NAME"]) do |target_facet|
-                source_facet_values = find_all(source_facet, "FACET_VALUES")
-
-                target_facet << element("_type", text: "terms")
-                target_facet << element("total", text: source_facet_values.length, type: "integer")
-                target_facet << (terms_array = array("terms"))
-
-                source_facet_values.each do |source_facet_value|
-                  array(terms_array) do |term|
-                    term << element("term", text: source_facet_value[:KEY])
-                    term << element("count", text: source_facet_value[:VALUE], type: "integer")
-                  end
-                end
-              end
-            end
-            
-            #
-            # records
-            #
-            process "SEGMENTS/JAGROOT/RESULT/DOCSET/DOC" do |record, target|
-              array(find(target, "hits/hits")) do |hit|
-                # syntactic mapping
-                hit << element("_type", text: "record")
-                hit << _source = element("_source") do |element|
-                  record.locate("PrimoNMBib/record/?").each do |section|
-                    element << section
-                  end
-                end
-
-                # semantic mapping
-                {
-                  "display/creationdate" => "created",
-                  "display/description"  => "description",
-                  "display/edition"      => "edition",
-                  "display/format"       => "format",
-                  "display/language"     => "language",
-                  "display/title"        => "title",
-                  "display/subject"      => "subject",
-                  "display/publisher"    => "publisher", # may there be more than one?
-                  "control/recordid"     => "id"
-                }
-                .each_pair do |from, to|
-                  find(_source, from) do |element|
-                    hit << element(to, text: element.text)
-                  end
-                end
-
-                find_all(_source, "_source/display/creator").each do |creator|
-                  hit << element("creator", text: creator.text)
-                end
-
-                #
-                # identifier
-                # 
-                hit << array("identifier") do |identifier|
-                  # ilsApiId
-                  identifier << element(find(_source, "control/ilsapiid").text, text: "ilsApiId")
-                  
-                  # isbns
-                  find_all(_source, "search/isbn").each do |isbn|
-                    identifier << element(isbn.text, text: "isbn")
-                  end
-
-                  # recordId
-                  identifier << element(find(_source, "control/recordid").text, text: "recordId")
-                end
-              end
-            end
-          end
-        end
-
-        process :document do |source, target|
-          # parse the "string encoded" inner search brief return
-          search_brief_return = Transformator.document_from_xml(
-            find(source, "Envelope/Body/searchBriefResponse/searchBriefReturn").text,
-            remove_namespaces: true,
-            remove_whitespace_only_text_nodes: false
-          )
-
-          # apply the literal transformation and merge the result's nodes with target
-          search_brief_return_transformation.apply(
-            to: search_brief_return,
-            output: :ox_document
-          ).nodes.each { |node| target << node }
-        end
-      end
-    end
-  end
-end

data/examples/search_request_transformation.rb

@@ -1,89 +0,0 @@
-require "transformator"
-
-module Transformator::Examples
-  class SearchRequestTransformation
-    def self.apply(*args)
-      transformation.apply(*args)
-    end
-
-    def self.transformation
-      Transformator::Transformation.new do
-        #
-        # setup outer target skeleton
-        #
-        process :target do |target|
-          target << element_from_xml(
-            <<-xml.strip_heredoc
-              <env:Envelope
-                  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                  xmlns:impl="http://primo.kobv.de/PrimoWebServices/services/searcher"
-                  xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
-                  xmlns:ins0="http://xml.apache.org/xml-soap">
-                <env:Body>
-                  <impl:searchBrief></impl:searchBrief>
-                </env:Body>
-              </env:Envelope>
-            xml
-          )
-        end
-
-        #
-        # setup inner search request that will be wrapped in a cdata element at the end
-        #
-        process :none do
-          # we setup this skeleton instead of dynamic element creation because order matters with primo
-          @search_request = element_from_xml(
-            <<-xml.strip_heredoc
-              <searchRequest xmlns="http://www.exlibris.com/primo/xsd/wsRequest" xmlns:uic="http://www.exlibris.com/primo/xsd/primoview/uicomponents">
-                <PrimoSearchRequest xmlns="http://www.exlibris.com/primo/xsd/search/request">
-                  <QueryTerms>
-                    <BoolOpeator>AND</BoolOpeator>
-                  </QueryTerms>
-                  <StartIndex></StartIndex>
-                  <BulkSize></BulkSize>
-                  <DidUMeanEnabled>false</DidUMeanEnabled>
-                  <HighlightingEnabled>false</HighlightingEnabled>
-                  <Languages></Languages>
-                  <SortByList></SortByList>
-                  <Locations></Locations>
-                </PrimoSearchRequest>
-                <onCampus>false</onCampus>
-              </searchRequest>
-            xml
-          )
-        end
-
-        #
-        # transform source into target
-        #
-        process "/from" do |element|
-          find(@search_request, "PrimoSearchRequest/StartIndex") << element.text
-        end
-
-        process "/size" do |element|
-          find(@search_request, "PrimoSearchRequest/BulkSize") << element.text
-        end
-
-        process "//query_string" do |query_string|
-          find(@search_request, "PrimoSearchRequest/QueryTerms") << element_from_xml(
-            <<-xml.strip_heredoc
-              <QueryTerm>
-                <IndexField></IndexField>
-                <PrecisionOperator>contains</PrecisionOperator>
-                <Value>#{find(query_string, "query").text}</Value>
-              </QueryTerm>
-            xml
-          )
-        end
-
-        #
-        # finally, wrap the search request into a cdata element
-        #
-        process :target do |target|
-          find(target, "//impl:searchBrief") << cdata(xml_from_element(@search_request))
-        end
-      end
-    end
-  end
-end

data/lib/transformator/dsl.rb

@@ -1,93 +0,0 @@
-require "ox"
-
-module Transformator::Dsl
-  def array(name_or_node, &block)
-    name_or_node = name_or_node.to_s if name_or_node.is_a?(Symbol) # eliminate "symbol"-case
-
-    name = name_or_node.is_a?(String) ? name_or_node : name_or_node.value
-    node = name_or_node.is_a?(Ox::Element) ? name_or_node : element(name, type: "array")
-
-    if block
-      append_accumulator = Struct.new(:elements) do
-        def <<(element)
-          self.elements.push(element)
-        end
-      end.new([])
-
-      yield(append_accumulator)
-
-      node << element(name) do |array_element|
-        append_accumulator.elements.each do |element|
-          array_element << element
-        end
-      end
-    end
-      
-    node
-  end
-
-  def cdata(content, &block)
-    new_cdata = Ox::CData.new(content)
-    block ? yield(new_cdata) : new_cdata
-  end
-
-  def element(name, options = {}, &block)
-    new_element = Ox::Element.new(name)
-
-    if (attributes = options[:attributes]).is_a?(Hash)
-      attributes.each_pair do |key, value|
-        new_element[key.to_s] = value.to_s
-      end
-    end
-
-    if nodes = options[:nodes]
-      (nodes.is_a?(Array) ? nodes : [nodes]).each do |node|
-        new_element << node
-      end
-    end
-
-    if text = options[:text]
-      new_element << text.to_s
-    end
-
-    if type = options[:type]
-      new_element["type"] = type.to_s
-    end
-
-    yield(new_element) if block
-    new_element
-  end
-
-  def elements_from_hash(hash)
-    Transformator.document_from_hash(hash).root.nodes
-  end
-
-  def element_from_xml(xml, options = {})
-    elements_from_xml(xml, options).first
-  end
-
-  def elements_from_xml(xml, options = {})
-    Transformator.document_from_xml(xml, options).nodes
-  end
-
-  def find(node, path, &block)
-    find_result = find_all(node, path).first
-
-    if block && find_result
-      yield(find_result)
-    else
-      find_result
-    end
-  end
-
-  def find_all(node, path, &block)
-    find_all_result = node.locate(Transformator.oxify_path(path))
-
-    yield(find_all_result) if block && !find_all_result.empty?
-    find_all_result
-  end
-
-  def xml_from_element(element)
-    Transformator.xml_from_document(element, with_xml: false)
-  end
-end

data/lib/transformator/format_converter.rb

@@ -1,27 +0,0 @@
-module Transformator::FormatConverter
-  require_relative "./format_converter/document_from_hash"
-  require_relative "./format_converter/document_from_object"
-  require_relative "./format_converter/document_from_xml"
-  require_relative "./format_converter/hash_from_document"
-  require_relative "./format_converter/xml_from_document"
-
-  include DocumentFromHash
-  include DocumentFromObject
-  include DocumentFromXml
-  include HashFromDocument
-  include XmlFromDocument
-
-  def self.remove_namespaces!(xml)
-    xml.gsub!(/<(\/?)\w+:(\w+)/, "<\\1\\2")
-  end
-
-  def self.remove_whitespace_only_text_nodes(xml)
-    remove_whitespace_only_text_nodes!(xml.dup)
-  end
-
-  def self.remove_whitespace_only_text_nodes!(xml)
-    # remove whitespace only text nodes
-    xml.gsub!(/>(\s|\n|\r)+</, "><")
-    xml
-  end
-end

data/lib/transformator/format_converter/document_from_hash.rb

@@ -1,13 +0,0 @@
-require "active_support/core_ext/hash/conversions"
-require "libxml"
-require "transformator/format_converter/document_from_xml"
-
-module Transformator::FormatConverter::DocumentFromHash
-  include Transformator::FormatConverter::DocumentFromXml
-
-  def document_from_hash(hash)
-    ActiveSupport::XmlMini.backend = "LibXML"
-    xml = hash.to_xml(dasherize: false, indent: 0, root: :hash, skip_types: false)
-    document_from_xml(xml, remove_whitespace_only_text_nodes: false)
-  end
-end

data/lib/transformator/format_converter/document_from_object.rb

@@ -1,20 +0,0 @@
-module Transformator::FormatConverter::DocumentFromObject
-  def document_from_object(obj, options = {})
-    case Transformator.determine_format(obj)
-    when :hash
-      Transformator.document_from_hash(obj)
-    when :json
-      Transformator.document_from_json(obj)
-    when :ox_document
-      obj
-    when :xml
-      Transformator.document_from_xml(
-        obj,
-        remove_whitespace_only_text_nodes: false,
-        remove_namespaces: true
-      )
-    when nil
-      Ox::Document.new(version: "1.0", encoding: "UTF-8")
-    end
-  end
-end

data/lib/transformator/format_converter/document_from_xml.rb

@@ -1,28 +0,0 @@
-module Transformator::FormatConverter::DocumentFromXml
-  def document_from_xml(xml, options = {})
-    xml =
-    if options[:remove_whitespace_only_text_nodes] || options[:remove_namespaces]
-      xml.dup
-    else
-      xml
-    end
-
-    unless options[:remove_whitespace_only_text_nodes] == false
-      Transformator::FormatConverter.remove_whitespace_only_text_nodes!(xml)
-    end
-
-    if options[:remove_namespaces] == true
-      Transformator::FormatConverter.remove_namespaces!(xml)
-    end
-
-    if xml[/\A\s*<\?xml/]
-      Ox.parse(xml)
-    else
-      Ox::Document.new(version: "1.0", encoding: "UTF-8").tap do |new_document|
-        Ox.parse("<root>" << xml << "</root>").nodes.each do |node|
-          new_document << node
-        end
-      end
-    end
-  end
-end

data/lib/transformator/format_converter/hash_from_document.rb

@@ -1,61 +0,0 @@
-require "ox"
-
-module Transformator::FormatConverter::HashFromDocument
-  def hash_from_document(document)
-    document =
-    if document.root.value == "hash"
-      document
-    else
-      hash_container_document = Ox::Document.new
-      hash_container_document << (hash_root_element = Ox::Element.new("hash"))
-      document.nodes.each do |node|
-        hash_root_element << node
-      end
-
-      hash_container_document
-    end
-
-    hash = Transformator::FormatConverter::HashFromDocument.process_node(document.root, {})
-    hash["hash"].nil? ? hash : hash["hash"]
-  end
-
-  def self.process_node(node, hash)
-    value =
-    if (child_nodes = node.nodes).all? { |child_node| child_node.is_a?(String) }
-      case node[:type]
-      when "integer" then child_nodes.join.to_i
-      when "float" then child_nodes.join.to_f
-      when "boolean" then child_nodes.join.downcase == "true"
-      else node[:nil] == "true" ? nil : child_nodes.join
-      end
-    else
-      if node[:type] == "array"
-        node.locate(node.value)
-        .map do |child_node|
-          if (arr_element = process_node(child_node, {})).is_a?(Hash) && arr_element.keys == [node.value]
-            arr_element.values.first
-          else
-            arr_element
-          end
-        end
-      else
-        {}.tap do |child_nodes_hash|
-          child_nodes.each do |child_node|
-            process_node(child_node, child_nodes_hash)
-          end
-        end
-      end
-    end
-
-    hash[node.value] =
-    if hash[node.value].nil?
-      value
-    elsif hash[node.value].is_a?(Array)
-      hash[node.value] << value
-    else
-      [hash[node.value], value]
-    end
-
-    hash
-  end
-end