yadtfp 1.0.2

data/lib/yadtfp/parsers_factory.rb

@@ -0,0 +1,24 @@
+require 'yadtfp/parsers/ox'
+
+
+module Yadtfp
+
+  class ParsersFactory
+
+    # Creates and returns parser defined for the supplied parser parameter.
+    #
+    # Note that parameter `parser` needs to be a symbol.
+    # The allowed values for `parser` is:
+    #   :ox
+    #
+    # Raises `ArgumentError` if `parser` is not one one of the values specified above.
+    def self.create(parser)
+
+      return Parsers::Ox.new if parser == :ox
+
+      raise ArgumentError, "Invalid parser `#{parser}`"
+
+    end
+
+  end
+end

data/lib/yadtfp/version.rb

@@ -0,0 +1,3 @@
+module Yadtfp
+  VERSION = "1.0.2".freeze
+end

data/spec/cli_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'yadtfp/cli'
+
+
+describe Yadtfp::CLI do
+
+  describe '#diff' do
+
+    let(:cli) { Yadtfp::CLI.new }
+
+
+
+    it 'when default options' do
+      config = instance_double(Yadtfp::Configuration, parser: :ox, outputter: :pretty)
+
+      expect(Yadtfp::Configuration).to receive(:parse_options).with({}).and_return(config)
+
+      parser = instance_double(Yadtfp::Parsers::Ox)
+      expect(Yadtfp::ParsersFactory).to receive(:create).with(:ox).and_return(parser)
+
+
+      file1, file2 = double('file1'), double('file2')
+      left, right = double('left'), double('right')
+
+
+      expect(parser).to receive(:parse).with(file1).and_return(left)
+      expect(parser).to receive(:parse).with(file2).and_return(right)
+
+
+      diff = double('diff')
+      expect(parser).to receive(:diff).with(left, right).and_return(diff)
+
+
+      outputter = instance_double(Yadtfp::Outputters::Pretty)
+      expect(Yadtfp::OutputtersFactory).to receive(:create).with(:pretty, diff).and_return(outputter)
+      expect(outputter).to receive(:print)
+
+
+      cli.diff(file1, file2)
+    end
+
+  end
+
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe 'Configuration' do
+
+  let(:config) { Yadtfp::Configuration.instance }
+
+
+
+  describe '#initialize' do
+
+
+    it 'does not allow instantiation of singleton Configuration class' do
+      expect{ Yadtfp::Configuration.new }.to raise_error(NoMethodError)
+    end
+
+
+
+
+    context 'filter' do
+
+      it 'defaults filter to *' do
+        expect(config.filter).to eq '*'
+      end
+
+    end
+
+
+
+
+    context 'parser' do
+
+      it 'defaults parser to :ox' do
+        expect(config.parser).to eq :ox
+      end
+
+    end
+
+
+
+
+    context 'outputter' do
+
+      it 'default outputter' do
+        expect(config.outputter).to eq(:pretty)
+      end
+
+    end
+
+  end
+
+
+
+
+  describe '#parser=' do
+
+    it 'when nil' do
+      expect { config.parser = nil }.to raise_error(ArgumentError)
+    end
+
+
+
+
+    it 'when invalid type' do
+      parser = double('foo')
+      allow(parser).to receive(:respond_to?).with(:to_sym).and_return(false)
+      expect { config.parser = parser }.to raise_error(ArgumentError)
+    end
+
+  end
+
+
+
+
+  describe '#outputter=' do
+
+    it 'when nil' do
+      expect { config.outputter = nil }.to raise_error(ArgumentError)
+    end
+
+
+
+
+    it 'when invalid type' do
+      outputter = double('foo')
+      allow(outputter).to receive(:respond_to?).with(:to_sym).and_return(false)
+      expect { config.outputter = outputter }.to raise_error(ArgumentError)
+    end
+
+  end
+
+
+
+
+  describe '.parse_options' do
+
+    it 'when valid hash' do
+      options = { filter: '*', parser: 'ox', outputter: 'pretty' }
+      config = Yadtfp::Configuration.parse_options(options)
+
+      expect(config.filter).to eq '*'
+      expect(config.parser).to eq :ox
+      expect(config.outputter).to eq :pretty
+    end
+
+
+
+
+    it 'when nil' do
+      expect { Yadtfp::Configuration.parse_options(nil) }.to raise_error(ArgumentError)
+    end
+
+  end
+
+
+end

