nokogiri-happymapper 0.6.0 → 0.9.0

data/spec/has_many_empty_array_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-module Sheep
-  class Item
-    include HappyMapper
-  end
-
-  class Navigator
-    include HappyMapper
-    tag 'navigator'
-
-    # This is purposefully set to have the name 'items' with the tag 'item'.
-    # The idea is that it should not find the empty items contained within the
-    # xml and return an empty array. This exercises the order of how nodes
-    # are searched for within an XML document.
-    has_many :items, Item, tag: 'item'
-
-    has_many :items_with_a_different_name, Item, tag: 'item'
-
-  end
-end
-
-describe "emptyness" do
-  let(:xml) do
-    <<-EOF
-    <navigator>
-      <items/>
-    </navigator>
-    EOF
-  end
-
-  let(:navigator) do
-    Sheep::Navigator.parse(xml)
-  end
-
-  it "returns an empty array" do
-    expect(navigator.items_with_a_different_name).to be_empty
-  end
-
-  it "returns an empty array" do
-    expect(navigator.items).to be_empty
-  end
-end

data/spec/ignay_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-class CatalogTree
-  include HappyMapper
-
-  tag 'CatalogTree'
-  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'
-
-  attribute :code, String
-
-  has_many :nodes, 'CatalogNode', :tag => 'Node', :xpath => '.'
-
-end
-
-
-class CatalogNode
-  include HappyMapper
-
-  tag 'Node'
-
-  attribute :back_office_id, String, :tag => 'vodBackOfficeId'
-
-  has_one :name, String, :tag => 'Name'
-  # other important fields
-
-  has_many :translations, 'CatalogNode::Translations', :tag => 'Translation', :xpath => 'child::*'
-
-  class Translations
-    include HappyMapper
-    tag 'Translation'
-
-    attribute :language, String, :tag => 'Language'
-    has_one :name, String, :tag => 'Name'
-
-  end
-
-  has_many :nodes, CatalogNode, :tag => 'Node', :xpath => 'child::*'
-
-end
-
-describe HappyMapper do
-
-  it "should not be nil" do
-    expect(catalog_tree).not_to be_nil
-  end
-
-  it "should have the attribute code" do
-    expect(catalog_tree.code).to eq("NLD")
-  end
-
-  it "should have many nodes" do
-    expect(catalog_tree.nodes).not_to be_empty
-    expect(catalog_tree.nodes.length).to eq(2)
-  end
-
-  context "first node" do
-
-    it "should have a name" do
-      expect(first_node.name).to eq("Parent 1")
-    end
-
-    it "should have translations" do
-      expect(first_node.translations.length).to eq(2)
-
-      expect(first_node.translations.first.language).to eq("en-GB")
-
-      expect(first_node.translations.last.name).to eq("Parent 1 de")
-    end
-
-    it "should have subnodes" do
-      expect(first_node.nodes).to be_kind_of(Enumerable)
-      expect(first_node.nodes).not_to be_empty
-      expect(first_node.nodes.length).to eq(1)
-    end
-
-    it "first node - first node name" do
-      expect(first_node.nodes.first.name).to eq("First")
-    end
-
-    def first_node
-      @first_node = catalog_tree.nodes.first
-    end
-
-  end
-
-
-  def catalog_tree ; @catalog_tree ; end
-
-  before(:all) do
-    xml_reference = "#{File.dirname(__FILE__)}/fixtures/inagy.xml"
-    @catalog_tree = CatalogTree.parse(File.read(xml_reference), :single => true)
-  end
-end

