xml_dsl 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8039a8956aa2ed81f448ceb371bf92523f9f1a3c
+  data.tar.gz: 5d8486f335d6a3fc412ce09ebe312a6738b187fe
+SHA512:
+  metadata.gz: f24e74b53fb2e66b325c032c749ff1795a6268fbc79f1ad2cb9a0c0c392266d774027ab0cb6d5a4b86951813b52d3f6cc8ea87720b57714dd29f4cf7787178e0
+  data.tar.gz: 3981133746da9191c4b25555f65915257a3204772204a1289efb52e77e10e2f96d075b1e264a3d1721ced396bae67cd0c754e9c64fd041a97872e99fbdf69dc3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+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,111 @@
+# Xml Dsl
+
+Xml Dsl adds DSL for defining easy parsers (or mappers) for XML via nokogiri XML objects.
+
+## Install
+
+Add `xml_dsl` gem to `Gemfile`:
+```
+    gem 'xml_dsl', '~> 0.1.1' 
+```
+
+## Usage
+
+Let's pretend we have an XML output of a following structure
+```
+    <root>
+      <offer>
+        <id>703134</id>
+        <distance>10</distance>
+        <house>38a</house>
+        <rooms>
+          <room>1</room>
+        </rooms>
+        <prices>
+          <price>2200000</price>
+        </prices>
+        <currency>RUR</currency>
+        <floor>7</floor>
+        <nfloor>17</nfloor>
+        <areas>
+          <area type="total">37</area>
+          <area type="live">0</area>
+          <area type="kitchen">10</area>
+        </areas>
+      </offer>
+      <offer>
+        <id>703102</id>
+        <distance>25</distance>
+        <house>7</house>
+        <rooms>
+          <room>1</room>
+        </rooms>
+        <prices>
+          <price>2650000</price>
+        </prices>
+        <currency>RUR</currency>
+        <floor>1</floor>
+        <nfloor>5</nfloor>
+        <areas>
+          <area type="total">30</area>
+          <area type="live">17</area>
+          <area type="kitchen">7</area>
+        </areas>
+        <magick>woodoo</magick>
+      </offer>
+    </root>
+```
+
+Then we can define our mapper as following
+```
+   class Parser
+     attr_accessor :xml, :external
+        def initialize(xml, external)
+          # Normal iteration goes from xml instance_variable
+          self.xml = xml
+          self.external = external
+        end
+
+        # Here we definig parser, which will put attributes to Hash, and look for <offer> nodes inside <root>
+        # any length of root path can be provided
+        define_xml_parser Hash, :root, :offer do
+
+          # We can define a block to call every time an XmlDsl::ParseError os raised
+          # it is raised if null: true is passed to field declaration, or manually via raise XmlDsl::ParseError
+          error_handle do |e, node|
+            external.notify node
+          end
+            
+          # Field declaration
+          field :id, :id, matcher: :to_i
+          
+          # We can pass getter to call on Nokogiri::Xml::Element (default :text) and matcher (default :to_s)
+          field :minutes, :distance, matcher: :to_i
+          
+          # If null: true (default false) is passed then if field is empty - it will raise XmlDsl::ParseError
+          # and then triggers error_handle blocks
+          field :magick, :magick, null: true
+          
+          # We can pass long xpath to find proper node inside our XML
+          # like this:
+          field :amount, [:prices, :price], matcher: :to_i
+          # or even like this:
+          field :total_area, [:areas, 'area[type=total]'], matcher: :to_i
+          
+          # If our logic is more complex we can define it inside block
+          field :full_area, null: true do |instance, node|
+            if !instance[:area]           
+                node.search('areas').reduce(0) { |acc,n| acc + n.text.to_i }
+            else
+                0
+            end
+          end
+        end
+      end
+```
+
+## Contributing
+
+Feel free to request for some features or fork - implement - pul request.
+
+

data/Rakefile

@@ -0,0 +1,14 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+Bundler::GemHelper.install_tasks
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/xml_dsl/block_method.rb