data/spec/outputters/diffable_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+shared_examples_for 'Yadtfp::Outputters::Diffable' do
+
+
+  describe '#initialize' do
+
+    it 'responds to `diff` array' do
+      expect(described_class.new).to respond_to(:diff)
+    end
+
+
+
+
+    it 'when empty array' do
+      described_object = described_class.new([])
+      expect(described_object.instance_variable_get(:@diff)).to eq([])
+    end
+
+
+
+
+    it 'when initialized with nil' do
+      expect{ described_class.new(nil) }.to raise_error(ArgumentError)
+    end
+
+
+
+
+    it 'when initialized without arguments do' do
+      described_object = described_class.new
+      expect{ described_object }.not_to raise_error
+
+      expect(described_object.instance_variable_get(:@diff)).to eq([])
+    end
+
+  end
+
+
+
+
+
+  describe '#changes' do
+
+    let(:diff) { [{ type: 'c' }] }
+
+
+
+    it 'when changes exist' do
+      obj = described_class.new(diff)
+      expect(obj.changes).to be_a ::Array
+      expect(obj.changes.length).to eq(1)
+    end
+
+
+
+    it 'when changes do not exist' do
+      obj = described_class.new
+      expect(obj.changes).to be_a ::Array
+      expect(obj.changes.length).to eq(0)
+    end
+
+  end
+
+
+
+
+
+  describe '#appends' do
+
+    let(:diff) { [{ type: 'a' }] }
+
+
+
+    it 'when appends exist' do
+      obj = described_class.new(diff)
+      expect(obj.appends).to be_a ::Array
+      expect(obj.appends.length).to eq(1)
+    end
+
+
+
+
+    it 'when appends do not exist' do
+      obj = described_class.new
+      expect(obj.appends).to be_a ::Array
+      expect(obj.appends.length).to eq(0)
+    end
+
+  end
+
+
+
+
+
+  describe '#deletes' do
+
+    let(:diff) { [{ type: 'd' }] }
+
+
+
+    it 'when deletes exist' do
+      obj = described_class.new(diff)
+      expect(obj.deletes).to be_a ::Array
+      expect(obj.deletes.length).to eq(1)
+    end
+
+
+
+
+    it 'when deletes do not exist' do
+      obj = described_class.new
+      expect(obj.deletes).to be_a ::Array
+      expect(obj.deletes.length).to eq(0)
+    end
+
+  end
+
+end