data/spec/inheritance_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-
-describe "Using inheritance to share elements and attributes" do
-
-  class Genetics
-    include HappyMapper
-    content :dna, String
-  end
-
-  class Parent
-    include HappyMapper
-    attribute :love, Integer
-    element :genetics, Genetics
-  end
-
-  class Child < Parent
-    include HappyMapper
-    attribute :naivety, String
-    has_many :immunities, String
-  end
-
-  class Overwrite < Parent
-    include HappyMapper
-
-    attribute :love, String
-    element :genetics, Integer
-  end
-
-  describe "Overwrite" do
-    let(:subject) do
-      xml = '<overwrite love="love" naivety="trusting"><genetics>1001</genetics><immunities>Chicken Pox</immunities></overwrite>'
-      Overwrite.parse(xml, single: true)
-    end
-
-    it 'overrides the parent elements and attributes' do
-      expect(Overwrite.attributes.count).to be == Parent.attributes.count
-      expect(Overwrite.elements.count).to be == Parent.elements.count
-    end
-
-    context "when parsing xml" do
-      it 'parses the new overwritten attribut' do
-        expect(subject.love).to be == "love"
-      end
-
-      it 'parses the new overwritten element' do
-        expect(subject.genetics).to be == 1001
-      end
-    end
-
-    context "when saving to xml" do
-      subject do
-        overwrite = Overwrite.new
-        overwrite.genetics = 1
-        overwrite.love = "love"
-        Nokogiri::XML(overwrite.to_xml).root
-      end
-
-      it 'has only 1 genetics element' do
-        expect(subject.xpath('//genetics').count).to be == 1
-      end
-
-      it 'has only 1 love attribute' do
-        expect(subject.xpath('@love').text).to be == "love"
-      end
-    end
-  end
-
-  describe "Child", "a subclass of the Parent" do
-    let(:subject) do
-      xml = '<child love="99" naivety="trusting"><genetics>ABBA</genetics><immunities>Chicken Pox</immunities></child>'
-      Child.parse(xml)
-    end
-
-    context "when parsing xml" do
-      it 'should be possible to deserialize XML into a Child class instance' do
-        expect(subject.love).to eq 99
-        expect(subject.genetics.dna).to eq "ABBA"
-        expect(subject.naivety).to eq "trusting"
-        expect(subject.immunities.size).to eq(1)
-      end
-    end
-
-    context "when saving to xml" do
-      let(:subject) do
-        child = Child.new
-        child.love = 100
-        child.naivety = 'Bright Eyed'
-        child.immunities = [ "Small Pox", "Chicken Pox", "Mumps" ]
-        genetics = Genetics.new
-        genetics.dna = "GATTACA"
-        child.genetics = genetics
-        Nokogiri::XML(child.to_xml).root
-      end
-
-      it "saves both the Child and Parent attributes" do
-        expect(subject.xpath("@naivety").text).to eq "Bright Eyed"
-        expect(subject.xpath("@love").text).to eq "100"
-      end
-
-      it "saves both the Child and Parent elements" do
-        expect(subject.xpath("genetics").text).to eq "GATTACA"
-        expect(subject.xpath("immunities").size).to eq(3)
-      end
-    end
-
-  end
-end

data/spec/mixed_namespaces_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe "A document with mixed namespaces" do
-
-  #
-  # Note that the parent element of the xml has the namespacing. The elements
-  # contained within the xml do not share the parent element namespace so a
-  # user of the library would likely need to clear the namespace on each of
-  # these child elements.
-  #
-  let(:xml_document) do
-    %{<prefix:address location='home' xmlns:prefix="http://www.unicornland.com/prefix"
-        xmlns:different="http://www.trollcountry.com/different">
-        <street>Milchstrasse</street>
-        <street>Another Street</street>
-        <housenumber>23</housenumber>
-        <different:postcode>26131</different:postcode>
-        <city>Oldenburg</city>
-      </prefix:address>}
-  end
-
-  module MixedNamespaces
-    class Address
-      include HappyMapper
-
-      namespace :prefix
-      tag :address
-
-      # Here each of the elements have their namespace set to nil to reset their
-      # namespace so that it is not the same as the prefix namespace
-
-      has_many :streets, String, tag: 'street', namespace: nil
-
-      has_one :house_number, String, tag: 'housenumber', namespace: nil
-      has_one :postcode, String, namespace: 'different'
-      has_one :city, String, namespace: nil
-    end
-  end
-
-  let(:address) do
-    MixedNamespaces::Address.parse(xml_document, single: true)
-  end
-
-
-  it "has the correct streets" do
-    expect(address.streets).to eq [ "Milchstrasse", "Another Street" ]
-  end
-
-  it "house number" do
-    expect(address.house_number).to eq "23"
-  end
-
-  it "postcode" do
-    expect(address.postcode).to eq "26131"
-  end
-
-  it "city" do
-    expect(address.city).to eq "Oldenburg"
-  end
-
-end

