transformator 0.0.1 → 0.1.0

data/examples/primo_search_response_transformation.rb

@@ -0,0 +1,123 @@
+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, "_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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,93 @@
+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/document_from_hash.rb

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,61 @@
+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

data/lib/transformator/format_converter/xml_from_document.rb

@@ -0,0 +1,7 @@
+require "ox"
+
+module Transformator::FormatConverter::XmlFromDocument
+  def xml_from_document(document, options = {})
+    Ox.dump(document, { }.merge(options))
+  end
+end

data/lib/transformator/format_converter.rb

@@ -0,0 +1,27 @@
+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/transformation.rb

@@ -1,41 +1,67 @@
 require "ox"
+require "transformator/dsl"
 
 class Transformator::Transformation
   def initialize(options = {}, &block)
-    @context = options[:context]
     @rules = []
     self.instance_eval(&block) if block
   end
 
-  def apply_to(source, options = {})
-    source = Ox.parse(source) if source.is_a?(String)
-    result = Ox::Document.new(version: "1.0", encoding: "UTF-8").tap do |target|
-      @rules.each do |rule|
-        apply_rule(rule, source, target, options)
+  #
+  public
+  #
+  def apply(options = {})
+    source = Transformator.document_from_object(options[:source] ||= options[:to])
+    target = Transformator.document_from_object(options[:target])
+
+    @rules.each do |rule|
+      block = rule[:callable]
+      path = rule[:path]
+      type = rule[:type]
+
+      # allow user do process source => source, target => target or target => source
+      _source = options[:source] == :target ? target : source
+      _target = options[:target] == :source ? source : target
+
+      if type == :process
+        if path.is_a?(Array)
+          block.call(
+            path.map do |_path| { _path => find_all(_source, _path) } end,
+            _target
+          )
+        elsif path.is_a?(String)
+          find_all(_source, path).each do |element_to_process|
+            block.call(element_to_process, _target)
+          end
+        elsif path.is_a?(Symbol)
+          if path == :document
+            block.call(_source, _target)
+          elsif path == :none
+            block.call
+          elsif path == :source
+            block.call(source, _target)
+          elsif path == :target
+            block.call(target, _target)
+          end
+        end
       end
     end
 
-    Ox.dump(result, with_xml: true)
+    case options[:output_format] || Transformator.determine_format(options[:source])
+    when :hash then Transformator.hash_from_document(target)
+    when :ox_document then target
+    when :xml then Ox.dump(target, with_xml: true)
+    else raise "Unknown output format!"
+    end
   end
 
+  #
   private
-
+  #
+  include Transformator::Dsl
+  
   def process(path, options = {}, &block)
-    @rules.push({ callable: block, path: path }.merge(options))
+    @rules.push({ callable: block, path: path, type: :process}.merge(options))
     self
   end
-
-  def apply_rule(rule, source, target, options = {})
-    value =
-    if rule[:path].is_a?(Array)
-      rule[:path].inject({}) do |hash, path|
-        hash[path] = source.locate(path)
-        memo
-      end
-    else
-      source.locate(rule[:path])
-    end
-
-    (options[:context] || @context || self).instance_exec(value, target, &rule[:callable])
-  end
 end

data/lib/transformator/version.rb

@@ -1,3 +1,3 @@
 module Transformator
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/transformator.rb

@@ -1,5 +1,33 @@
+require "ox"
 require "transformator/version"
 
 module Transformator
+  require_relative "./transformator/dsl"
+  require_relative "./transformator/format_converter"
   require_relative "./transformator/transformation"
+
+  extend Transformator::FormatConverter
+
+  def self.determine_format(obj)
+    if obj.is_a?(Hash)
+      :hash
+    elsif obj.is_a?(Ox::Document)
+      :ox_document
+    elsif obj.is_a?(String) && obj[/\A\s*{/]
+      :json
+    elsif obj.is_a?(String) && obj[/\A\s*</]
+      :xml
+    elsif obj.nil?
+      nil
+    else
+      raise "Unkown format!"
+    end
+  end
+
+  def self.oxify_path(path)
+    path
+    .gsub(/\A\/\/(\S+)/, "*/\\1")
+    .gsub(/(\S*)\/\/(\S*)/, "\\1/*/\\2")
+    .gsub(/\A\/(\w+)(\S*)/, "?/\\1\\2")  # replace "/foo" with "?/foo"
+  end
 end

data/spec/examples/primo_search_response_transformation_spec.rb

@@ -0,0 +1,19 @@
+require_relative "../../examples/primo_search_response_transformation"
+
+describe "Examples" do
+  let(:primo_search_response) do
+    File.read(
+      File.expand_path(
+        File.join(
+          File.dirname(__FILE__), "../../assets/primo_search_response_1.xml"
+        )
+      )
+    )
+  end
+
+  it "transforms primo search response" do
+    Transformator::Examples::PrimoSearchResponseTransformation.apply(to: primo_search_response, output_format: :hash).tap do |w|
+      # binding.pry
+    end
+  end
+end

data/spec/examples/search_request_transformation_spec.rb

@@ -0,0 +1,48 @@
+require_relative "../../examples/search_request_transformation"
+
+describe "Examples" do
+  let(:search_request_hash) do
+    {
+      from: 0,
+      size: 20,
+      query: {
+        bool: {
+          must: [
+            {
+              query_string: {
+                query: "linux",
+                default_operator: "AND",
+                fields: [
+                  "title^2",
+                  "_all"
+                ]
+              }
+            },
+            {
+              query_string: {
+                query: "kofler",
+                default_operator: "AND",
+                fields: [
+                  "creator"
+                ]
+              }
+            },
+            {
+              range: {
+                lsr09: {
+                  gte: 20140101
+                }
+              }        
+            }
+          ]
+        }
+      },
+    }
+  end
+
+  it "transforms search request to primo soap body" do
+    Transformator::Examples::SearchRequestTransformation.apply(to: search_request_hash, output_format: :xml).tap do |w|
+      # binding.pry
+    end
+  end
+end