transformator 0.1.4 → 1.0.0.pre1

data/lib/transformator/format_converter/xml_from_document.rb

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

data/lib/transformator/transformation.rb

@@ -1,91 +0,0 @@
-require "ox"
-require "transformator/dsl"
-
-class Transformator::Transformation
-  def initialize(options = {}, &block)
-    # make it possible to initialize a transformation with external data
-    options.each_pair do |key, value|
-      instance_variable_set "@#{key}".to_sym, value
-    end
-
-    @rules = []
-    self.instance_eval(&block) if block
-  end
-
-  #
-  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 to set source/target freely
-      _source =
-      if (source_callable = rule[:source]).respond_to?(:call)
-        source_callable.call
-      else
-        source
-      end
-
-      _target =
-      if (target_callable = rule[:target]).respond_to?(:call)
-        target_callable.call
-      else
-        target
-      end
-
-      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
-
-    case options[:output_format] || @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 before_apply(options = {}, &block)
-    @rules.unshift({ callable: block, path: :none, type: :process}.merge(options))
-  end
-
-  def output_format(format)
-    @output_format = format.to_sym
-  end
-
-  def process(path, options = {}, &block)
-    @rules.push({ callable: block, path: path, type: :process}.merge(options))
-    self
-  end
-end

data/spec/examples/primo_search_response_transformation_spec.rb

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

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

data/spec/transformator/dsl_spec.rb

@@ -1,187 +0,0 @@
-describe Transformator::Dsl do
-  let(:dsl) do
-    Module.new.extend(described_class)
-  end
-
-  #
-  # array
-  #
-  describe "#array" do
-    it "creates a new element with attribute \"type\" == \"array\"" do
-      expect(dsl.array(:foo)["type"]).to eq("array")
-    end
-
-    context "when called with a block" do
-      describe "passes an array accumulator to the block" do
-        it "allows appending elements to the array so that it's activesupport Hash.from_xml compatble" do
-          array_with_one_element = dsl.array(:foo) do |arr|
-            arr << dsl.element(:bar)
-          end
-
-          expect(dsl.find(array_with_one_element, "foo/bar")).not_to be_nil
-        end
-      end
-    end
-  end
-
-  #
-  # element
-  #
-  describe "#element" do
-    it "creates a new element with the given name" do
-      expect(dsl.element(:foo).value).to eq("foo")
-    end
-
-    context "when called with an \"attributes\" option" do
-      it "sets the attributes of the newly created element accordingly" do
-        attributes = { attr1: 1, attr2: "2", "attr3" => true }
-        expect(dsl.element(:foo, attributes: attributes).attributes).to eq({
-          "attr1" => "1",
-          "attr2" => "2",
-          "attr3" => "true"
-        })
-      end
-    end
-
-    context "when called with a \"text\" option" do
-      it "adds a text node to the newly created element" do
-        expect(dsl.element(:foo, text: "bar").text).to eq("bar")
-      end
-    end
-
-    context "when called with a \"type\" option" do
-      it "adds an attribute named \"type\" with the given value" do
-        expect(dsl.element(:foo, text: 1, type: :integer).attributes).to include({"type" => "integer"})
-      end
-    end
-  end
-
-  #
-  # elements_from_hash
-  #
-  describe "#elements_from_hash" do
-    let(:hash) do
-      {
-        key1: "value1",
-        key2: [
-          {
-            subkey: "subvalue"
-          }
-        ]
-      }
-    end
-
-    it "creates elements from the given hash" do
-      elements = dsl.elements_from_hash(hash)
-      expect(elements[0].value).to eq("key1")
-      expect(dsl.find(elements[1], "key2/subkey").text).to eq("subvalue") # key2 ist found due to the additional array element encoding
-    end
-  end
-
-  #
-  # elements_from_xml
-  #
-  describe "#elements_from_xml" do
-    let(:xml) do
-      <<-xml.strip_heredoc
-        <key1>value1</key1>
-        <key2>
-          <subkey>subvalue</subkey>
-        </key2>
-      xml
-    end
-
-    it "creates elements from the given xml string" do
-      elements = dsl.elements_from_xml(xml)
-      expect(elements[0].value).to eq("key1")
-      expect(dsl.find(elements[1], "subkey").text).to eq("subvalue")
-    end
-  end
-
-  #
-  # find
-  #
-  describe "#find" do
-    let(:node) do
-      dsl.element(:root) do |root|
-        root << dsl.element(:foo, text: "1")
-        root << dsl.element(:foo, text: "2")
-      end
-    end
-
-    describe "is a shortcut for find_all(..)[0]" do
-      context "when there are elements matching the given path" do
-        it "returns the first element found" do
-          expect(dsl.find(node, "foo").text).to eq("1")
-        end
-      end
-
-      context "when there are no elements matching the given path" do
-        it "returns nil" do
-          expect(dsl.find(node, "nope")).to be_nil
-        end
-      end
-    end
-  end
-
-  #
-  # find_all
-  #
-  describe "#find_all" do
-    let(:node) do
-      dsl.element(:root) do |root|
-        root << dsl.element(:foo, text: "1")
-        root << dsl.element(:foo, text: "2")
-        root << dsl.element(:bar) do |bar|
-          bar << dsl.element(:muff) do |muff|
-            muff << dsl.element(:key, text: "value")
-          end
-        end
-      end
-    end
-
-    it "understands xpath like path expressions" do
-      expect(dsl.find_all(node, "//key")).not_to be_nil
-    end
-
-    describe "finds all elements by the given path" do
-      context "when there are elements matching the given path" do
-        it "returns all elements found" do
-          expect(dsl.find_all(node, "foo").map(&:text)).to eq(["1", "2"])
-        end
-      end
-
-      context "when there are no elements matching the given path" do
-        it "returns an empty array" do
-          expect(dsl.find_all(node, "nope")).to eq([])
-        end
-      end
-    end
-
-    context "when called with a block" do
-      context "when there are elements matching the given path" do
-        it "calls the block with resulting array" do
-          variable_changed_inside_block = false
-
-          dsl.find_all(node, "foo") do |result|
-            variable_changed_inside_block = true if result.length == 2
-          end
-
-          expect(variable_changed_inside_block).to be(true)
-        end
-      end
-
-      context "when there are no elements matching the given path" do
-        it "the block is not called" do
-          variable_changed_inside_block = false
-
-          dsl.find_all(node, "nope") do |foo|
-            variable_changed_inside_block = true 
-          end
-
-          expect(variable_changed_inside_block).to be(false)
-        end
-      end
-    end
-  end
-end

