sawtooth 0.2.0

data/test/sawtooth/builder_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+class Sawtooth::BuilderTest < MiniTest::Unit::TestCase
+
+  def test_using_basic_builder
+    @builder = Sawtooth::Builder.new do
+      before { |doc| doc << Array.new }
+      after  { |doc| doc << doc.pop.first }
+
+      on('statuses/status') do
+        on_start  { |doc| doc << Hash.new }
+        on_finish { |doc| doc.parent << doc.pop }
+      end
+
+      on_text('statuses/status/created_at' => :created_at) { |str| Date.parse(str) }
+      on_text 'statuses/status/text' => :value
+      on_text 'statuses/status/*' => Proc.new { |str| str.to_sym }
+    end
+
+    @doc = @builder.parse File.read(fixture_path('statuses.xml'))
+    assert_equal 'I so just thought the guy lighting the Olympic torch was falling when he began to run on the wall. Wow that would have been catastrophic.', @doc.root[:value]
+    assert_equal '2008-08-09', @doc.root[:created_at].strftime('%Y-%m-%d')
+    assert_nil @doc.root[:screen_name]
+    assert_equal 'web', @doc.root[:source]
+  end
+
+  def test_delegate_shortcut
+    user = Sawtooth::Builder.new do
+      before { |doc| doc << Hash.new }
+      after  { |doc| doc.parent['user'] = doc.pop }
+
+      on_text('user/name')
+      on_text('user/screen_name')
+      on_text('user/id') { |str| str.to_i }
+    end
+
+    builder = Sawtooth::Builder.new do
+      before { |doc| doc << [] }
+      after  { |doc| doc << doc.pop.last }
+
+      on('statuses/status') do
+        on_start  { |doc| doc << Hash.new }
+        on_finish { |doc| doc.parent << doc.pop }
+      end
+
+      on_text('statuses/status/text')
+      delegate('statuses/status/user/**' => user)
+    end
+
+    @doc = builder.parse File.read(fixture_path('statuses.xml'))
+    assert_match /^Netshare will no longer start up for me\./, @doc.root['text']
+    assert_equal 'John Nunemaker', @doc.root['user']['name']
+    assert_equal 4243, @doc.root['user']['id']
+  end
+
+  def test_chained_delegate_rules
+
+    order = []
+
+    block = Sawtooth::Builder.new do
+      on_text('Blocks/Title' => 'title', 'Blocks/Text' => 'text')
+      after { order << "block" }
+    end
+
+    article = Sawtooth::Builder.new do
+      before { |doc| doc << Hash.new }
+      after  { |doc| order << "article"; doc.parent == doc.root ? doc.parent['sections'].first << doc.pop : doc.parent << doc.pop }
+
+      delegate('Blocks/**' => block)
+    end
+
+    section = Sawtooth::Builder.new do
+      before { |doc| doc << [] }
+      after  { |doc| order << "section"; doc.parent['sections'] << doc.pop }
+
+      delegate('Article/**' => article, :prefix => 'Article')
+    end
+
+    builder = Sawtooth::Builder.new do
+      before { |doc| doc.push('sections' => [[]]) }
+      after { |doc| order << "builder" }
+
+      on_text('Articles/Author')
+      on_text('Articles/Version') { |str| str.to_i }
+
+      delegate('Articles/MainArticle/**' => article, :prefix => 'Articles/MainArticle')
+      delegate('Articles/Section/**' => section, :prefix => 'Articles/Section')
+    end
+
+    @doc = builder.parse File.read(fixture_path('delegate.xml'))
+    assert_equal 'lukas', @doc.root['author']
+    assert_equal 35, @doc.root['version']
+
+    assert_equal 1, @doc.stack.size
+    assert_equal 2, @doc.root['sections'].size
+
+    assert_equal 'Didum', @doc.root['sections'].last.first['title']
+    assert_equal 'Barfoo', @doc.root['sections'].first.first['text']
+
+    assert_equal %w{block article block article section block article block article builder}, order
+  end
+end