data/spec/outputters/pretty_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+require 'outputters/diffable_spec'
+
+
+describe Yadtfp::Outputters::Pretty do
+
+  it_behaves_like 'Yadtfp::Outputters::Diffable'
+
+
+  describe '#print' do
+
+    it 'prints diff' do
+      pretty = Yadtfp::Outputters::Pretty.new([])
+
+      expect(Yadtfp::Outputters::Pretty::TYPES).to receive(:map).ordered.with(any_args).and_return([])
+      expect(pretty).to receive(:repeatc).with("\xA", 1)
+      expect(pretty).to receive(:summary)
+
+      expect(pretty.print).to be_nil
+    end
+
+  end
+
+
+
+
+
+  describe '#header' do
+
+
+    it "when change 'c'" do
+      diff = [{ type: 'c' }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      header = "Changes (Replace left value with right value)"
+      header << "\xA#{ "-" * header.length }\xA"
+
+      expect(pretty.header('c')).to eq(header)
+    end
+
+
+
+
+    it "when append 'a'" do
+      diff = [{ type: 'a' }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      header = "Appends (Add values to left)"
+      header << "\xA#{ "-" * header.length }\xA"
+
+      expect(pretty.header('a')).to eq(header)
+    end
+
+
+
+
+    it "when delete 'd'" do
+      diff = [{ type: 'd' }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      header = "Deletes (Remove values from left)"
+      header << "\xA#{ "-" * header.length }\xA"
+
+      expect(pretty.header('d')).to eq(header)
+    end
+
+
+
+
+    it 'when invalid type' do
+      pretty = Yadtfp::Outputters::Pretty.new([])
+
+      expect(pretty.header(nil)).to eq('')
+    end
+
+  end
+
+
+
+
+
+  describe '#body' do
+
+    it "when change is single" do
+      diff = [{ type: 'c', path: '/xml/@id', lvalue: 'root', rvalue: 'root_node' }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      body = pretty.changes.to_enum.with_index(1).inject("") do |body, (diff, index)|
+        body << "\xA#{index}.\x20Path:\x20/xml/@id"
+        body << "\xA#{ "\x20" * 3 }Left:\x20root"
+        body << "\xA#{ "\x20" * 3 }Right:\x20root_node"
+        body << "\xA"
+      end
+      body << "\xA"
+
+      expect(pretty.body('c')).to eq(body)
+    end
+
+
+
+
+    it "when append is single" do
+      diff = [{ type: 'a', path: '/xml/@id', lvalue: nil, rvalue: 'root' }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      body = pretty.appends.to_enum.with_index(1).inject("") do |body, (diff, index)|
+        body << "\xA#{index}.\x20Path:\x20/xml/@id"
+        body << "\xA#{ "\x20" * 3 }Left:\x20"
+        body << "\xA#{ "\x20" * 3 }Right:\x20root"
+        body << "\xA"
+      end
+      body << "\xA"
+
+      expect(pretty.body('a')).to eq(body)
+    end
+
+
+
+
+
+    it 'when append is multiple' do
+      diff = [{ type: 'a', path: '/xml/@id', lvalue: nil, rvalue: [ 'root', 'root_node' ] }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      body = "#{"\xA"}1.\x20Path:\x20/xml/@id\xA"
+      body << "#{ "\x20" * 3 }Left:\x20\xA"
+      body << "#{ "\x20" * 3 }Right:\x20\xA"
+      body << "#{ "\x20" * 5}1.\x20root\xA"
+      body << "#{ "\x20" * 5}2.\x20root_node\xA"
+      body << "\xA"
+
+      expect(pretty.body('a')).to eq(body)
+    end
+
+
+
+
+    it 'when append contains nil right' do
+      diff = [{ type: 'a', rvalue: nil }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      expect { pretty.body('a') }.to raise_error(Yadtfp::Outputters::TypeValuesMismatchError)
+    end
+
+
+
+
+
+    it "when delete is string type" do
+      diff = [{ type: 'd', path: '/xml/@id', lvalue: 'root', rvalue: nil }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      body = pretty.deletes.to_enum.with_index(1).inject("") do |body, (diff, index)|
+        body << "\xA#{index}.\x20Path:\x20/xml/@id"
+        body << "\xA#{ "\x20" * 3 }Left:\x20root"
+        body << "\xA#{ "\x20" * 3 }Right:\x20"
+        body << "\xA"
+      end
+      body << "\xA"
+
+      expect(pretty.body('d')).to eq(body)
+    end
+
+
+
+
+
+    it 'when delete is multiple' do
+      diff = [{ type: 'd', path: '/xml/@id', lvalue: [ 'root', 'root_node' ], rvalue: nil }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      body = "#{"\xA"}1.\x20Path:\x20/xml/@id"
+      body << "\xA#{ "\x20" * 3 }Left:\x20\xA"
+      body << "#{ "\x20" * 5}1.\x20root\xA"
+      body << "#{ "\x20" * 5}2.\x20root_node\xA"
+      body << "#{ "\x20" * 3 }Right:\x20\xA"
+      body << "\xA"
+
+      expect(pretty.body('d')).to eq(body)
+    end
+
+
+
+
+
+    it 'when delete contains nil left' do
+      diff = [{ type: 'd', lvalue: nil }]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      expect { pretty.body('d') }.to raise_error(Yadtfp::Outputters::TypeValuesMismatchError)
+    end
+
+
+
+
+
+    it 'when invalid type' do
+      pretty = Yadtfp::Outputters::Pretty.new([])
+
+      expect(pretty.body(nil)).to eq('')
+    end
+
+  end
+
+
+
+
+
+  describe '#summary' do
+
+
+    it 'when contains changes, appends and deletes' do
+      diff = [
+        { type: 'c', path: '/xml/@id', lvalue: 'root', rvalue: 'new_root' },
+        { type: 'a', path: '/xml/@name', lvalue: nil, rvalue: 'Root node' },
+        { type: 'd', path: '/xml/@class', lvalue: 'root', rvalue: nil }
+      ]
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      summary = "Summary of differences"
+      summary << "\xA#{ "-" * summary.length }\xA"
+      summary << "Number of differences: 3"
+      summary << "\xA Changes 'c': 1"
+      summary << "\xA Appends 'a': 1"
+      summary << "\xA Deletes 'd': 1"
+      summary << "\xA"
+
+      expect(pretty.summary).to eq(summary)
+    end
+
+
+
+
+    it 'when empty diff' do
+      diff = []
+
+      pretty = Yadtfp::Outputters::Pretty.new(diff)
+
+      summary = "Summary of differences"
+      summary << "\xA#{ "-" * summary.length }\xA"
+      summary << "Number of differences: 0"
+      summary << "\xA"
+
+      expect(pretty.summary).to eq(summary)
+    end
+
+  end
+
+end