data/spec/parse_with_object_to_update_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe "Updating existing objects with .parse and #parse" do
-
-  let(:subject) { ParseInstanceSpec::Root.parse(parse_instance_initial_xml) }
-
-  let(:parse_instance_initial_xml) do
-     %{<root attr1="initial">
-      <item attr1="initial">
-        <description>initial</description>
-        <subitem attr1="initial">
-          <name>initial</name>
-        </subitem>
-        <subitem attr1="initial">
-          <name>initial</name>
-        </subitem>
-      </item>
-      <item attr1="initial">
-        <description>initial</description>
-        <subitem attr1="initial">
-          <name>initial</name>
-        </subitem>
-        <subitem attr1="initial">
-          <name>initial</name>
-        </subitem>
-      </item>
-    </root>}
-  end
-
-  let(:parse_instance_updated_xml) do
-    %{<root attr1="updated">
-      <item attr1="updated">
-        <description>updated</description>
-        <subitem attr1="updated">
-          <name>updated</name>
-        </subitem>
-        <subitem attr1="updated">
-          <name>updated</name>
-        </subitem>
-      </item>
-      <item attr1="updated">
-        <description>updated</description>
-        <subitem attr1="updated">
-          <name>updated</name>
-        </subitem>
-        <subitem attr1="updated">
-          <name>updated</name>
-        </subitem>
-      </item>
-    </root>}
-  end
-
-  module ParseInstanceSpec
-    class SubItem
-      include HappyMapper
-      tag 'subitem'
-      attribute :attr1, String
-      element :name, String
-    end
-    class Item
-      include HappyMapper
-      tag 'item'
-      attribute :attr1, String
-      element :description, String
-      has_many :sub_items, SubItem
-    end
-    class Root
-      include HappyMapper
-      tag 'root'
-      attribute :attr1, String
-      has_many :items, Item
-    end
-  end
-
-  def item_is_correctly_defined(item,value='initial')
-    expect(item.attr1).to eq value
-    expect(item.description).to eq value
-    expect(item.sub_items[0].attr1).to eq value
-    expect(item.sub_items[0].name).to eq value
-    expect(item.sub_items[1].attr1).to eq value
-    expect(item.sub_items[1].name).to eq value
-  end
-
-  it 'initial values are correct' do
-    expect(subject.attr1).to eq('initial')
-    item_is_correctly_defined( subject.items[0] )
-    item_is_correctly_defined( subject.items[1] )
-  end
-
-
-  describe ".parse", "specifying an existing object to update" do
-    it 'all fields are correct' do
-      ParseInstanceSpec::Root.parse(parse_instance_updated_xml, :update => subject)
-      expect(subject.attr1).to eq 'updated'
-
-      item_is_correctly_defined( subject.items[0], 'updated' )
-      item_is_correctly_defined( subject.items[1], 'updated' )
-    end
-  end
-
-  describe "#parse" do
-    it "all fields are correct" do
-      subject.parse(parse_instance_updated_xml)
-      expect(subject.attr1).to eq 'updated'
-
-      item_is_correctly_defined( subject.items[0], 'updated' )
-      item_is_correctly_defined( subject.items[1], 'updated' )
-    end
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,7 +0,0 @@
-require 'rspec'
-
-require 'happymapper'
-
-def fixture_file(filename)
-  File.read(File.dirname(__FILE__) + "/fixtures/#{filename}")
-end

data/spec/to_xml_spec.rb