data/spec/transformator/format_converter/hash_from_document_spec.rb

@@ -1,42 +0,0 @@
-describe Transformator::FormatConverter::HashFromDocument do
-  let(:transformator) do
-    Module.new.tap do |mod|
-      mod.extend Transformator::FormatConverter::HashFromDocument
-      mod.extend Transformator::FormatConverter::DocumentFromHash
-    end
-  end
-
-  let(:hash) do
-    {
-      "key1" => "value1",
-      "key2" => 1,
-      "key3" => 1.5,
-      "key4" => true,
-      "key5" => nil,
-      "key6" => {
-        "key6_1" => "value6_1"
-      },
-      "key7" => [
-        "1",
-        2,
-        true,
-        {
-          "key_arr_obj1" => [
-            "nested_element1",
-            {
-              "nested_key" => "nested_value"
-            }
-          ]
-        }
-      ]
-    }     
-  end
-
-  let(:document) do
-    transformator.document_from_hash(hash)
-  end
-
-  it "converts a document to its corresponding hash" do
-    expect(transformator.hash_from_document(document)).to eq(hash)
-  end
-end

data/spec/transformator/transformation_spec.rb

@@ -1,112 +0,0 @@
-describe Transformator::Transformation do
-  let(:source_xml) do
-    <<-xml.strip_heredoc
-      <?xml version="1.0" encoding="UTF-8"?>
-      <foo>
-        <bar>muff</bar>
-      </foo>
-    xml
-  end
-
-  let(:transformed_xml) do
-    <<-xml.strip_heredoc
-      <?xml version="1.0" encoding="UTF-8"?>
-      <muff>muff</muff>
-    xml
-  end
-
-  describe ".new" do
-    context "when called with an options hash" do
-      let(:transformed_xml) do
-        <<-xml.strip_heredoc
-          <?xml version="1.0" encoding="UTF-8"?>
-          <muff>value1</muff>
-        xml
-      end
-
-      it "provides each key as an instance variable inside the transformation" do
-        transformation = described_class.new(option1: "value1") do
-          process "foo/bar" do |element, target|
-            target << element("muff", text: @option1)
-          end
-        end
-
-        expect(transformation.apply(to: source_xml)).to eq(transformed_xml)
-      end
-    end
-
-    it "can be called with a block, containing the mapping described by the dsl" do
-      transformation = described_class.new do
-        process "foo/bar" do |element, target|
-          target << element("muff", nodes: element.nodes)
-        end
-      end
-
-      expect(transformation.apply(to: source_xml)).to eq(transformed_xml)
-    end
-  end
-
-  describe "#before_apply" do
-    let(:transformation) do
-      described_class.new(data: "some_data") do
-        process :target do |target|
-          target << element("data", text: @foo)
-        end
-
-        # usually rules are executed in order as the are defined, but this one comes first
-        before_apply do
-          @foo = @data
-        end
-      end
-    end
-
-    it "executes the given block before applying the transformation" do
-      transformed_document = transformation.apply(to: nil, output_format: :ox_document)
-      expect(transformed_document.locate("data").first.text).to eq("some_data")
-    end
-  end
-    
-  describe "#output_format" do
-    let(:transformation) do
-      described_class.new do
-        output_format :xml
-      end
-    end
-
-    it "sets the default output format for the transformation" do
-      expect(transformation.apply(to: {})).to start_with("<?xml")
-    end
-  end
-  
-  describe "#process" do
-    context "when source responds to call" do
-      let(:transformation) do
-        described_class.new do
-          process :none do
-            @foo = element("foo") << element("bar", text: "muff")
-          end
-
-          process "*", source: -> { @foo } do |element, target|
-            target << element
-          end
-        end
-      end
-
-      it "executes the rule with the callable result as the source" do
-        expect(transformation.apply(to: nil, output_format: :ox_document).locate("bar").first.text).to eq("muff")
-      end
-    end
-
-    context "when called with the special path :document" do
-      it "provides the whole input document to the block" do
-        transformation = described_class.new do
-          process :document do |document, target|
-            target << element("muff", nodes: ["muff"]) if document.nodes.empty?
-          end
-        end
-
-        expect(transformation.apply(to: nil, output_format: :xml)).to eq(transformed_xml)
-      end
-    end
-  end
-end