data/test/sawtooth/document_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+
+class Sawtooth::DocumentTest < MiniTest::Unit::TestCase
+
+  # A fake Attribute, for testing
+  FakeAttr = Struct.new(:localname, :value) do
+    def self.build(hsh = {})
+      hsh.map { |k,v| self.new(k, v) }
+    end
+  end
+
+  # A fake delegate for testing
+  class FakeDelegate
+    attr_reader :args
+    def path; @args[0] end
+    def doc;  @args[1] end
+    def node; @args[2] end
+    def start_document(*args); @args = args end
+    def end_document(*args); @args = args.dup end
+    def start_element(*args); @args = args end
+    def end_element(*args); @args = args.map { |e| e.dup } end
+  end
+
+  def setup
+    @delegate = FakeDelegate.new
+    @doc = Sawtooth::Document.new @delegate
+  end
+
+  def test_that_elements_can_be_pushed_onto_the_stack
+    @doc.push "a"
+    @doc.push "b"
+    assert_equal %w{a b}, @doc.stack
+  end
+
+  def test_elements_can_be_pushed_using_lshift
+    @doc << "a"
+    @doc << "b"
+    assert_equal %w{a b}, @doc.stack
+  end
+
+  def test_push_chaining
+    @doc.push("a").push("b") << "c" << "d"
+    assert_equal %w{a b c d}, @doc.stack
+  end
+
+  def test_that_elements_can_be_popped_from_the_stack
+    @doc << "a" << "b"
+    @doc.pop
+    assert_equal %w{a}, @doc.stack
+  end
+
+  def test_that_pop_returns_popped_item
+    @doc.push("a").push("b").push("c")
+    assert_equal "c", @doc.pop
+    assert_equal "b", @doc.pop
+    assert_equal %w{a}, @doc.stack
+  end
+
+  def test_that_peek_looks_at_the_element
+    @doc << "a" << "b" << "c"
+    assert_equal "c", @doc.peek
+    assert_equal "b", @doc.peek(1)
+    assert_equal "a", @doc.peek(2)
+    assert_nil @doc.peek(3)
+  end
+
+  def test_current_and_parent_peek_aliases
+    @doc << "a" << "b" << "c"
+    assert_equal "c", @doc.current
+    assert_equal "b", @doc.parent
+  end
+
+  def test_root_method
+    @doc << "a"
+    assert_equal "a", @doc.root
+    @doc << "b"
+    assert_equal "a", @doc.root
+  end
+
+  def test_document_parsing
+    @doc.start_document
+    assert_equal 0, @doc.path.size
+    assert_equal 1, @delegate.path.size
+    assert_equal '@document', @delegate.path.first.name
+
+    # <root type='array'>
+    @doc.start_element_namespace 'root', FakeAttr.build({ 'type' => 'array' })
+    assert_equal 1, @doc.path.size
+    assert_equal 'root', @delegate.node.name
+
+    # <root type='array'>
+    #   <elem>
+    @doc.start_element_namespace 'elem'
+    assert_equal 2, @doc.path.size
+    assert_equal "root/elem", @doc.path.join('/')
+
+    #     text
+    @doc.characters("   te")
+    @doc.characters("xt\n  ")
+
+    #   </elem>
+    @doc.end_element_namespace 'elem'
+    assert_equal 1, @doc.path.size
+    assert_equal 'elem', @delegate.node.name
+    assert_equal 'text', @delegate.node.text
+
+    # </root>
+    @doc.end_element_namespace 'root'
+    assert_equal 0, @doc.path.size
+    assert_equal 1, @delegate.path.size
+    assert_equal 'root', @delegate.node.name
+    assert_equal({ 'type' => 'array' }, @delegate.node.attributes)
+
+    # end document
+    @doc.end_document
+    assert_equal 1, @delegate.path.size
+    assert_equal '@document', @delegate.path.first.name
+  end
+end

data/test/sawtooth/parser_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class Sawtooth::DelegateTest < MiniTest::Unit::TestCase
+  def setup
+    @parser = Sawtooth::Parser.new
+    @initRule = Sawtooth::Rules::CallRule.new(:start => Proc.new { |doc| doc << Array.new })
+    @addRule = Sawtooth::Rules::TextRule.new
+  end
+
+  def test_adding_simple_rule_and_parsing_file
+    @parser.add("statuses", @initRule)
+    @parser.add("statuses/status/text", @addRule)
+    doc = @parser.parse File.open(fixture_path('statuses.xml'))
+    assert_equal 'I so just thought the guy lighting the Olympic torch was falling when he began to run on the wall. Wow that would have been catastrophic.', doc.peek.first
+    assert_equal 20, doc.peek.size
+  end
+end

data/test/sawtooth/readme_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+require 'open-uri'
+
+class Sawtooth::ReadmeTest < MiniTest::Unit::TestCase
+  def test_primary_cnn_example
+    rules = Sawtooth.rules do
+      before { |doc| doc << [] }
+      on 'rss/channel/item' do
+        on_start  { |doc| doc << Hash.new }
+        on_finish { |doc| doc.parent << doc.pop }
+      end
+      on_text 'rss/channel/item/*'
+    end
+
+    result = rules.parse(open('http://rss.cnn.com/rss/edition.rss')).root
+
+    assert_instance_of Array, result
+    assert_instance_of Hash, result.first
+    assert_equal %w{guid title pub_date description link}.sort, result.first.keys.sort
+  end
+end