@@ -1,201 +0,0 @@
-require 'spec_helper'
-
-describe "Saving #to_xml" do
-
-  module ToXML
-    class Address
-      include HappyMapper
-
-      tag 'address'
-
-      attribute :location, String, :on_save => :when_saving_location
-
-      element :street, String
-      element :postcode, String
-      element :city, String
-
-      element :housenumber, String
-
-      attribute :modified, Boolean, :read_only => true
-      element :temporary, Boolean, :read_only => true
-      #
-      # 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 }
-
-
-      #
-      # Execute the method with the same name
-
-      #
-      # 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
-      #
-      element :country, 'Country', :tag => 'country'
-
-      attribute :occupied, Boolean
-
-      def initialize(parameters)
-        parameters.each_pair do |property,value|
-          send("#{property}=",value) if respond_to?("#{property}=")
-        end
-        @modified = @temporary = true
-      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
-
-      attribute :code, String, :tag => 'countryCode'
-      has_one :name, String, :tag => 'countryName'
-      has_one :description, 'Description', :tag => 'description'
-
-      #
-      # This inner-class here is to demonstrate saving a text node
-      # and optional attributes
-      #
-      class Description
-        include HappyMapper
-        content :description, String
-        attribute :category, String, :tag => 'category'
-        attribute :rating, String, :tag => 'rating', :state_when_nil => true
-
-        def initialize(desc)
-          @description = desc
-        end
-      end
-
-      def initialize(parameters)
-        parameters.each_pair do |property,value|
-          send("#{property}=",value) if respond_to?("#{property}=")
-        end
-      end
-
-    end
-  end
-
-  let(:subject) do
-    address = ToXML::Address.new 'street' => 'Mockingbird Lane',
-      'location' => 'Home',
-      'housenumber' => '1313',
-      'postcode' => '98103',
-      'city' => 'Seattle',
-      'country' => ToXML::Country.new(:name => 'USA', :code => 'us', :empty_code => nil,
-        :description => ToXML::Country::Description.new("A lovely country") ),
-      'date_created' => '2011-01-01 15:00:00',
-      'occupied' => false
-
-    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("#{property}").text).to eq value
-    end
-  end
-
-  it "saves attributes" do
-    expect(subject.xpath('@location').text).to eq "Home-live"
-  end
-
-  it 'saves attributes that are Boolean and have a value of false' do
-    expect(subject.xpath('@occupied').text).to eq "false"
-  end
-
-  context "when an element has a 'read_only' parameter" do
-    it "does not save elements" do
-      expect(subject.xpath('temporary')).to be_empty
-    end
-  end
-
-  context "when an attribute has a 'read_only' parameter" do
-    it "does not save attributes" do
-      expect(subject.xpath("@modified")).to be_empty
-    end
-  end
-
-  context "when an element has a 'state_when_nil' parameter" do
-    it "saves an empty element" do
-      expect(subject.xpath('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 the function" do
-        expect(subject.xpath("housenumber").text).to eq "[1313]"
-      end
-    end
-
-    context "with a lambda" do
-      it "saves the result of the lambda" do
-        expect(subject.xpath('date_created').text).to eq "15:00:00 01/01/11"
-      end
-    end
-  end
-
-  context "when a has_many has a 'on_save' parameter" do
-    context "with a lambda" do
-      it "saves the results" do
-        dates_updated = subject.xpath('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 attribute has a 'on_save' parameter" do
-    context "with a symbol which represents a function" do
-      it "saves the result" do
-        expect(subject.xpath('@location').text).to eq "Home-live"
-      end
-    end
-  end
-
-  context "when an element type is a HappyMapper subclass" do
-    it "saves attributes" do
-      expect(subject.xpath('country/@countryCode').text).to eq "us"
-    end
-
-    it "saves elements" do
-      expect(subject.xpath('country/countryName').text).to eq "USA"
-    end
-
-    it "saves elements" do
-      expect(subject.xpath('country/description').text).to eq "A lovely country"
-    end
-  end
-end