@@ -0,0 +1,43 @@
+module XmlDsl
+  class BlockMethod
+    attr_reader :method, :args, :block
+    def initialize(method, *args, &block)
+      @method = method
+      @args = args
+      @block = block if block_given?
+    end
+
+    def call(instance, node, parser)
+      if block
+        self.send method, *[instance, node, parser] + args, &block
+      else
+        self.send method, *[instance, node, parser] + args
+      end
+    end
+
+    def field(instance, node, parser, target, source = nil, getter: :text, matcher: :to_s, null: false, &block)
+      raise ArgumentError, 'Wrong target' unless target.is_a? Symbol
+      if block_given?
+        instance[target] = parser.instance_exec instance, node, &block
+      else
+        raise ArgumentError, 'No source specified' if source.nil?
+        source = case [source.class]
+                   when [Symbol]
+                     source.to_s
+                   when [Array]
+                     source.join('/')
+                   else
+                     source.to_s
+                 end
+        instance[target] = node.search(source).send(getter).send(matcher)
+      end
+      if null
+        raise XmlDsl::ParseError, "#{target} is empty. Node: #{node}" if instance[target].nil? || instance[target] == ""
+      end
+    end
+
+    def error_handle(exception, node, parser, &block)
+      parser.instance_exec exception, node, &block
+    end
+  end
+end

data/lib/xml_dsl/core.rb

@@ -0,0 +1,4 @@
+require 'xml_dsl/macro_methods'
+Class.class_eval do
+  include XmlDsl::MacroMethods
+end

data/lib/xml_dsl/errors.rb

@@ -0,0 +1,6 @@
+module XmlDsl
+  class Error < StandardError
+  end
+  class ParseError < StandardError
+  end
+end

data/lib/xml_dsl/extensions.rb

@@ -0,0 +1,42 @@
+module XmlDsl
+  module Extensions
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+      base.class_eval do
+        attr_reader :_xml_parse_callbacks, :_xml_root_path, :_xml_target_class
+
+        alias_method :original_initialize, :initialize
+        def initialize(*args, &block)
+          self.class.instance_variable_get(:@xml_parser).setup_parser_instance(self)
+          original_initialize(*args, &block)
+        end
+      end
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      def iterate(xml_obj = nil, acc: nil, &block)
+        xml_obj ||= xml
+        raise ArgumentError, "If there is no @xml in parser, pass it to iterate" if xml_obj.nil?
+        xml_obj.search(_xml_root_path).each do |node|
+          begin
+            instance = _xml_target_class.new
+            _xml_parse_callbacks[:readers].each do |bm|
+              bm.call instance, node, self
+            end
+            yield instance if block_given?
+            acc << instance if acc
+          rescue XmlDsl::ParseError => e
+            _xml_parse_callbacks[:error_handlers].each do |bm|
+              bm.call e, node, self
+            end
+          end
+        end
+        acc
+      end
+    end
+  end
+end

data/lib/xml_dsl/macro_methods.rb

@@ -0,0 +1,9 @@
+require 'xml_dsl/xml_parser'
+
+module XmlDsl
+  module MacroMethods
+    def define_xml_parser(*args, &block)
+      XmlDsl::XmlParser.create(self, *args, &block)
+    end
+  end
+end

data/lib/xml_dsl/version.rb

@@ -0,0 +1,3 @@
+module XmlDsl
+  VERSION = "0.3.1"
+end

data/lib/xml_dsl/xml_parser.rb

@@ -0,0 +1,51 @@
+require 'xml_dsl/block_method'
+require 'xml_dsl/extensions'
+require 'xml_dsl/errors'
+
+module XmlDsl
+  class XmlParser
+    class << self
+      def create(owner, *args, &block)
+        new(owner, *args, &block)
+      end
+    end
+
+    attr_reader :owner, :target_class, :state_lock, :callbacks
+
+    def initialize(owner, target_class, *args, &block)
+      raise XmlDsl::Error, 'No block given for parser' unless block_given?
+      @target_class = target_class
+      @root_path = args
+      @state_lock = Mutex.new
+      self.owner = owner
+      @callbacks = Hash.new { |h,k| h[k] = [] }
+      self.instance_eval &block
+    end
+
+    def owner=(klazz)
+      @owner = klazz
+      @owner.send :include, XmlDsl::Extensions
+      @owner.instance_variable_set :@xml_parser, self
+    end
+
+    def field(*args, &block)
+      callbacks[:readers] << XmlDsl::BlockMethod.new(:field, *args, &block)
+    end
+
+    def error_handle(*args, &block)
+      callbacks[:error_handlers] << XmlDsl::BlockMethod.new(:error_handle, *args, &block)
+    end
+
+    def setup_parser_instance(instance)
+      state_lock.synchronize do
+        instance.instance_variable_set :@_xml_root_path, root_path
+        instance.instance_variable_set :@_xml_parse_callbacks, callbacks.dup
+        instance.instance_variable_set :@_xml_target_class, target_class
+      end
+    end
+
+    def root_path
+      @root_path.join('/').prepend('//')
+    end
+  end
+end

