xml_resource 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 onrooby GmbH
+
+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,2 @@
+xml_resource
+============

data/Rakefile

@@ -0,0 +1,34 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'XmlResource'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/xml_resource/base.rb

@@ -0,0 +1,171 @@
+module XmlResource
+  class Base
+    class_attribute :attributes, :collections, :objects, :root_path
+    self.attributes = {}
+    self.collections = {}
+    self.objects = {}
+  
+    class XmlResource::ParseError < Exception; end
+    class XmlResource::TypeCastError < Exception; end
+  
+    class << self
+    
+      def from_xml(xml_or_string)
+        xml_or_string and xml = parse(xml_or_string) or return
+        attrs = {}
+        self.attributes.each do |name, options|
+          if xpath = attribute_xpath(name)
+            node = xml.at(xpath)
+            value = node ? node.inner_text : nil
+            if !value.nil? && type = attribute_type(name)
+              value = cast_to(type, value)
+            end
+            attrs[name] = value
+          end
+        end
+        self.objects.each do |name, options|
+          if xpath = object_xpath(name)
+            attrs[name] = object_class(name).from_xml(xml.at(xpath))
+          end
+        end
+        self.collections.each do |name, options|
+          if xpath = collection_xpath(name)
+            attrs[name] = collection_class(name).collection_from_xml(xml.at(xpath))
+          end
+        end
+        new attrs
+      end
+    
+      def collection_from_xml(xml_or_string)
+        parse(xml_or_string).search(root).map { |element| from_xml(element) }.compact
+      end
+    
+      def basename
+        name.sub(/^.*::/, '')
+      end
+    
+      def root
+        self.root_path || "/#{self.basename.underscore}"
+      end
+    
+      def root=(root)
+        self.root_path = root
+      end
+    
+      [:attribute, :object, :collection].each do |method_name|
+        define_method "#{method_name}_names" do
+          send(method_name.to_s.pluralize).keys
+        end
+      end
+    
+      protected
+    
+      def has_attribute(name, options = {})
+        self.attributes = attributes.merge(name.to_sym => options.symbolize_keys!)
+        attribute_accessor_method name
+      end
+    
+      def has_attributes(*args)
+        options = args.extract_options!
+        args.each { |arg| has_attribute arg, options }
+      end
+    
+      def has_object(name, options = {})
+        self.objects = objects.merge(name.to_sym => options.symbolize_keys!)
+        attr_accessor name
+      end
+    
+      def has_collection(name, options = {})
+        self.collections = collections.merge(name.to_sym => options.symbolize_keys!)
+        define_method "#{name}" do
+          instance_variable_get("@#{name}") or instance_variable_set("@#{name}", [])
+        end
+        define_method "#{name}=" do |assignment|
+          instance_variable_set("@#{name}", assignment) if assignment
+        end
+      end
+
+      private
+    
+      def attribute_accessor_method(name)
+        define_method("#{name}") { self[name] }
+        define_method("#{name}=") { |value| self[name] = value }
+      end
+
+      [:attribute, :object, :collection].each do |method_name|
+        define_method "#{method_name}_xpath" do |name|
+          options = send(method_name.to_s.pluralize)
+          options[name] && options[name][:xpath] or "/#{name}"
+        end
+      end
+
+      def attribute_type(name)
+        attributes[name] && attributes[name][:type]
+      end
+    
+      def object_class(name)
+        if objects[name] && class_name = objects[name][:class_name]
+          class_name.constantize
+        else
+          name.to_s.camelize.constantize
+        end
+      end
+    
+      def collection_class(name)
+        if collections[name] && class_name = collections[name][:class_name]
+          class_name.constantize
+        else
+          name.to_s.singularize.camelize.constantize
+        end
+      end
+    
+      def cast_to(type, value)  # only called for non-nil values
+        case type
+        when :string    then value
+        when :integer   then value.to_i
+        when :float     then value.to_f
+        when :boolean   then !!value
+        when :decimal   then BigDecimal.new(value)
+        when :date      then Date.parse(value)
+        when :datetime  then DateTime.parse(value)
+        else
+          raise XmlResource::TypeCastError, "don't know how to cast #{value.inspect} to #{type}"
+        end
+      end
+
+      def parse(xml_or_string)
+        case xml_or_string
+        when Hpricot::Elem, Hpricot::Elements then xml_or_string
+        when String then Hpricot.XML(xml_or_string).root
+        else
+          raise XmlResource::ParseError, "cannot parse #{xml_or_string.inspect}"
+        end 
+      end
+    end
+  
+    def initialize(attrs = {})
+      self.attributes = attrs
+    end
+
+    def valid?
+      true
+    end
+  
+    def attributes=(attrs)
+      attrs.each { |name, value| send "#{name}=", value }
+    end
+  
+    def attributes
+      @attributes ||= {}.with_indifferent_access
+    end
+  
+    def [](attr_name)
+      attributes[attr_name]
+    end
+  
+    def []=(attr_name, value)
+      attributes[attr_name] = value
+    end
+  
+  end
+end

