nokogiri-happymapper 0.6.0 → 0.9.0

data/spec/to_xml_with_namespaces_spec.rb

@@ -1,232 +0,0 @@
-require 'spec_helper'
-
-module ToXMLWithNamespaces
-
-  #
-  # Similar example as the to_xml but this time with namespacing
-  #
-  class Address
-    include HappyMapper
-
-    register_namespace 'address', 'http://www.company.com/address'
-    register_namespace 'country', 'http://www.company.com/country'
-
-    tag 'Address'
-    namespace 'address'
-
-    element :country, 'Country', :tag => 'country', :namespace => 'country'
-
-    attribute :location, String, :on_save => :when_saving_location
-
-    element :street, String
-    element :postcode, String
-    element :city, String
-
-    element :housenumber, String
-
-    #
-    # to_xml will default to the attr_accessor method and not the attribute,
-    # allowing for that to be overwritten
-    #
-    undef :housenumber
-    def housenumber
-      "[#{@housenumber}]"
-    end
-
-    def when_saving_location(loc)
-      loc + '-live'
-    end
-
-    #
-    # Write a empty element even if this is not specified
-    #
-    element :description, String, :state_when_nil => true
-
-    #
-    # Perform the on_save operation when saving
-    #
-    has_one :date_created, Time, :on_save => lambda {|time| DateTime.parse(time).strftime("%T %D") if time }
-
-    #
-    # Write multiple elements and call on_save when saving
-    #
-    has_many :dates_updated, Time, :on_save => lambda {|times|
-      times.compact.map {|time| DateTime.parse(time).strftime("%T %D") } if times }
-
-    #
-    # Class composition
-    #
-
-    def initialize(parameters)
-      parameters.each_pair do |property,value|
-        send("#{property}=",value) if respond_to?("#{property}=")
-      end
-    end
-
-  end
-
-  #
-  # Country is composed above the in Address class. Here is a demonstration
-  # of how to_xml will handle class composition as well as utilizing the tag
-  # value.
-  #
-  class Country
-    include HappyMapper
-
-    register_namespace 'countryName', 'http://www.company.com/countryName'
-
-    attribute :code, String, :tag => 'countryCode'
-    has_one :name, String, :tag => 'countryName', :namespace => 'countryName'
-
-    def initialize(parameters)
-      parameters.each_pair do |property,value|
-        send("#{property}=",value) if respond_to?("#{property}=")
-      end
-    end
-
-  end
-
-
-  #
-  # This class is an example of a class that has a default namespace
-  #xmlns="urn:eventis:prodis:onlineapi:1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-  #
-  class Recipe
-    include HappyMapper
-
-    # this is the default namespace of the document
-    register_namespace 'xmlns', 'urn:eventis:prodis:onlineapi:1.0'
-    register_namespace 'xsi', "http://www.w3.org/2001/XMLSchema-instance"
-    register_namespace 'xsd', "http://www.w3.org/2001/XMLSchema"
-
-    has_many :ingredients, String
-
-    def initialize(parameters)
-      parameters.each_pair {|property,value| send("#{property}=",value) if respond_to?("#{property}=") }
-    end
-  end
-end
-
-describe "Saving #to_xml", "with xml namespaces" do
-
-  context "#to_xml", "with namespaces" do
-
-    let(:subject) do
-      address = ToXMLWithNamespaces::Address.new('street' => 'Mockingbird Lane',
-      'location' => 'Home',
-      'housenumber' => '1313',
-      'postcode' => '98103',
-      'city' => 'Seattle',
-      'country' => ToXMLWithNamespaces::Country.new(:name => 'USA', :code => 'us'),
-      'date_created' => '2011-01-01 15:00:00')
-
-
-      address.dates_updated = ["2011-01-01 16:01:00","2011-01-02 11:30:01"]
-
-      Nokogiri::XML(address.to_xml).root
-    end
-
-    it "saves elements" do
-      elements = { 'street' => 'Mockingbird Lane', 'postcode' => '98103', 'city' => 'Seattle' }
-
-      elements.each_pair do |property,value|
-        expect(subject.xpath("address:#{property}").text).to eq value
-      end
-    end
-
-    it "saves attributes" do
-      expect(subject.xpath('@location').text).to eq "Home-live"
-    end
-
-    context "when an element has a 'state_when_nil' parameter" do
-      it "saves an empty element" do
-        expect(subject.xpath('address:description').text).to eq ""
-      end
-    end
-
-    context "when an element has a 'on_save' parameter" do
-      context "with a symbol which represents a function" do
-        it "saves the element with the result of a function call and not the value of the instance variable" do
-          expect(subject.xpath("address:housenumber").text).to eq "[1313]"
-        end
-      end
-
-      context "with a lambda" do
-        it "saves the results" do
-          expect(subject.xpath('address:date_created').text).to eq "15:00:00 01/01/11"
-        end
-      end
-    end
-
-    context "when an attribute has a 'on_save' parameter" do
-      context "with a lambda" do
-        it "saves the result" do
-          expect(subject.xpath('@location').text).to eq "Home-live"
-        end
-      end
-    end
-
-    context "when a has_many has a 'on_save' parameter" do
-      context "with a lambda" do
-        it "saves the result" do
-          dates_updated = subject.xpath('address:dates_updated')
-          expect(dates_updated.length).to eq 2
-          expect(dates_updated.first.text).to eq "16:01:00 01/01/11"
-          expect(dates_updated.last.text).to eq "11:30:01 01/02/11"
-        end
-      end
-    end
-
-    context "when an element type is a HappyMapper subclass" do
-      it "saves attributes" do
-        expect(subject.xpath('country:country/@countryCode').text).to eq "us"
-      end
-
-      it "saves elements" do
-        expect(subject.xpath('country:country/countryName:countryName').text).to eq "USA"
-      end
-    end
-  end
-
-  context "with a default namespace" do
-    it "writes the default namespace to xml without repeating xmlns" do
-      recipe = ToXMLWithNamespaces::Recipe.new(:ingredients => ['One Cup Flour', 'Two Scoops of Lovin'])
-      expect(recipe.to_xml).to match(/xmlns=\"urn:eventis:prodis:onlineapi:1\.0\"/)
-    end
-  end
-
-  context 'namespace supplied by element declaration trumps namespace ' \
-          'specified by element class' do
-
-    let(:expected_xml) do
-      <<-XML.gsub(/^\s*\|/, '')
-        |<?xml version="1.0"?>
-        |<coffeemachine xmlns:coffee="http://coffee.org/Coffee/0.1" xmlns:beverage="http://beverages.org/Beverage/0.1">
-        |  <beverage:beverage name="coffee"/>
-        |</coffeemachine>
-      XML
-    end
-
-    class Beverage
-      include HappyMapper
-      namespace 'coffee'
-
-      attribute :name, String
-    end
-
-    class CoffeeMachine
-      include HappyMapper
-      register_namespace 'coffee', "http://coffee.org/Coffee/0.1"
-      register_namespace 'beverage', "http://beverages.org/Beverage/0.1"
-
-      element :beverage, 'beverage', namespace: 'beverage'
-    end
-
-    it 'uses the element declaration namespace on the element' do
-      machine = CoffeeMachine.new
-      machine.beverage = Beverage.new.tap {|obj| obj.name = 'coffee'}
-      expect(machine.to_xml).to eq(expected_xml)
-    end
-  end
-
-end

data/spec/wilcard_tag_name_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-
-describe "Wildcard Root Tag" do
-
-  generic_class_xml = %{
-    <root>
-        <description>some description</description>
-        <blarg name='blargname1' href='http://blarg.com'/>
-        <blarg name='blargname2' href='http://blarg.com'/>
-        <jello name='jelloname' href='http://jello.com'/>
-        <subelement>
-          <jello name='subjelloname' href='http://ohnojello.com' other='othertext'/>
-        </subelement>
-      </root>}
-
-  module GenericBase
-    class Base
-      include Comparable
-      include HappyMapper
-
-      def initialize(params = {})
-        @name = params[:name]
-        @href = params[:href]
-        @other = params[:other]
-      end
-
-      tag '*'
-      attribute :name, String
-      attribute :href, String
-      attribute :other, String
-
-      def <=>(compared)
-        name <=> compared.name && href <=> compared.href && other <=> compared.other
-      end
-    end
-    class Sub
-      include HappyMapper
-      tag 'subelement'
-      has_one :jello, Base, :tag => 'jello'
-    end
-    class Root
-      include HappyMapper
-      tag 'root'
-      element :description, String
-      has_many :blargs, Base, :tag => 'blarg', :xpath => '.'
-      has_many :jellos, Base, :tag => 'jello', :xpath => '.'
-      has_many :subjellos, Base, :tag => 'jello', :xpath => 'subelement/.', :read_only => true
-      has_one :sub_element, Sub
-    end
-  end
-
-  describe "can have generic classes using tag '*'" do
-
-    let(:subject) { GenericBase::Root.parse(generic_class_xml) }
-    let(:xml) { Nokogiri::XML(subject.to_xml) }
-
-    it 'should map different elements to same class' do
-      expect(subject.blargs).not_to be_nil
-      expect(subject.jellos).not_to be_nil
-    end
-
-    it 'should filter on xpath appropriately' do
-      expect(subject.blargs.size).to eq(2)
-      expect(subject.jellos.size).to eq(1)
-      expect(subject.subjellos.size).to eq(1)
-    end
-
-    def base_with(name,href,other)
-      GenericBase::Base.new(:name => name,:href => href,:other => other)
-    end
-
-    it 'should parse correct values onto generic class' do
-      expect(subject.blargs[0]).to eq base_with('blargname1','http://blarg.com',nil)
-      expect(subject.blargs[1]).to eq base_with('blargname2','http://blarg.com',nil)
-      expect(subject.jellos[0]).to eq base_with('jelloname','http://jello.com',nil)
-      expect(subject.subjellos[0]).to eq base_with('subjelloname','http://ohnojello.com','othertext')
-    end
-
-    def validate_xpath(xpath,name,href,other)
-      expect(xml.xpath("#{xpath}/@name").text).to eq name
-      expect(xml.xpath("#{xpath}/@href").text).to eq href
-      expect(xml.xpath("#{xpath}/@other").text).to eq other
-    end
-
-    it 'should #to_xml using parent element tag name' do
-      expect(xml.xpath('/root/description').text).to eq('some description')
-      validate_xpath("/root/blarg[1]","blargname1","http://blarg.com","")
-      validate_xpath("/root/blarg[2]","blargname2","http://blarg.com","")
-      validate_xpath("/root/jello[1]","jelloname","http://jello.com","")
-    end
-
-    it "should properly respect child HappyMapper tags if tag isn't provided on the element defintion" do
-      expect(xml.xpath('root/subelement').size).to eq(1)
-    end
-  end
-end

data/spec/wrap_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe "wrap which allows you to specify a wrapper element" do
-
-  module Wrap
-    class SubClass
-      include HappyMapper
-      tag 'subclass'
-      attribute :myattr, String
-      has_many :items, String, :tag => 'item'
-    end
-    class Root
-      include HappyMapper
-      tag 'root'
-      attribute :attr1, String
-      element :name, String
-      wrap 'mywraptag' do
-        element :description, String
-        has_one :subclass, SubClass
-      end
-      element :number, Integer
-    end
-  end
-
-  describe ".parse" do
-    context "when given valid XML" do
-      let(:subject) { Wrap::Root.parse fixture_file('wrapper.xml') }
-
-      it 'sets the values correctly' do
-        expect(subject.attr1).to eq 'somevalue'
-        expect(subject.name).to eq 'myname'
-        expect(subject.description).to eq 'some description'
-        expect(subject.subclass.myattr).to eq 'attrvalue'
-        expect(subject.subclass.items.size).to eq(2)
-        expect(subject.subclass.items[0]).to eq 'item1'
-        expect(subject.subclass.items[1]).to eq 'item2'
-        expect(subject.number).to eq 12345
-      end
-    end
-
-    context "when initialized without XML" do
-      let(:subject) { Wrap::Root.new }
-
-      it "anonymous classes are created so nil class values does not occur" do
-        expect { subject.description = 'anything' }.to_not raise_error
-      end
-    end
-  end
-
-  describe ".to_xml" do
-    let(:subject) do
-      root = Wrap::Root.new
-      root.attr1 = 'somevalue'
-      root.name = 'myname'
-      root.description = 'some description'
-      root.number = 12345
-
-      subclass = Wrap::SubClass.new
-      subclass.myattr = 'attrvalue'
-      subclass.items = []
-      subclass.items << 'item1'
-      subclass.items << 'item2'
-
-      root.subclass = subclass
-
-      root
-    end
-
-    it "generates the correct xml" do
-      xml = Nokogiri::XML(subject.to_xml)
-      expect(xml.xpath('/root/@attr1').text).to eq 'somevalue'
-      expect(xml.xpath('/root/name').text).to eq 'myname'
-      expect(xml.xpath('/root/mywraptag/description').text).to eq 'some description'
-      expect(xml.xpath('/root/mywraptag/subclass/@myattr').text).to eq 'attrvalue'
-      expect(xml.xpath('/root/mywraptag/subclass/item').size).to eq(2)
-      expect(xml.xpath('/root/mywraptag/subclass/item[1]').text).to eq 'item1'
-      expect(xml.xpath('/root/mywraptag/subclass/item[2]').text).to eq 'item2'
-      expect(xml.xpath('/root/number').text).to eq '12345'
-    end
-
-  end
-end

data/spec/xpath_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe "Specifying elements and attributes with an xpath" do
-
-  class Item
-    include HappyMapper
-
-    tag 'item'
-    namespace 'amazing'
-
-    element :title, String
-    attribute :link, String, :xpath => 'amazing:link/@href'
-    has_one :different_link, String, :xpath => 'different:link/@href'
-    element :detail, String, :xpath => 'amazing:subitem/amazing:detail'
-    has_many :more_details_text, String, :xpath => 'amazing:subitem/amazing:more'
-    has_many :more_details, String, :xpath => 'amazing:subitem/amazing:more/@first|amazing:subitem/amazing:more/@alternative'
-    has_many :more_details_alternative, String, :xpath => 'amazing:subitem/amazing:more/@*'
-
-    has_one :baby, 'Baby', :name => 'baby', :namespace => 'amazing'
-
-  end
-
-  class Baby
-    include HappyMapper
-
-    has_one :name, String
-  end
-
-  let(:subject) { Item.parse(xml_string,:single => true) }
-
-  let(:xml_string) do
-    %{
-    <rss>
-      <amazing:item xmlns:amazing="http://www.amazing.com/amazing" xmlns:different="http://www.different.com/different">
-        <amazing:title>Test XML</amazing:title>
-        <different:link href="different_link" />
-        <amazing:link href="link_to_resources" />
-        <amazing:subitem>
-          <amazing:detail>I want to parse this</amazing:detail>
-          <amazing:more first="this one">more 1</amazing:more>
-          <amazing:more alternative="another one">more 2</amazing:more>
-        </amazing:subitem>
-        <amazing:baby>
-          <amazing:name>Jumbo</amazing:name>
-        </amazing:baby>
-      </amazing:item>
-    </rss>
-    }
-  end
-
-  it "should have a title" do
-    expect(subject.title).to eq "Test XML"
-  end
-
-  it "should find the link href value" do
-    expect(subject.link).to eq 'link_to_resources'
-  end
-
-  it "should find the link href value" do
-    expect(subject.different_link).to eq 'different_link'
-  end
-
-  it "should find this subitem based on the xpath" do
-    expect(subject.detail).to eq 'I want to parse this'
-  end
-
-  it "should find the subitems based on the xpath" do
-    expect(subject.more_details_text.size).to eq(2)
-    expect(subject.more_details_text.first).to eq  "more 1"
-    expect(subject.more_details_text.last).to eq "more 2"
-  end
-
-  it "should find the subitems based on the xpath" do
-    expect(subject.more_details.size).to eq(2)
-    expect(subject.more_details.first).to eq "this one"
-    expect(subject.more_details.last).to eq "another one"
-  end
-
-  it "should find the subitems based on the xpath" do
-    expect(subject.more_details_alternative.size).to eq(2)
-    expect(subject.more_details_alternative.first).to eq "this one"
-    expect(subject.more_details_alternative.last).to eq "another one"
-  end
-
-  it "should have a baby name" do
-    expect(subject.baby.name).to eq "Jumbo"
-  end
-
-end