data/lib/xml_dsl.rb

@@ -0,0 +1,3 @@
+require 'xml_dsl/core'
+module XmlDsl
+end

data/spec/fixtures/some.xml

@@ -0,0 +1,41 @@
+<root>
+  <offer>
+    <id>703134</id>
+    <distance>10</distance>
+    <house>38a</house>
+    <rooms>
+      <room>1</room>
+    </rooms>
+    <prices>
+      <price>2200000</price>
+    </prices>
+    <currency>RUR</currency>
+    <floor>7</floor>
+    <nfloor>17</nfloor>
+    <areas>
+      <area type="total">37</area>
+      <area type="live">0</area>
+      <area type="kitchen">10</area>
+    </areas>
+  </offer>
+  <offer>
+    <id>703102</id>
+    <distance>25</distance>
+    <house>7</house>
+    <rooms>
+      <room>1</room>
+    </rooms>
+    <prices>
+      <price>2650000</price>
+    </prices>
+    <currency>RUR</currency>
+    <floor>1</floor>
+    <nfloor>5</nfloor>
+    <areas>
+      <area type="total">30</area>
+      <area type="live">17</area>
+      <area type="kitchen">7</area>
+    </areas>
+    <magick>woodoo</magick>
+  </offer>
+</root>

data/spec/integrational/example_parser_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'support/xml'
+
+describe 'Example Xml Mapper Spec' do
+  context 'normal parser' do
+    before(:each) do
+      clazz = Class.new
+      clazz.class_eval do
+        attr_accessor :xml
+        def initialize(xml)
+          self.xml = xml
+        end
+
+        define_xml_parser Hash, :root, :offer do
+          field :id, :id, matcher: :to_i
+          field :minutes, :distance, matcher: :to_i
+          field :amount, [:prices, :price], matcher: :to_i
+          field :currency, :currency
+          field :total_area, [:areas, 'area[type=total]'], matcher: :to_i
+          field :full_area, null: true do |_, node|
+            node.search('areas').reduce(0) { |acc,n| acc + n.text.to_i }
+          end
+          field :magick, :magick
+        end
+      end
+      @parser = clazz.new some_xml
+    end
+
+    it 'responds to iterate' do
+      expect(@parser).to respond_to(:iterate)
+    end
+
+    it 'puts one Hash obj to acc' do
+      expect(@parser.iterate(acc: []).first).to be_instance_of(Hash)
+    end
+
+    it 'iterates over nodes and call block twice in outer context' do
+      some_obj = double
+      expect(some_obj).to receive(:notify).twice
+      @parser.iterate do |item|
+        some_obj.notify item
+      end
+    end
+
+    context 'Parser results' do
+      let(:result) { @parser.iterate(acc: []).first }
+
+      it 'has amount of kind Numeric' do
+        expect(result[:amount]).to be_instance_of(Fixnum)
+      end
+
+      it 'has id of kind Fixnum' do
+        expect(result[:id]).to be_instance_of(Fixnum)
+      end
+
+      it 'has currency of kind String' do
+        expect(result[:currency]).to be_instance_of(String)
+      end
+
+      it 'has full area of kind Fixnum' do
+        expect(result[:full_area]).to be_instance_of(Fixnum)
+      end
+
+      it 'has total area equal 37' do
+        expect(result[:total_area]).to eql(37)
+      end
+
+      it 'has empty magick' do
+        expect(result[:magick]).to be_empty
+      end
+    end
+  end
+
+  context 'parser for different errors' do
+    before(:each) do
+      clazz = Class.new
+      @external_obj = double
+      clazz.class_eval do
+        attr_accessor :xml, :external
+        def initialize(xml, external)
+          self.xml = xml
+          self.external = external
+        end
+
+        define_xml_parser Hash, :root, :offer do
+
+          error_handle do |e, node|
+            external.notify node
+          end
+
+          field :id, :id, matcher: :to_i
+          field :minutes, :distance, matcher: :to_i
+          field :magick, :magick, null: true
+        end
+      end
+      @parser = clazz.new some_xml, @external_obj
+    end
+
+    it 'calls error_handler on parse error if null: true' do
+      expect(@external_obj).to receive(:notify).with(kind_of(Nokogiri::XML::Element)).once
+      @parser.iterate
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+require 'nokogiri'
+require 'pry'
+Bundler.setup
+
+require 'xml_dsl' # and any other gems you need
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.order = "random"
+end