data/lib/xml_resource/version.rb

@@ -0,0 +1,3 @@
+module XmlResource
+  VERSION = '1.0.0'
+end

data/lib/xml_resource.rb

@@ -0,0 +1,4 @@
+require 'active_support/core_ext'
+require 'hpricot'
+require 'xml_resource/version'
+require 'xml_resource/base'

data/test/cases/xml_resource_test.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+require 'xml_resource'
+
+class XmlResourceTest < ActiveSupport::TestCase
+
+  setup do
+    xml = File.read(File.expand_path(File.dirname(__FILE__) + '/../data/orders.xml'))
+    @orders = Order.collection_from_xml(xml)
+  end    
+  
+  test 'Instantiation of attributes' do
+    assert_equal 3, orders.size
+    assert_equal [1, 2, 3], orders.map(&:id)
+    assert_equal %w(A B C), orders.map(&:foobar)
+    assert_equal %w(2012-08-27 2012-08-26 2012-08-25).map(&:to_date), orders.map(&:date)
+    assert_equal [12.99, 10, -12.99], orders.map(&:shipping_cost)
+    assert_equal [BigDecimal], orders.map(&:shipping_cost).map(&:class).uniq
+    assert_equal [:quantity, :name], Item.attribute_names
+  end
+  
+  test 'Instantiation of objects' do
+    assert_equal "Mister Spock", orders.first.customer.name
+    assert_equal "Käptn Kirk", orders.second.customer.name
+    assert_equal nil, orders.third.customer
+    assert_equal ['E F', 'A B', 'C D'], orders.map(&:contact).map(&:name)
+  end
+  
+  test 'Instantiation of collections' do
+    items = orders.map(&:items)
+    assert_equal [1, 2, 3], items.map(&:size)
+    assert_equal [[3], [3, 2], [3, 2, 1]], items.map { |ary| ary.map(&:quantity) }
+    assert_equal [%w(1Three), %w(2Three 2Two), %w(3Three 3Two 3One)], items.map { |ary| ary.map(&:name) }
+  end
+  
+  test 'Inheritance' do
+    subklass = Class.new(Item) { self.root = 'subitem' }
+    assert_equal 'subitem', subklass.root
+    assert_equal 'i', Item.root
+  end
+  
+  test 'Validation method' do
+    assert_equal true, orders.first.valid?
+  end
+  
+  test 'Invalid data raises error' do
+    assert_raise(XmlResource::ParseError) { Order.collection_from_xml({}) }
+  end
+  
+  private
+  
+  def orders
+    @orders
+  end
+  
+end

data/test/data/orders.xml

