nokogiri-notepad 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69b59cae51bfba530ba00d49ef8938bb05a6340a
+  data.tar.gz: c1058b552c699c44d79d72555efb8e215b000124
+SHA512:
+  metadata.gz: '09034313e1f6116cf247cfefdcdb745091410f823a5e2ad9d1e519eaf576d8f4b522e70b23b1f5ded1f367a195f5e8a1c00c82ae84f198f6a924c1a53ca93ecf'
+  data.tar.gz: ce990d9228442f6f26076a36411c99d46382ad4ad25aa8bf5f9a4bba9cc6bbcd5e2aecfc2b1d59cd6542e93a07aa3a45bd42e798f6bfb4f28aef96e8c1abd90c

data/Gemfile

@@ -0,0 +1,2 @@
+gem "nokogiri"
+gem "nikkou"

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009, Nick Quaranto
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# What is nokogiri-notepad?
+
+Nokogiri-notepad is a Ruby Gem for easily extracting information from an xml file according the paths provided by Notepad++
+
+# Installation
+
+To download the gem do
+
+```
+gem install 'nokogiri-notepad'
+```
+
+or to include it in your gemfile do
+
+```ruby
+# Gemfile
+
+gem 'nokogiri-notepad'
+```
+
+and then do `bundle install`
+
+# Usage
+
+First create a parser object. This parser object takes three mandatory arguments and one optional.
+
+The mandatory arguments are: 
+ 
+- file_path -> This is the absolute path to the xml file you want to process
+- single_targets -> This is a hash containing with:
+  - keys being the names of the methods you would like available on the parser instance
+  - values being the path given to you by Notepad++ (by highlighting the value of the node and clicking `Ctrl + Shift + Alt + P`). Note they are always given as an array.
+- multiple targets -> Sometimes a path will give you multiple nodes back. This hash is similar in construction to the single_targets except it will give you a method that will return an array of strings
+- The Parser initalize method will only accept files with an xml extension by default. You can add an array of extensions to be accepted instead if you wish
+
+### Example `target_hash`
+
+```xml
+<plane>
+   <year> 1977 </year>
+   <make> Cessna </make>
+   <model> Skyhawk </model>
+   <color> Light blue and white </color>
+</plane>
+```
+
+If we want to target "1977" and "Cessna" saved on our `parser` instance our `single_target` hash would contain
+
+```ruby
+single_targets = { "year" => ["/plane/year"], "make" => ["/plane/make"] }
+```
+
+Our parser instance would then have the following attributes
+
+```ruby
+parser.year // "1977"
+parser.make // "Cessna"
+```
+
+Sometimes we can get more complex xml files like below, where it is more difficult to target specific nodes. Let's say we want to target the "Tripacer" node. We would need to specify a node in the group that is unique. This will give us the group of nodes, from which we can access our target node. If we just give the path `planes/plane/model` this leads us to both "Centurian" and "Tripacer", which is not what we want. Instead we can do
+
+```ruby
+single_targets = { "model" => ["/planes/plane/foo", "four", "model"] }
+```
+
+```xml
+<planes>
+   <plane>
+      <foo> three </foo>      
+      <year> 1960 </year>
+      <make> Cessna </make>
+      <model> Centurian </model>
+      <color> Yellow and white </color>
+   </plane>
+   <plane>
+      <foo> four </foo>
+      <year> 1956 </year>
+      <make> Piper </make>
+      <model> Tripacer </model>
+      <color> Blue </color>
+   </plane>
+</planes>
+```
+
+If we wanted to capture both "Centurian" and "Tripacer" above we would define the path in our multiple_targets hash
+
+```ruby
+multiple_targets = { "model" => ["/planes/plane/model"] }
+```
+
+This would give us the following getter method available on our instance
+
+```ruby
+parser.model // ["Centurian", "Tripacer"]
+```
+
+

data/Rakefile

@@ -0,0 +1,7 @@
+task default: %w[test]
+
+desc "Run Tests"
+task :test do
+  ruby "test/tc_node_finder.rb"
+  ruby "test/tc_parser.rb"
+end