data/test/sawtooth/rules/delegate_rule_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class Sawtooth::Rules::DelegateRuleTest < MiniTest::Unit::TestCase
+
+  include Sawtooth::Rules
+
+  XML = '<didum><del><foo><bar>x</bar><baz>z</baz></foo></del><da>123</da></didum>'
+
+  def setup
+    @parser = Sawtooth::Parser.new
+    @parser.add("didum", CallRule.new(:start => Proc.new { |doc| doc << Hash.new }))
+    @parser.add("didum/da", TextRule.new)
+  end
+
+  def test_using_delgate_rule
+    @rules = Sawtooth::Rules::Set.new
+    @rules.add("@document:before", CallRule.new(:start => Proc.new { |doc| doc << Hash.new }))
+    @rules.add("@document:after", CallRule.new(:finish => Proc.new { |doc| doc.parent['del'] = doc.pop }))
+    @rules.add("foo/bar", TextRule.new)
+    @rules.add("foo/baz", TextRule.new)
+
+    @rule = Sawtooth::Rules::DelegateRule.new :prefix => "didum/del/", :rules => @rules
+    @parser.add('didum/del', @rule.before_after_callbacks_rule)
+    @parser.add('didum/del/**', @rule)
+    obj = @parser.parse(XML).top
+    assert_equal '123', obj['da']
+    assert_equal({ 'baz' => 'z', 'bar' => 'x' }, obj['del'])
+  end
+
+  def test_using_prefix_delegate_rule
+    @rules = Sawtooth::Rules::Set.new
+    @rules.add("@document:before", CallRule.new(:start => Proc.new { |doc| doc << Hash.new }))
+    @rules.add("@document:after", CallRule.new(:finish => Proc.new { |doc| doc.parent['del'] = doc.pop }))
+    @rules.add("bar", TextRule.new)
+    @rules.add("baz", TextRule.new)
+
+    @rule = Sawtooth::Rules::DelegateRule.new :prefix => "didum/del/foo", :rules => @rules
+    @parser.add('didum/del/foo', @rule.before_after_callbacks_rule)
+    @parser.add('didum/del/foo/**', @rule)
+    obj = @parser.parse(XML).top
+    assert_equal '123', obj['da']
+    assert_equal({ 'baz' => 'z', 'bar' => 'x' }, obj['del'])
+  end
+end

data/test/sawtooth/rules/text_rule_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class Sawtooth::Rules::TextRuleTest < MiniTest::Unit::TestCase
+
+  # Test Class
+  SomeModel = Struct.new(:first_name)
+
+  def test_setting_value_open_model
+    doc.push SomeModel.new
+    rule = Sawtooth::Rules::TextRule.new
+    rule.finish("root/firstName", doc, build_node!("firstName", :text => "Hans"))
+    assert_equal "Hans", doc.top.first_name
+  end
+
+  def test_setting_value_to_hash
+    doc.push Hash.new
+    rule = Sawtooth::Rules::TextRule.new
+    rule.finish("root/firstName", doc, build_node!("firstName", :text => "Hans"))
+    assert_equal "Hans", doc.top['first_name']
+  end
+
+  def test_supply_custom_name
+    doc.push SomeModel.new
+    rule = Sawtooth::Rules::TextRule.new :first_name
+    rule.finish("root/didum/Text", doc, build_node!("Text", :text => "Hans"))
+    assert_equal "Hans", doc.top.first_name
+  end
+
+  def test_supply_conversion_block
+    doc.push Hash.new
+    rule = Sawtooth::Rules::TextRule.new(:value) { |str| str.strip.to_i }
+    rule.finish("root/didum/intValue", doc, build_node!("intValue", :text => "   1234\n"))
+    assert_equal 1234, doc.top[:value]
+  end
+
+  def test_supply_name_conversion_block
+    doc.push Hash.new
+    rule = Sawtooth::Rules::TextRule.new(Proc.new { |name| name.upcase.to_sym })
+    rule.finish("root/dadam/intValue", doc, build_node!("intValue", :text => "   1234\n"))
+    rule.finish("root/dadam/strValue", doc, build_node!("strValue", :text => "   didum\n"))
+    assert_equal "1234", doc.top[:INTVALUE]
+    assert_equal "didum", doc.top[:STRVALUE]
+  end
+
+  def test_default_converter_converts_empty_line_to_nil
+    doc.push SomeModel.new
+    rule = Sawtooth::Rules::TextRule.new
+    rule.finish("root/firstName", doc, build_node!("firstName", :text => "    \n"))
+    assert_nil doc.top.first_name
+  end
+
+  def test_appends_values_if_array
+    doc.push []
+    rule = Sawtooth::Rules::TextRule.new
+    rule.finish("root/firstName", doc, build_node!("firstName", :text => "Hans\n"))
+    rule.finish("root/lastName",  doc, build_node!("lastName", :text => "    Muster\n\n"))
+    assert_equal %w{Hans Muster}, doc.top
+  end
+end

