elibri_xml_versions 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - ree
+notifications:
+  email:
+    - p.szmielew@ava.waw.pl
+    - tomek@gildia.pl

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in elibri_xml_versions.gemspec
+gemspec
+
+#gem 'elibri_onix_mocks', :git => 'git://github.com/elibri/elibri_onix_mocks.git'

data/README.md

@@ -0,0 +1,24 @@
+[![Build Status](https://secure.travis-ci.org/elibri/elibri_xml_versions.png?branch=master)](http://travis-ci.org/elibri/elibri_xml_versions)
+
+Gem created for comparing eLibri xml objects.
+
+Currently working and tested only on REE.
+
+Basic usage:
+``Elibri::XmlVersions.new(product_ver1, product_ver2).diff``
+
+`product_ver1` and `product_ver2` must be same classes
+
+It will return hash:
+```ruby
+{
+  :added => [],
+  :changes => [], 
+  :deleted => []
+  }
+```
+
+under changes key, will be array of symbol and/or hashes.
+Symbols represents attributes that in product_ver2 are different then in product_ver1. If there is hash in changes key, it represents some changes in object that is in one <-> one relation with product_ver2.
+
+Added and deleted contains array of hashes. Every hash has symbol as a key, that is used to access array of elements where changes occures. As a value it contains array of elements that has been added/deleted from product_ver2, in comparision to product_ver1.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+desc "Running specs"
+task :spec do |t|
+  exec "cd spec/ && bundle exec rspec elibri_xml_versions_spec.rb"
+end
+
+task :default => ["spec"]

data/elibri_xml_versions.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "elibri_xml_versions/version"
+
+Gem::Specification.new do |s|
+  s.name        = "elibri_xml_versions"
+  s.version     = ElibriXmlVersions::VERSION
+  s.authors     = ["Piotr Szmielew"]
+  s.email       = ["p.szmielew@ava.waw.pl"]
+  s.homepage    = ""
+  s.summary     = %q{Gem created for comparing eLibri xml objects.}
+  s.description = %q|Gem created for comparing eLibri xml objects. More info coming soon. Currently working and tested only on REE.
+Basic usage: Elibri::XmlVersions.new(product_ver1, product_ver2).diff
+it will return hash: {:added => [], :changes => [], :deleted => []}|
+
+  s.rubyforge_project = "elibri_xml_versions"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+
+  s.add_development_dependency "rake"
+  
+#  s.add_development_dependency "ruby-debug"
+  s.add_development_dependency "elibri_onix_mocks"
+  s.add_runtime_dependency 'elibri_api_client'
+  s.add_runtime_dependency 'elibri_onix_dict'
+
+end

data/lib/elibri_xml_versions/version.rb

@@ -0,0 +1,3 @@
+module ElibriXmlVersions
+  VERSION = "0.1.0"
+end

data/lib/elibri_xml_versions.rb

@@ -0,0 +1,179 @@
+#encoding: UTF-8
+
+require "elibri_xml_versions/version"
+require 'elibri_api_client'
+require 'elibri_onix_dict'
+require 'digest/sha2'
+
+
+
+
+module Elibri
+  
+  class XmlVersions
+    
+
+    SKIPPED_ATTRIBS = ["@opts", "@default_namespace", "@instance", "@roxml_references"]
+    SKIPPED_2 = ["@id", "@id_before_type_cast"]
+                        
+
+    
+    attr_accessor :a, :b
+    
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+    
+    def diff
+=begin
+      diffs = []
+      @a.instance_variables.each do |attrib|
+        attrib = attrib.gsub("@", "").to_sym
+        if TREE_ATTRIBS.include? attrib
+          tree_attr = @a.send(attrib).map(&:id).sort
+          tree_attr_2 = @b.send(attrib).map(&:id).sort
+          if tree_attr != tree_attr_2         
+            #coś dopisane/usunięte
+          else
+            #trzeba sprawdzić czy wszystkie są takie same
+            attr_1 = @a.send(attrib).sort { |x,y| x.id <=> y.id }
+            attr_2 = @b.send(attrib).sort! { |x,y| x.id <=> y.id }
+            attr_1.each_with_index do |element, i|
+              element.instance_variables.each do |var|
+                var = var.gsub("@", "").to_sym
+                diffs << [attrib, var] if element.send(var) != attr_2[i].send(var)
+              end
+            end
+          end
+        else
+          diffs << attrib if @a.send(attrib) != @b.send(attrib)
+        end
+      end
+      diffs
+=end
+      check_tree(@a, @b)
+    end
+    
+    
+    def check_tree(a, b)
+     if a.class != b.class
+       raise "Different classes for diff" 
+     end
+=begin
+        if a.class.is_a? NilClass
+          return {:deleted => [], :added => [], :changes => [b]}
+        elsif b.class.is_a? NilClass
+          return {:deleted => [], :added => [], :changes => [a]}
+        else
+
+        end
+      end
+=end
+      changes = []
+      deleted = []
+      added = []
+      if a.is_a? Array
+        a.sort! { |x,y| x.id <=> y.id }
+        b.sort! { |x,y| x.id <=> y.id }
+        if a.all? { |x| x.instance_variables.include? "@id_before_type_cast"} || a.all? { |x| x.instance_variables.include? "@import_id"}
+          a_m = a.map { |x| x.id }
+          b_m = b.map { |x| x.id }
+        else
+=begin
+        ch = []
+        del = []
+        add = []
+        a.each_with_index do |element, i|
+          res = check_tree(element, b[i])
+          ch += res[:changes]
+          del += res[:deleted]
+          add += res[:added]
+        end
+=end       
+        #obsługa dodania i usunięcia elementów
+        #problematyczne są części rekordu które nie są identyfikowalne jako identyczne :(
+          a_m = a.map { |x| calculate_hash(x) }
+          b_m = b.map { |x| calculate_hash(x) }
+        end
+     #   if a.map(&:id) != b.map(&:id)
+        if a_m != b_m
+          deleted_ids = a.map(&:id) - b.map(&:id)
+          added_ids = b.map(&:id) - a.map(&:id)
+          deleted_ids.each do |id|
+            if a.find { |x| x.id == id } && !a.find { |x| x.id == id }.blank?
+              deleted << a.find { |x| x.id == id }
+              a.delete(a.find { |x| x.id == id })
+            end
+          end
+          added_ids.each do |id|
+            if b.find { |x| x.id == id } && !b.find { |x| x.id == id }.blank?
+              added << b.find { |x| x.id == id }
+              b.delete(b.find { |x| x.id == id })
+            end
+          end
+        end
+        #obsługa różnych elementów w arrayu
+        a.each_with_index do |element, i|
+          ret = check_tree(element, b[i])
+          changes += ret[:changes]
+          added += ret[:added]
+          deleted += ret[:deleted]
+        end
+      else
+        a.instance_variables.each do |attrib|
+          next if SKIPPED_ATTRIBS.include? attrib
+          attrib = attrib.to_s.gsub("@", "").to_sym
+          if a.send(attrib).is_a? Array
+            ret = check_tree(a.send(attrib), b.send(attrib))
+            changes << {attrib, ret[:changes]} if !ret[:changes].blank?
+            added << {attrib, ret[:added]} if !ret[:added].blank?
+            deleted << {attrib, ret[:deleted]} if !ret[:deleted].blank?
+          else
+            if (a.send(attrib).is_a?(String) || a.send(attrib).is_a?(Numeric) || a.send(attrib).is_a?(NilClass) || b.send(attrib).is_a?(NilClass))
+              changes << attrib if a.send(attrib) != b.send(attrib)
+            else
+              #klasa zlozona
+              ret = check_tree(a.send(attrib), b.send(attrib))
+              changes << {attrib, ret[:changes]} if !ret[:changes].blank?
+              added << {attrib, ret[:added]} if !ret[:added].blank?
+              deleted << {attrib, ret[:deleted]} if !ret[:deleted].blank?
+            end
+          end
+        end
+      end
+      return {:deleted => deleted, :added => added, :changes => changes}
+    end
+    
+    def calculate_hash(object)
+      result = []
+      if object.is_a? Array
+        object.each { |x| result << calculate_hash(x) }
+      else
+        object.instance_variables.each do |attrib|
+          next if SKIPPED_ATTRIBS.include? attrib
+          next if SKIPPED_2.include? attrib
+          attrib = attrib.to_s.gsub("@", "").to_sym
+          if object.send(attrib).is_a? Array
+            result << calculate_hash(object.send(attrib))
+          elsif object.send(attrib).is_a?(String) || object.send(attrib).is_a?(Numeric) || object.send(attrib).is_a?(Fixnum) || object.send(attrib).is_a?(Symbol)
+            result << object.send(attrib)
+          else
+            result << calculate_hash(object.send(attrib))
+          end
+        end
+      end
+      return Digest::SHA1.hexdigest(result.join("-"))
+    end
+    
+    def convert_arr_to_hash(arr)
+      {}.tap do |hash|
+        arr.each do |pair|
+          hash[pair.keys.first] = pair.values.first
+        end
+      end
+    end
+    
+  end
+  
+end

data/spec/elibri_xml_versions_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+$VERBOSE = nil #temp: supress id warnings
+describe Elibri::XmlVersions do
+
+  RAW_EXTRAS = {
+    :imprint => nil,
+    :authorship_kind => nil,
+    :contributors => [],
+    :languages => [],
+    :other_texts => [],
+    :series_membership_kind => nil,
+    :series_memberships => [],
+    :facsimiles => [],
+    :similar_products => [],
+    :product_attachments => [],
+    :product_availabilities => []
+  }
+
+  it "should return no changes for same basic elibri object" do
+    generated_product = onix_from_mock(:basic_product)
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product.products.first)
+    @elibri_xml_versions.diff.should eq({:deleted => [], :added => [], :changes => []})
+  end
+
+  it "should return no changes for same basic elibri object double generated" do
+    generated_product = onix_from_mock(:basic_product)
+    generated_product_2 = onix_from_mock(:basic_product)
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+    @elibri_xml_versions.diff.should eq({:deleted => [], :added => [], :changes => []})
+  end
+ 
+  it "should return change for different basic elibri objects" do
+    generated_product = onix_from_mock(:basic_product, :record_reference => 'fdb8fa072be774d97a97')
+    generated_product_2 = onix_from_mock(:basic_product, :record_reference => 'fdb8fa072be774d97a95')
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+    @elibri_xml_versions.diff.should eq({:deleted => [], :added => [], :changes => [:record_reference]})
+  end
+
+  it "should return no changes for same book elibri objects" do
+    generated_product = onix_from_mock(:book_example)
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product.products.first)
+    @elibri_xml_versions.diff.should eq({:deleted => [], :added => [], :changes => []})    
+  end
+
+  it "should return no changes for same book elibri objects double generated" do
+    mock = Elibri::XmlMocks::Examples.review_mock
+    generated_product = onix_from_mock(:book_example, RAW_EXTRAS.merge(:other_texts => [mock]) )
+    generated_product_2 = onix_from_mock(:book_example, RAW_EXTRAS.merge(:other_texts => [mock]) )
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+    result = @elibri_xml_versions.diff
+    (@elibri_xml_versions.convert_arr_to_hash result[:changes]).count.should eq(0) 
+  end
+
+  it "should return change for different book elibri objects" do
+    review_mock = Elibri::XmlMocks::Examples.review_mock
+    supply_details = Elibri::XmlMocks::Examples.supply_detail_mock
+    generated_product = onix_from_mock(:book_example, RAW_EXTRAS.merge(:other_texts => [review_mock], :product_availabilities => [supply_details], :record_reference => 'fdb8fa072be774d97a97'))
+    generated_product_2 = onix_from_mock(:book_example, RAW_EXTRAS.merge(:other_texts => [review_mock], :product_availabilities => [supply_details], :record_reference => 'fdb8fa072be774d97a95'))
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+    @elibri_xml_versions.diff.should eq({:deleted => [], :added => [], :changes => [:record_reference]})
+  end
+
+  it "should return added element when new review is added" do
+    generated_product = onix_from_mock(:book_example, RAW_EXTRAS.merge(:other_texts => [Elibri::XmlMocks::Examples.review_mock]))
+    generated_product_2 = onix_from_mock(:book_example, RAW_EXTRAS.merge(:other_texts => [Elibri::XmlMocks::Examples.review_mock, Elibri::XmlMocks::Examples.review_mock(:text_author => "lobuz lobuzialski")]))
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+    result = @elibri_xml_versions.diff
+    (@elibri_xml_versions.convert_arr_to_hash result[:added])[:reviews].count.should eq(2)
+    (@elibri_xml_versions.convert_arr_to_hash result[:deleted])[:reviews].count.should eq(1)
+    (@elibri_xml_versions.convert_arr_to_hash result[:added])[:text_contents].count.should eq(2)
+    (@elibri_xml_versions.convert_arr_to_hash result[:deleted])[:text_contents].count.should eq(1)
+    end
+
+    it "should return no changes for same onix_record_identifiers_example objects" do
+      generated_product = onix_from_mock(:onix_record_identifiers_example)
+      @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product.products.first)
+      @elibri_xml_versions.diff.should eq({:deleted => [], :added => [], :changes => []})    
+    end
+  
+    it "should return no changes for double generated onix_record_identifiers_example objects" do
+      generated_product = onix_from_mock(:onix_record_identifiers_example)
+      generated_product_2 = onix_from_mock(:onix_record_identifiers_example)      
+      @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+      @elibri_xml_versions.diff.should eq({:deleted => [], :added => [], :changes => []})    
+    end
+
+    SPLITTING_SYMBOLS = [
+      :publisher_name
+    ]
+  
+    SIMPLE_SYMBOLS = [
+      :publisher_name, :record_reference
+    ]
+
+    TRAVERSE_VECTOR = {
+      :or_title => :original_title,
+      :publisher_name => :publisher_name,
+      :record_reference => :record_reference,
+      :deletion_text => :deletion_text,
+      :isbn_value => :isbn13,
+      :ean => :ean,
+      :deletion_text => :deletion_text,
+      :trade_title => :trade_title,
+      :pkwiu => :pkwiu_from_3_0_1,
+      :title => :title,
+      :subtitle => :subtitle,
+      :edition_statement => :edition_statement,
+      :audience_age_from => :reading_age_from,
+      :audience_age_to => :reading_age_to,
+      :price_amount => :cover_price_from_3_0_1,
+      :vat => :vat_from_3_0_1
+    }
+
+    #strings
+    [
+      :publisher_name, :record_reference,
+      :ean, :isbn_value, :deletion_text, :or_title,
+      :trade_title, :pkwiu, :title, :subtitle, 
+      :edition_statement
+    ].each do |symbol|
+    
+      it "should return change when #{symbol} change in two books objects (one with default settings)" do
+        string = "ehdroruwnm"
+        generated_product = onix_from_mock(:book_example, RAW_EXTRAS)
+        generated_product_2 = onix_from_mock(:book_example, RAW_EXTRAS.merge(symbol => string) )
+        @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+        @elibri_xml_versions.diff[:changes].should include(TRAVERSE_VECTOR[symbol])
+      end
+ 
+      it "should return change when #{symbol} change in two books objects" do
+        string = "ehdroruwnm"
+        string2 = "TOXYAUEJ"
+        review_mock = Elibri::XmlMocks::Examples.review_mock
+        supply_details = Elibri::XmlMocks::Examples.supply_detail_mock
+        generated_product = onix_from_mock(:book_example, RAW_EXTRAS.merge(symbol => string))
+        generated_product_2 = onix_from_mock(:book_example, RAW_EXTRAS.merge(symbol => string2))
+        @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+        @elibri_xml_versions.diff[:changes].should include(TRAVERSE_VECTOR[symbol])
+      end
+    
+      it "should return change when #{symbol} change in two basic products objects (one with default settings)" do
+        string = "ehdroruwnm"
+        generated_product = onix_from_mock(:basic_product)
+        generated_product_2 = onix_from_mock(:basic_product, {symbol => string})
+        @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+        if SPLITTING_SYMBOLS.include?(symbol)
+          @elibri_xml_versions.diff[:changes].should include(symbol.to_s.split("_")[0].to_sym)
+        else
+          @elibri_xml_versions.diff[:changes].should include(TRAVERSE_VECTOR[symbol])
+        end
+      end
+    
+      it "should return change when #{symbol} change in two basic products objects" do
+        string = "ehdroruwnm"
+        string2 = "TOXYAUEJ"
+        generated_product = onix_from_mock(:basic_product, {symbol => string})
+        generated_product_2 = onix_from_mock(:basic_product, {symbol => string2})
+        @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+        @elibri_xml_versions.diff[:changes].should include(TRAVERSE_VECTOR[symbol])
+      end
+
+    #end strings  
+    end
+
+
+  #integers
+  [
+    :audience_age_from, :audience_age_to, :price_amount, :vat
+  ].each do |symbol|
+    
+    it "should return change when #{symbol} change in two books objects (one with default settings)" do
+      string = 52
+      generated_product = onix_from_mock(:book_example, RAW_EXTRAS)
+      generated_product_2 = onix_from_mock(:book_example, RAW_EXTRAS.merge(symbol => string))
+      @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+      @elibri_xml_versions.diff[:changes].should include(TRAVERSE_VECTOR[symbol])
+    end
+
+    it "should return change when #{symbol} change in two books objects" do
+      string = 52
+      string2 = 44
+      review_mock = Elibri::XmlMocks::Examples.review_mock
+      supply_details = Elibri::XmlMocks::Examples.supply_detail_mock
+      generated_product = onix_from_mock(:book_example, RAW_EXTRAS.merge(symbol => string))
+      generated_product_2 = onix_from_mock(:book_example, RAW_EXTRAS.merge(symbol => string2))
+      @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+      @elibri_xml_versions.diff[:changes].should include(TRAVERSE_VECTOR[symbol])
+    end
+  
+    it "should return change when #{symbol} change in two basic products objects (one with default settings)" do
+      string = 52
+      generated_product = onix_from_mock(:basic_product)
+      generated_product_2 = onix_from_mock(:basic_product, {symbol => string})
+      @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+      if SPLITTING_SYMBOLS.include?(symbol)
+        @elibri_xml_versions.diff[:changes].should include(symbol.to_s.split("_")[0].to_sym)
+      else
+        @elibri_xml_versions.diff[:changes].should include(TRAVERSE_VECTOR[symbol])
+      end
+    end
+  
+    it "should return change when #{symbol} change in two basic products objects" do
+      string = 52
+      string2 = 44
+      generated_product = onix_from_mock(:basic_product, {symbol => string})
+      generated_product_2 = onix_from_mock(:basic_product, {symbol => string2})
+      @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+      @elibri_xml_versions.diff[:changes].should include(TRAVERSE_VECTOR[symbol])
+    end
+    
+  #end of integers  
+  end  
+
+  it "should detect change in object inside basic product" do
+    imprint = Elibri::XmlMocks::Examples.imprint_mock
+    imprint_2 = Elibri::XmlMocks::Examples.imprint_mock(:name => 'second')
+    generated_product = onix_from_mock(:basic_product, {:imprint => imprint})
+    generated_product_2 = onix_from_mock(:basic_product, {:imprint => imprint_2})
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+    @elibri_xml_versions.diff[:changes].should include({:imprint => [:name]})
+  end
+
+  it "should detect change in object inside book product" do
+    imprint = Elibri::XmlMocks::Examples.imprint_mock
+    imprint_2 = Elibri::XmlMocks::Examples.imprint_mock(:name => 'second')
+    generated_product = onix_from_mock(:book_example, RAW_EXTRAS.merge({:imprint => imprint}))
+    generated_product_2 = onix_from_mock(:book_example, RAW_EXTRAS.merge({:imprint => imprint_2}))
+    @elibri_xml_versions = Elibri::XmlVersions.new(generated_product.products.first, generated_product_2.products.first)
+    @elibri_xml_versions.diff[:changes].should include({:imprint => [:name]})
+  end
+ 
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec'
+require 'ostruct'
+#require 'mocha'
+require 'elibri_xml_versions' # and any other gems you need
+require 'elibri_onix_mocks'
+=begin
+require 'support/mocks/xml_mocks'
+require 'support/mocks/mock_method_missing'
+require 'support/generators/xml_generator'
+require 'support/xml_variant'
+require 'support/onix_helpers'
+=end
+
+
+
+
+RSpec.configure do |config|
+  # some (optional) config here
+end
+
+def onix_from_mock(sym, *args)
+  Elibri::ONIX::Release_3_0::ONIXMessage.from_xml(Elibri::ONIX::XMLGenerator.new(Elibri::XmlMocks::Examples.send(sym, *args)).to_s)
+end
+
+def xml_parse(xml_string)
+  Elibri::ONIX::Release_3_0::ONIXMessage.from_xml(xml_string)
+end
+
+def generate_xml(mock)
+  Elibri::ONIX::XMLGenerator.new(mock)
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification 
+name: elibri_xml_versions
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Piotr Szmielew
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-05 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: elibri_onix_mocks
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: elibri_api_client
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: elibri_onix_dict
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+description: |-
+  Gem created for comparing eLibri xml objects. More info coming soon. Currently working and tested only on REE.
+  Basic usage: Elibri::XmlVersions.new(product_ver1, product_ver2).diff
+  it will return hash: {:added => [], :changes => [], :deleted => []}
+email: 
+- p.szmielew@ava.waw.pl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- elibri_xml_versions.gemspec
+- lib/elibri_xml_versions.rb
+- lib/elibri_xml_versions/version.rb
+- spec/elibri_xml_versions_spec.rb
+- spec/spec_helper.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: elibri_xml_versions
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Gem created for comparing eLibri xml objects.
+test_files: 
+- spec/elibri_xml_versions_spec.rb
+- spec/spec_helper.rb