@@ -0,0 +1,82 @@
+<someroot>
+  <order>
+    <id>1</id>
+    <info>
+      <foo type="bar">A</foo>
+      <date>2012-08-27</date>
+      <foo type="non">sense</foo>
+    </info>
+    <shipping_cost>12.99</shipping_cost>
+    <customer>
+      <first_name>Mister</first_name>
+      <last_name>Spock</last_name>
+    </customer>
+    <contact>
+      <first_name>E</first_name>
+      <last_name>F</last_name>
+    </contact>
+    <items>
+      <i>
+        <quantity>3</quantity>
+        <name>1Three</name>
+      </i>
+    </items>
+  </order>
+  
+  <order>
+    <id>2</id>
+    <info>
+      <foo type="non">blubb</foo>
+      <foo type="bar">B</foo>
+      <date>2012-08-26</date>
+    </info>
+    <shipping_cost>10</shipping_cost>
+    <customer>
+      <first_name>Käptn</first_name>
+      <last_name>Kirk</last_name>
+    </customer>
+    <contact>
+      <first_name>A</first_name>
+      <last_name>B</last_name>
+    </contact>
+    <items>
+      <i>
+        <quantity>3</quantity>
+        <name>2Three</name>
+      </i>
+      <i>
+        <quantity>2</quantity>
+        <name>2Two</name>
+      </i>
+    </items>
+  </order>
+  
+  <order>
+    <id>3</id>
+    <info>
+      <foo type="non">wah</foo>
+      <foo type="bar">C</foo>
+      <date>2012-08-25</date>
+    </info>
+    <shipping_cost>-12.99</shipping_cost>
+    <contact>
+      <first_name>C</first_name>
+      <last_name>D</last_name>
+    </contact>
+    <items>
+      <i>
+        <quantity>3</quantity>
+        <name>3Three</name>
+      </i>
+      <i>
+        <quantity>2</quantity>
+        <name>3Two</name>
+      </i>
+      <i>
+        <quantity>1</quantity>
+        <name>3One</name>
+      </i>
+    </items>    
+  </order>
+  
+</someroot>

data/test/models/contact.rb

@@ -0,0 +1,7 @@
+class Contact < XmlResource::Base
+  has_attributes :first_name, :last_name, :type => :string
+  
+  def name
+    "#{first_name} #{last_name}"
+  end
+end

data/test/models/item.rb

@@ -0,0 +1,6 @@
+class Item < XmlResource::Base
+  self.root = 'i'
+  
+  has_attribute :quantity, :type => :float
+  has_attribute :name
+end

data/test/models/order.rb

@@ -0,0 +1,11 @@
+class Order < XmlResource::Base
+  has_attribute :id, :type => :integer
+  has_attribute :date, :type => :date, :xpath => '/info/date'
+  has_attribute :foobar, :xpath => '/info/foo[@type="bar"]'
+  has_attribute :shipping_cost, :type => :decimal
+  
+  has_object :customer, :class_name => "Contact"
+  has_object :contact
+  
+  has_collection :items, :class_name => "Item", :xpath => '/items'
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+ENV["RAILS_ENV"] = "test"
+
+require 'pathname'
+
+if RUBY_VERSION >= '1.9'
+  require 'simplecov'
+  SimpleCov.start do
+    if artifacts_dir = ENV['CC_BUILD_ARTIFACTS']
+      coverage_dir Pathname.new(artifacts_dir).relative_path_from(Pathname.new(SimpleCov.root)).to_s
+    end
+    add_filter '/test/'
+    add_filter 'vendor'
+  end
+
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+    if result = SimpleCov.result
+      File.open(File.join(SimpleCov.coverage_path, 'coverage_percent.txt'), 'w') { |f| f << result.covered_percent.to_s }
+    end
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default)
+require 'test/unit'
+
+require 'xml_resource'
+
+require File.expand_path('../models/item', __FILE__)
+require File.expand_path('../models/contact', __FILE__)
+require File.expand_path('../models/order', __FILE__)

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: xml_resource
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Matthias Grosser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2151918380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2151918380
+- !ruby/object:Gem::Dependency
+  name: hpricot
+  requirement: &2151917700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2151917700
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: &2151917100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151917100
+description: ''
+email:
+- mtgrosser@gmx.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/xml_resource/base.rb
+- lib/xml_resource/version.rb
+- lib/xml_resource.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+- test/cases/xml_resource_test.rb
+- test/data/orders.xml
+- test/models/contact.rb
+- test/models/item.rb
+- test/models/order.rb
+- test/test_helper.rb
+homepage: http://rubygems.org/gems/xml_resource
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Turn XML into Ruby objects
+test_files:
+- test/cases/xml_resource_test.rb
+- test/data/orders.xml
+- test/models/contact.rb
+- test/models/item.rb
+- test/models/order.rb
+- test/test_helper.rb