data/spec/support/xml.rb

@@ -0,0 +1,3 @@
+def some_xml
+  Nokogiri::XML(open('spec/fixtures/some.xml') { |f| f.read })
+end

data/spec/unit/xml_dsl_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe XmlDsl do
+  context 'Within class' do
+    let(:clazz) { Class.new }
+
+    it 'added :define_xml_parser to class_methods' do
+      expect(clazz).to respond_to(:define_xml_parser)
+    end
+
+    it 'has no :define_xml_parser on instance' do
+      expect { clazz.new.instance_eval { define_xml_parser Hash, :root }}.to raise_error(NoMethodError)
+    end
+
+    it 'but no :iterate on instance before definition' do
+      expect { clazz.new.iterate }.to raise_error(NoMethodError)
+    end
+
+    context 'on instance after empty parser definition' do
+      before(:all) do
+        clazz.instance_eval do
+          define_xml_parser Hash, :root, :item do
+          end
+        end
+        @parser = clazz.new
+      end
+
+      it 'has no :iterate on class after defenition' do
+        expect { clazz.iterate }.to raise_error(NoMethodError)
+      end
+      it 'has :iterate method on instance' do
+        expect(@parser).to respond_to(:iterate)
+      end
+      it 'has xml_parser on class' do
+        expect(clazz.instance_variable_get(:@xml_parser)).to be_instance_of(XmlDsl::XmlParser)
+      end
+      it 'doesn\'t have xml_parser on instance' do
+        expect(@parser.instance_variable_get(:@xml_parser)).to be_nil
+      end
+      it 'have callbacks stack on instance' do
+        expect(@parser.instance_variable_get(:@_xml_parse_callbacks)).to be_instance_of(Hash)
+      end
+
+      context 'defining different callbacks' do
+        let(:xml_parser) { clazz.instance_variable_get(:@xml_parser) }
+
+        it 'defining field callback is put inside :readers' do
+          expect { in_definition { field :name, :ext_name } }.to change(xml_parser.callbacks[:readers], :length).by(1)
+        end
+
+        it 'defining error_handler is put inside error_handlers' do
+          expect { in_definition { error_handle  } }.to change(xml_parser.callbacks[:error_handlers], :length).by(1)
+        end
+
+        def in_definition(&block)
+          xml_parser.instance_eval &block
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: xml_dsl
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Vladislav Bogomolov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pry-remote
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: DSL designed for easily create XML mappers
+email:
+- vladson4ik@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/xml_dsl.rb
+- lib/xml_dsl/block_method.rb
+- lib/xml_dsl/core.rb
+- lib/xml_dsl/errors.rb
+- lib/xml_dsl/extensions.rb
+- lib/xml_dsl/macro_methods.rb
+- lib/xml_dsl/version.rb
+- lib/xml_dsl/xml_parser.rb
+- spec/fixtures/some.xml
+- spec/integrational/example_parser_spec.rb
+- spec/spec_helper.rb
+- spec/support/xml.rb
+- spec/unit/xml_dsl_spec.rb
+homepage: https://github.com/vladson/xml_dsl
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Create easy xml mappers to hash via Nokogiri::XML
+test_files:
+- spec/fixtures/some.xml
+- spec/integrational/example_parser_spec.rb
+- spec/spec_helper.rb
+- spec/support/xml.rb
+- spec/unit/xml_dsl_spec.rb