data/lib/custom_errors.rb

@@ -0,0 +1,7 @@
+module NokogiriNotepad
+  class ExtensionArgumentMustBeArray < StandardError; end
+  class ExtensionElementsMustBeStrings < StandardError; end
+  class InvalidDataTypeForTargets < StandardError; end
+  class InvalidFileName < StandardError; end
+  class InvalidExtension < StandardError; end
+end

data/lib/node_finder.rb

@@ -0,0 +1,62 @@
+module NokogiriNotepad
+  class NodeFinder
+    def initialize(doc)
+      @doc = doc
+    end
+
+    def find_node_at(path, code=nil, tag_name=nil)
+      begin
+        nodes = @doc.remove_namespaces!.xpath(render(path))
+      rescue NoMethodError
+        return nil
+      end
+
+      if !(code || tag_name)
+        node = nodes.first || nil
+      else
+        matching_nodes = nodes.select do |node|
+                         return nil if node.nil?
+                         node.children.to_s.try(:strip) == code
+                       end
+        return nil if matching_nodes.first.nil?
+        return nil if matching_nodes.first.parent.at(".//#{tag_name}").nil?
+
+        node = matching_nodes.first.parent.at(".//#{tag_name}")
+      end
+      node
+    end
+
+    def find_grouped_nodes_at(path, code=nil, tag_name=nil)
+      begin
+        nodes = @doc.remove_namespaces!.xpath(render(path))
+      rescue NoMethodError
+        return nil
+      end
+
+      return nil if nodes.empty?
+
+      if !(code || tag_name)
+        node = nodes.first || nil
+      else
+        matching_nodes = nodes.select do |node|
+                         return nil if node.nil?
+                         node.children.to_s.try(:strip) == code
+                       end
+
+        return nil if matching_nodes.first.nil?
+        return nil if matching_nodes.first.parent.at(".//#{tag_name}").nil?
+
+        nodes = matching_nodes.map do |node|
+          node.parent.at(".//#{tag_name}")
+        end
+      end
+      nodes
+    end
+
+    private
+
+    def render(path)
+      path.gsub(/\//, "//")
+    end
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,102 @@
+require 'nokogiri'
+require 'nikkou'
+require_relative 'node_finder'
+require_relative 'custom_errors'
+
+module NokogiriNotepad
+  class Parser
+    attr_accessor :accepted_extensions
+    attr_reader :file_path, :single_targets, :multiple_targets
+
+    def initialize(file_path, single_targets, multiple_targets, extensions = nil)
+      @file_path = file_path
+      @single_targets = single_targets
+      @multiple_targets = multiple_targets
+      @accepted_extensions = [".xml"]
+      add_extensions(extensions) if extensions
+      validate_input
+      doc = load_nokogiri_doc file_path
+      @node_finder = NodeFinder.new doc
+      initialize_data
+      doc = nil
+      @node_finder = nil
+    end
+    
+    def extensions
+      @accepted_extensions
+    end
+
+    private
+
+    def add_extensions(extensions)
+      raise ExtensionArgumentMustBeArray unless extensions.kind_of?(Array)
+      extensions.each do |ext| 
+        raise ExtensionElementsMustBeStrings unless ext.kind_of? String
+        @accepted_extensions << ext
+      end
+    end
+
+    def validate_input
+      validate_file_path
+      validate_targets
+    end
+
+    def validate_file_path
+      raise InvalidFileName, "#{file_path} is too long" unless file_path.length < 255
+      raise InvalidFileName unless File.file?(file_path)
+      raise InvalidExtension unless extension_valid?
+    end
+
+    def validate_targets
+      raise InvalidDataTypeForTargets unless single_targets.kind_of?(Hash)
+      raise InvalidDataTypeForTargets unless multiple_targets.kind_of?(Hash)
+
+    end
+
+    def load_nokogiri_doc(file_path)
+      Nokogiri::XML(File.open(file_path))
+    end
+
+    def initialize_data
+      initialize_single_target_data
+      initialize_multiple_target_data
+    end
+
+    def initialize_single_target_data
+      @single_targets.each do |key, path|
+        self.instance_variable_set("@#{key}", data_at_attr(key))
+        create_method(key) { self.instance_variable_get("@#{key}") }
+      end
+    end
+
+    def data_at_attr(target)
+      path = @single_targets[target]
+      node = @node_finder.find_node_at(*path)
+      node.nil? ? nil : node.content.strip
+    end
+
+    def initialize_multiple_target_data
+      @multiple_targets.each do |key, path|
+        self.instance_variable_set("@#{key}", multiple_data_at_attr(key))
+        create_method(key) { self.instance_variable_get("@#{key}") }
+      end
+    end
+
+    def multiple_data_at_attr(target)
+      path = @multiple_targets[target]
+      nodes = @node_finder.find_grouped_nodes_at(*path)
+      return nil if nodes.nil? || nodes.empty?
+      nodes.map do |node|
+        node.nil? ? nil : node.content.strip
+      end
+    end
+
+    def create_method(name, &block)
+      self.class.send(:define_method, name, &block)
+    end
+
+    def extension_valid?
+      accepted_extensions.include? File.extname(file_path)
+    end
+  end
+end

data/test/tc_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'nokogiri'
+require 'pry'
+require 'nikkou'
+require 'minitest/autorun'
+require 'node_finder'
+require 'parser'
+

data/test/tc_node_finder.rb

@@ -0,0 +1,102 @@
+require_relative "tc_helper"
+
+class BasicTest < Minitest::Test
+  def setup
+    @file_path = "#{File.dirname(__FILE__)}/test_files/xslplanes.1.xml"
+    @doc = Nokogiri::XML(File.open(@file_path))
+    @file_path2 = "#{File.dirname(__FILE__)}/test_files/xslplanes.2.xml"
+    @doc2 = Nokogiri::XML(File.open(@file_path2))
+    @file_path3 = "#{File.dirname(__FILE__)}/test_files/xslplanes.3.xml"
+    @doc3 = Nokogiri::XML(File.open(@file_path3))
+  end
+
+  def test_initialize_node_finder
+    node_finder = NokogiriNotepad::NodeFinder.new @doc
+    assert_equal(NokogiriNotepad::NodeFinder, node_finder.class)
+  end
+
+  def test_initialize_node_finder_with_invalid_doc
+    node_finder = NokogiriNotepad::NodeFinder.new nil 
+    assert_equal(NokogiriNotepad::NodeFinder, node_finder.class)
+  end
+
+  def test_find_node_at_when_doc_is_nil
+    node_finder = NokogiriNotepad::NodeFinder.new nil
+    node = node_finder.find_node_at 'path'
+    assert_nil(node)
+  end
+
+  def test_find_grouped_nodes_at_when_doc_is_nil
+    node_finder = NokogiriNotepad::NodeFinder.new nil
+    node = node_finder.find_grouped_nodes_at 'path'
+    assert_nil(node)
+  end
+
+  def test_find_node_when_invalid_path_given
+    node_finder = NokogiriNotepad::NodeFinder.new @doc
+    node = node_finder.find_node_at 'path'
+    assert_nil(node)
+  end
+
+  def test_find_grouped_node_at_when_invalid_path_given
+    node_finder = NokogiriNotepad::NodeFinder.new @doc
+    node = node_finder.find_grouped_nodes_at 'path'
+    assert_nil(node)
+  end
+
+  def test_find_node_at_returns_expected_string
+    node_finder = NokogiriNotepad::NodeFinder.new @doc
+    node = node_finder.find_node_at "/plane/make"
+    assert_equal("Cessna", node.content.strip)
+  end
+
+  def test_find_node_at_returns_expected_string_when_code_and_tagname_given
+    node_finder = NokogiriNotepad::NodeFinder.new @doc2
+    node = node_finder.find_node_at "/planes/plane/foo", "four", "color"
+    assert_equal("Blue", node.content.strip)
+  end
+
+  def test_find_node_at_when_invalid_code_and_tag_name_given
+    node_finder = NokogiriNotepad::NodeFinder.new @doc2
+    node = node_finder.find_node_at '/planes/plane/foo', 'path', 'path'
+    assert_nil(node)
+  end
+
+  def test_find_node_at_when_all_args_are_invalid
+    node_finder = NokogiriNotepad::NodeFinder.new @doc2
+    node = node_finder.find_node_at 'path', 'path', 'path'
+    assert_nil(node)
+  end
+
+  def test_find_grouped_nodes_at_when_invalid_code_and_tag_name_given
+    node_finder = NokogiriNotepad::NodeFinder.new @doc2
+    node = node_finder.find_grouped_nodes_at '/planes/plane/foo', 'path', 'path'
+    assert_nil(node)
+  end
+
+  def test_find_grouped_nodes_at_when_all_args_are_invalid
+    node_finder = NokogiriNotepad::NodeFinder.new @doc2
+    node = node_finder.find_grouped_nodes_at 'path', 'path', 'path'
+    assert_nil(node)
+  end
+
+  def test_find_grouped_nodes_at_when_all_args_are_invalid
+    node_finder = NokogiriNotepad::NodeFinder.new @doc2
+    node = node_finder.find_grouped_nodes_at 'path', 'path', 'path'
+    assert_nil(node)
+  end
+
+  def test_find_grouped_nodes_at_when_valid_path
+    node_finder = NokogiriNotepad::NodeFinder.new @doc3
+    nodes = node_finder.find_grouped_nodes_at '/planes/plane/year'
+    nodes = nodes.map { |n| n.nil? ? nil : n.content.strip}
+    assert_equal(["1977", "1975", "1960", "1956", "1977_2", "1975_2", "1960_2", "1956_2"], nodes)
+  end
+
+  def test_find_grouped_nodes_at_when_valid_args
+    node_finder = NokogiriNotepad::NodeFinder.new @doc3
+    nodes = node_finder.find_grouped_nodes_at '/planes/plane/foo', 'four', 'color'
+    nodes = nodes.map { |n| n.nil? ? nil : n.content.strip}
+    assert_equal(["Blue", "Blue_2"], nodes)
+  end
+end

data/test/tc_parser.rb

@@ -0,0 +1,99 @@
+require_relative "tc_helper"
+
+class BasicTest < Minitest::Test
+  def setup
+    @file_path = "#{File.dirname(__FILE__)}/test_files/xslplanes.1.xml"
+    @file_path2 = "#{File.dirname(__FILE__)}/test_files/xslplanes.2.xml"
+    @file_path3 = "#{File.dirname(__FILE__)}/test_files/xslplanes.3.xml"
+    @file_path4 = "#{File.dirname(__FILE__)}/test_files/xslplanes.1.xmx"
+
+    @single_targets = { "year" => ["/plane/year"], "make" => ["/plane/make"] }
+    @single_targets2 = { "color" => ["/planes/plane/foo", "four", "color"], "model" => ["/planes/plane/foo", "two", "model"] }
+    @multiple_targets = { "multiple_year" => ["/plane/year"], "multiple_make" => ["/plane/make"] }
+    @multiple_targets2 = { "multiple_color" => ["/planes/plane/foo", "four", "color"], "multiple_model" => ["/planes/plane/foo", "three", "model"] }
+  end
+
+  def test_initializing_with_invalid_xml_file
+    invalid_path = "#{File.dirname(__FILE__)}/test_files/invalid.xml"
+    parser = NokogiriNotepad::Parser.new(invalid_path, @single_targets, @multiple_targets)
+    assert_nil(parser.year)
+    assert_nil(parser.make)
+  end
+
+  def test_inititalizing_with_valid_extension_adds_extensions_to_accepted_extensions
+    extensions = [".foo", ".bar"]
+    parser = NokogiriNotepad::Parser.new(@file_path, @single_targets, @multiple_targets, extensions)
+    assert_equal(parser.extensions, [".xml", ".foo", ".bar"])
+  end
+
+  def test_inititalizing_with_invalid_extension_raises_error
+    extensions = ".foo"
+    assert_raises NokogiriNotepad::ExtensionArgumentMustBeArray do
+      NokogiriNotepad::Parser.new(@file_path, @single_targets, @multiple_targets, extensions)
+    end
+  end
+
+  def test_initializing_with_invalid_extension_objects_raises_error
+    extensions = [[".foo"]]
+    assert_raises NokogiriNotepad::ExtensionElementsMustBeStrings do
+      NokogiriNotepad::Parser.new(@file_path, @single_targets, @multiple_targets, extensions)
+    end
+  end
+
+  def test_initializing_with_invalid_single_targets_raises_error
+    assert_raises NokogiriNotepad::InvalidDataTypeForTargets do
+      NokogiriNotepad::Parser.new(@file_path, "foo", @multiple_targets)
+    end
+  end
+
+  def test_initializing_with_invalid_multiple_targets_raises_error
+    assert_raises NokogiriNotepad::InvalidDataTypeForTargets do
+      NokogiriNotepad::Parser.new(@file_path, @single_targets, "foo")
+    end
+  end
+
+  def test_parser_has_correct_attributes
+    parser = NokogiriNotepad::Parser.new(@file_path, @single_targets, @multiple_targets)
+    assert_equal(parser.year, "1977")
+    assert_equal(parser.make, "Cessna")
+  end
+
+  def test_parser_has_correct_attributes_for_single_targets
+    parser = NokogiriNotepad::Parser.new(@file_path, @single_targets, @multiple_targets)
+    assert_equal(parser.year, "1977")
+    assert_equal(parser.make, "Cessna")
+  end
+
+  def test_parser_has_correct_attributes_for_single_targets_with_targeted_node
+    parser = NokogiriNotepad::Parser.new(@file_path2, @single_targets2, @multiple_targets)
+    assert_equal(parser.color, "Blue")
+    assert_equal(parser.model, "Apache")
+  end
+
+  def test_parser_has_correct_attributes_for_multiple_targets
+    parser = NokogiriNotepad::Parser.new(@file_path2, @single_targets, @multiple_targets)
+    assert_equal(parser.multiple_year, ["1977", "1975", "1960", "1956"])
+    assert_equal(parser.multiple_make, ["Cessna", "Piper", "Cessna", "Piper"])
+  end
+
+  def test_parser_has_correct_attributes_for_multiple_targets_with_targeted_node
+    parser = NokogiriNotepad::Parser.new(@file_path3, @single_targets, @multiple_targets2)
+    assert_equal(parser.multiple_color, ["Blue", "Blue_2"])
+    assert_equal(parser.multiple_model, ["Centurian", "Centurian_2"])
+  end
+
+  def test_parser_throws_error_if_initialized_with_invalid_extension_file
+    assert_raises NokogiriNotepad::InvalidExtension do
+      parser = NokogiriNotepad::Parser.new(@file_path4, @single_targets, @multiple_targets2)
+    end
+  end
+
+  def test_parser_has_correct_attributes_when_extension_defined
+    def test_parser_has_correct_attributes_for_single_targets
+      parser = NokogiriNotepad::Parser.new(@file_path4, @single_targets, @multiple_targets, [".xmx"])
+      assert_equal(parser.year, "1977")
+      assert_equal(parser.make, "Cessna")
+    end
+  end
+  
+end

data/test/test_files/xslplanes.1.xml

@@ -0,0 +1,9 @@
+<?xml version = "1.0" encoding = "utf-8"?>
+<!-- xslplane.1.xml -->
+<?xml-stylesheet type = "text/xsl"  href = "xslplane.1.xsl" ?>
+<plane>
+   <year> 1977 </year>
+   <make> Cessna </make>
+   <model> Skyhawk </model>
+   <color> Light blue and white </color>
+</plane>

data/test/test_files/xslplanes.1.xmx

@@ -0,0 +1,9 @@
+<?xml version = "1.0" encoding = "utf-8"?>
+<!-- xslplane.1.xml -->
+<?xml-stylesheet type = "text/xsl"  href = "xslplane.1.xsl" ?>
+<plane>
+   <year> 1977 </year>
+   <make> Cessna </make>
+   <model> Skyhawk </model>
+   <color> Light blue and white </color>
+</plane>

data/test/test_files/xslplanes.2.xml

@@ -0,0 +1,33 @@
+<?xml version = "1.0" encoding = "utf-8"?>
+<!-- xslplanes.2.xml -->
+<?xml-stylesheet type = "text/xsl" href = "xslplanes.2.xsl" ?>
+<planes>
+   <plane>
+      <foo> one </foo>
+      <year> 1977 </year>
+      <make> Cessna </make>
+      <model> Skyhawk </model>
+      <color> Light blue and white </color>
+   </plane>
+   <plane>
+      <foo> two </foo>
+      <year> 1975 </year>
+      <make> Piper </make>
+      <model> Apache </model>
+      <color> White </color>
+   </plane>   
+   <plane>
+      <foo> three </foo>      
+      <year> 1960 </year>
+      <make> Cessna </make>
+      <model> Centurian </model>
+      <color> Yellow and white </color>
+   </plane>
+   <plane>
+      <foo> four </foo>
+      <year> 1956 </year>
+      <make> Piper </make>
+      <model> Tripacer </model>
+      <color> Blue </color>
+   </plane>
+</planes>

data/test/test_files/xslplanes.3.xml

@@ -0,0 +1,61 @@
+<?xml version = "1.0" encoding = "utf-8"?>
+<!-- xslplanes.2.xml -->
+<?xml-stylesheet type = "text/xsl" href = "xslplanes.2.xsl" ?>
+<planes>
+   <plane>
+      <foo> one </foo>
+      <year> 1977 </year>
+      <make> Cessna </make>
+      <model> Skyhawk </model>
+      <color> Light blue and white </color>
+   </plane>
+   <plane>
+      <foo> two </foo>
+      <year> 1975 </year>
+      <make> Piper </make>
+      <model> Apache </model>
+      <color> White </color>
+   </plane>   
+   <plane>
+      <foo> three </foo>      
+      <year> 1960 </year>
+      <make> Cessna </make>
+      <model> Centurian </model>
+      <color> Yellow and white </color>
+   </plane>
+   <plane>
+      <foo> four </foo>
+      <year> 1956 </year>
+      <make> Piper </make>
+      <model> Tripacer </model>
+      <color> Blue </color>
+   </plane>
+   <plane>
+      <foo> one </foo>
+      <year> 1977_2 </year>
+      <make> Cessna_2 </make>
+      <model> Skyhawk_2 </model>
+      <color> Light blue and white_2 </color>
+   </plane>
+   <plane>
+      <foo> two </foo>
+      <year> 1975_2 </year>
+      <make> Piper_2 </make>
+      <model> Apache_2 </model>
+      <color> White_2 </color>
+   </plane>   
+   <plane>
+      <foo> three </foo>      
+      <year> 1960_2 </year>
+      <make> Cessna_2 </make>
+      <model> Centurian_2 </model>
+      <color> Yellow and white_2 </color>
+   </plane>
+   <plane>
+      <foo> four </foo>
+      <year> 1956_2 </year>
+      <make> Piper_2 </make>
+      <model> Tripacer_2 </model>
+      <color> Blue_2 </color>
+   </plane>
+</planes>

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: nokogiri-notepad
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Adrian Carroll
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-11 00:00:00.000000000 Z
+dependencies: []
+description: Gem for extracting info from xml files according to paths defined in
+  Notepad++
+email: adrian.carroll7@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/custom_errors.rb
+- lib/node_finder.rb
+- lib/parser.rb
+- test/tc_helper.rb
+- test/tc_node_finder.rb
+- test/tc_parser.rb
+- test/test_files/invalid.xml
+- test/test_files/xslplanes.1.xml
+- test/test_files/xslplanes.1.xmx
+- test/test_files/xslplanes.2.xml
+- test/test_files/xslplanes.3.xml
+homepage: http://github.com/carrola7/nokogiri-notepad
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: XML Node extractor
+test_files: []