data/test/sawtooth/rules_set_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class Sawtooth::Rules::SetTest < MiniTest::Unit::TestCase
+  def setup
+    @set = Sawtooth::Rules::Set.new
+    @set.add "other/test/path", 10
+    @set.add "otherPath/test/*", 11
+    @set.add "other/**", 12
+    @set.add "other/path", 13
+
+    @set.add "didum/*", 20
+    @set.add "didum/user/*", 21
+
+    @set.add %r{\Asome/(magic|regex(/.*)?)\z}, 3
+
+    @set.add "some/path", 1
+    @set.add "some/path/here", 2
+  end
+
+  def test_adding_rules
+    assert_equal 2, @set.items.last.rule
+  end
+
+  def test_matching_static_rules
+    assert_equal 1, @set.find("some/path")
+    assert_equal 2, @set.find("some/path/here")
+    assert_equal 1, @set.find(%w{some path})
+    assert_equal 2, @set.find('some', 'path', 'here')
+  end
+
+  def test_matching_glob_rules
+    assert_equal 12, @set.find("other/didum")
+    assert_equal 12, @set.find("other/didum/dadam")
+    assert_equal 12, @set.find("other/path") # cannot be reached because of globbing
+    assert_equal 11, @set.find("otherPath/test/didum")
+    assert_nil @set.find("otherPath/test")
+
+    assert_equal 20, @set.find("didum/magic")
+    assert_equal 20, @set.find("didum/random")
+    assert_nil @set.find("didum/magic/boredom")
+    assert_nil @set.find("didum/magic/didum/darmdam")
+  end
+
+  def test_regex_paths
+    assert_equal 3, @set.find("some/magic")
+    assert_equal 3, @set.find("some/regex")
+    assert_equal 3, @set.find("some/regex/didum")
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+require 'minitest/autorun'
+
+# load sawtooth
+require 'sawtooth'
+
+class MiniTest::Unit::TestCase
+
+  # Root directory, for tests
+  TEST_ROOT = File.dirname(__FILE__)
+
+  # Testing Stack
+  def doc; @doc ||= Sawtooth::Document.new end
+
+  # Helper which creates a new Sawtooth::Document::Node
+  # Instance.
+  #
+  def build_node!(name = "test", opts = {})
+    Sawtooth::Document::Node.new(opts[:ns] || opts[:namespace], name, opts[:attrs] || opts[:attributes] || {}, opts[:txt] || opts[:text] || '')
+  end
+
+  # Path to a file in test/files
+  def fixture_path(filename)
+    "#{TEST_ROOT}/files/#{filename}"
+  end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: sawtooth
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Lukas Westermann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-19 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  name: nokogiri
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 9
+        - 2
+        version: 0.9.2
+  prerelease: false
+  name: rake
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  prerelease: false
+  name: appraisal
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 39
+        segments: 
+        - 2
+        - 10
+        - 0
+        version: 2.10.0
+  prerelease: false
+  name: minitest
+  version_requirements: *id004
+description: Provides an interface on top of nokogiri to parse XML files like Apache Digester.
+email: 
+- lukas.westermann@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/sawtooth.rb
+- lib/sawtooth/builder.rb
+- lib/sawtooth/document.rb
+- lib/sawtooth/parser.rb
+- lib/sawtooth/rules.rb
+- lib/sawtooth/rules/base.rb
+- lib/sawtooth/rules/call_rule.rb
+- lib/sawtooth/rules/delegate_rule.rb
+- lib/sawtooth/rules/set.rb
+- lib/sawtooth/rules/text_rule.rb
+- lib/sawtooth/version.rb
+- sawtooth.gemspec
+- test/files/delegate.xml
+- test/files/statuses.xml
+- test/sawtooth/builder_test.rb
+- test/sawtooth/document_test.rb
+- test/sawtooth/parser_test.rb
+- test/sawtooth/readme_test.rb
+- test/sawtooth/rules/delegate_rule_test.rb
+- test/sawtooth/rules/text_rule_test.rb
+- test/sawtooth/rules_set_test.rb
+- test/test_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: sawtooth
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Declarative XML parsing using nokogiri
+test_files: 
+- test/files/delegate.xml
+- test/files/statuses.xml
+- test/sawtooth/builder_test.rb
+- test/sawtooth/document_test.rb
+- test/sawtooth/parser_test.rb
+- test/sawtooth/readme_test.rb
+- test/sawtooth/rules/delegate_rule_test.rb
+- test/sawtooth/rules/text_rule_test.rb
+- test/sawtooth/rules_set_test.rb
+- test/test_helper.rb