model_xml 1.0.0

data/.gitignore

@@ -0,0 +1 @@
+*.sw*

data/README.md

@@ -0,0 +1,104 @@
+Introduction
+============
+
+model_xml is a small gem which helps in the conversion of ruby objects to xml.  It is designed with ActiveRecord objects in mind, but should work with any Ruby object.
+
+Installation
+============
+
+gem 'model_xml' in your gemfile, or gem install model_xml
+
+If you are using Rails, just require model_xml any time after ActiveRecord has loaded - the bottom of your environment.rb file is fine.  Otherwise, require model_xml, then include ModelXML in your object.
+
+Usage
+=====
+
+Take a look at ActiveRecord's baked in to_xml method first.  If it meets your requirements, obviously just use that.  If not, read on.
+
+The simplest usage method is just to declare the list of fields you want in your model's xml representation, like this:
+
+    class User < ActiveRecord::Base
+      model_xml :first_name, :last_name, :dob
+    end
+
+Then user.to_xml gives:
+
+    <user>
+      <first_name>John</first_name>
+      <last_name>Jones</last_name>
+      <dob>1970-12-23</dob>
+    </user>
+
+Note that (unlike ActiveRecords's to_xml) the field names can be any method in your object, not just database columns - eg
+
+    class User < ActiveRecord::Base
+      model_xml :full_name, :dob
+
+      def full_name
+        "#{first_name} {last+name}"
+      end
+    end
+
+behaves as expected:
+
+    <user>
+      <full_name>John Jones</full_name>
+      <dob>1970-12-23</dob>
+    </user>
+
+You can even declare a formatting proc on the fly, like this:
+
+    class User < ActiveRecord::Base
+      model_xml [:full_name, proc {|u| "#{u.first_name} #{u.last_name}"], :dob
+    end
+
+which would give the same result.
+
+For more complicated setups, you can use block notation like this:
+
+    class User < ActiveRecord::Base
+      model_xml do
+        full_name proc {|u| "#{u.first_name} #{u.last_name}"}
+        dob
+        password
+        last_logged_in
+      end
+    end
+
+Finally, you can declare named blocks using block notation like this:
+
+    class User < ActiveRecord::Base
+      model_xml :first_name, :last_name
+      model_xml :personal_details do
+        dob
+        password
+        last_logged_in
+      end
+    end
+
+By default named blocks are excluded from the xml, so user.to_xml gives
+
+    <user>
+      <first_name>John</first_name>
+      <last_name>Jones</last_name>
+    </user>
+
+but can be included explicitly - so user.to_xml(:personal_details => true) gives
+
+    <user>
+      <first_name>John</first_name>
+      <last_name>Jones</last_name>
+      <dob>1970-12-23</dob>
+      <password>foo</password>
+      <last_logged_in>2012-04-10</last_logged_in>
+    </user>
+
+Source
+======
+
+Source is on github https://github.com/rob-anderson/model_xml
+
+Bugs
+====
+
+Send bugs or comments to me rob.anderson@paymentcardsolutions.co.uk

data/lib/model_xml/block_parser.rb

@@ -0,0 +1,34 @@
+module ModelXML
+  class BlockParser
+
+    class << self
+
+      def parse &block
+        raise "block required" unless block_given?
+        parser = self.new
+        parser.instance_eval &block
+        parser.field_set
+      end
+
+    end
+
+    attr_reader :field_set
+
+    def initialize
+      @field_set = []
+    end
+
+    def method_missing *args
+
+      # if the method is called without arguments, add it as a member of the field set
+      if args.map(&:class) == [Symbol]
+        @field_set << args[0]
+
+      # otherwise add it as an array
+      else
+        @field_set << args
+      end
+    end
+
+  end
+end

data/lib/model_xml/generator.rb

@@ -0,0 +1,116 @@
+require 'rubygems'
+require 'builder'
+require 'nokogiri'
+require 'model_xml/block_parser'
+
+module ModelXML
+  class Generator
+
+    attr_reader :field_sets
+
+    def initialize
+      @field_sets ||= []
+    end
+
+    # three types of argument list are expected:
+    #
+    # 1. an unnamed fieldset expressed as any number of symbols eg
+    # model_xml :id, :first_name, :last_name, [:embossed_name, :getter => proc {|u| "#{u.first_name} #{u.last_name}".upcase}]
+    #
+    # 2. a named fieldset in block notation eg
+    # model_xml :personal_data do
+    #   :first_name
+    #   :last_name
+    #   :embossed_name proc {|u| "#{u.first_name} #{u.last_name}".upcase}
+    # end
+    #
+    # 3. an unnamed fieldset in block notation eg
+    # model_xml do
+    #   :first_name
+    #   last_name
+    # end
+
+    def add_field_set *args, &block
+
+      # if the argument list is empty and we have a block, it is an unnamed block
+      if args.empty? && block_given?
+        @field_sets << ModelXML::BlockParser.parse(&block)
+
+      # otherwise if the argument list is a symbol and we have a block, it is a named block
+      elsif args.map(&:class) == [Symbol] && block_given?
+        name = args[0]
+        @field_sets << {name => ModelXML::BlockParser.parse(&block)}
+
+      # otherwise assume it is a simple fieldset expressed as symbols
+      else
+        @field_sets << args
+      end
+    end
+
+    # apply any options to the default field sets to generate a single array of fields
+    def generate_field_list options={}
+
+      field_list = []
+      @field_sets.each do |field_set|
+
+        # if the field set is a hash then it is a hash of conditional field sets
+        # which should only be included if the conditions are present as options
+        if field_set.is_a?(Hash)
+          field_set.each do |k, v|
+            field_list += v if options[k]
+          end
+
+        # otherwise, always include
+        else
+          field_list += field_set
+        end
+      end
+      field_list
+    end
+
+    def generate_xml! object, options={}
+
+      field_list = generate_field_list(options)
+
+      xml = Builder::XmlMarkup.new
+      unless options[:skip_instruct]
+        xml.instruct!
+      end
+
+      xml.tag! object.class.to_s.downcase do
+
+        field_list.each do |field|
+
+          # if the field is a symbol, treat it as the field name and the getter method
+          if field.is_a?(Symbol)
+            tag = field
+            content = object.send(field)
+
+          # if the field is an array of a symbol followed by a proc, assume the symbol is the field name and the proc is the getter
+          elsif field.is_a?(Array) && field.map(&:class) == [Symbol, Proc]
+            tag = field[0]
+            content = field[1].call(object)
+
+          # otherwise we have garbage
+          else
+           raise "ModelXML unable to parse #{field.inspect}"
+          end
+
+          # if the content implements a to_xml method which returns a non-nil value, insert as raw xml
+          if content.respond_to?(:to_xml) && inline_content = content.to_xml(:skip_instruct => true, :skip_types => true)
+            xml << inline_content
+
+          # otherwise create the tag normally
+          else
+            xml.tag! tag, content
+          end
+        end
+      end
+
+      # builder will screw up the indentation of embedded xml objects, so use nokogiri to format it nicely
+      output = xml.target!.gsub("\n","").gsub("  ","")
+      Nokogiri.parse(output).to_s
+
+    end
+  end
+end

data/lib/model_xml.rb

@@ -0,0 +1,45 @@
+$:.unshift File.dirname __FILE__
+require 'model_xml/generator'
+
+module ModelXML
+
+  def self.included base
+
+    base.instance_eval do
+
+      def model_xml *args, &block
+
+        @model_xml_generator ||= ModelXML::Generator.new
+        if block_given?
+          @model_xml_generator.add_field_set(*args, &block)
+        else
+          @model_xml_generator.add_field_set *args
+        end
+
+      end
+
+      # this is probably only ever required for testing
+      def model_xml_reset!
+        @model_xml_generator = ModelXML::Generator.new
+      end
+
+      def model_xml_generator
+        @model_xml_generator
+      end
+    end
+
+  end
+
+  def to_xml options={}
+
+    # if no generator is defined, pass straight through to the parent to_xml method, which may or may not exist
+    if generator = self.class.model_xml_generator
+      generator.generate_xml! self, options
+    else
+      super options
+    end
+  end
+
+end
+
+ActiveRecord::Base.send :include, ModelXML if defined?(ActiveRecord::Base)

data/test/test_block_parser.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+$:.unshift File.dirname(__FILE__) + "/../lib/"
+require 'model_xml/block_parser'
+
+class BlockParserTest < Test::Unit::TestCase
+
+  def test_simple_parse
+    block = Proc.new do
+      foo
+      bar 3, 4
+    end
+    assert_equal [:foo, [:bar, 3, 4]], ModelXML::BlockParser.parse(&block)
+  end
+
+end
+

data/test/test_model_xml.rb

@@ -0,0 +1,87 @@
+require 'test/unit'
+require 'ostruct'
+$:.unshift File.dirname(__FILE__) + "/../lib/"
+require 'model_xml'
+
+class TestStruct < OpenStruct
+  include ModelXML
+end
+
+class ModelXMLTest < Test::Unit::TestCase
+
+  def setup
+    @t = TestStruct.new :foo => 1, :bar => 2
+  end
+
+  def test_class_simple
+    TestStruct.instance_eval do
+      model_xml_reset!
+      model_xml :foo
+    end
+
+    assert_equal [[:foo]], TestStruct.model_xml_generator.field_sets
+
+    res = '<?xml version="1.0" encoding="UTF-8"?>
+<teststruct>
+  <foo>1</foo>
+</teststruct>
+'
+    assert_equal res, @t.to_xml
+  end
+
+  def test_block_notation
+    TestStruct.instance_eval do
+      model_xml_reset!
+      model_xml do
+        foo
+        bar
+      end
+    end
+
+    assert_equal [[:foo, :bar]], TestStruct.model_xml_generator.field_sets
+
+    res = '<?xml version="1.0" encoding="UTF-8"?>
+<teststruct>
+  <foo>1</foo>
+  <bar>2</bar>
+</teststruct>
+'
+    assert_equal res, @t.to_xml
+  end
+
+  def test_inline_procs
+    TestStruct.instance_eval do
+      model_xml_reset!
+      model_xml do
+        foo
+        bar
+        foobar Proc.new {|obj| obj.foo + obj.bar}
+      end
+    end
+
+    res = '<?xml version="1.0" encoding="UTF-8"?>
+<teststruct>
+  <foo>1</foo>
+  <bar>2</bar>
+  <foobar>3</foobar>
+</teststruct>
+'
+    assert_equal res, @t.to_xml
+  end
+
+  def test_skip_instruct
+    TestStruct.instance_eval do
+      model_xml_reset!
+      model_xml :foo, :bar
+    end
+
+    res = '<?xml version="1.0"?>
+<teststruct>
+  <foo>1</foo>
+  <bar>2</bar>
+</teststruct>
+'
+    assert_equal res, @t.to_xml(:skip_instruct => true)
+
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: model_xml
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Rob Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-10 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 1
+        - 2
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 4
+        - 2
+        version: 1.4.2
+  type: :runtime
+  version_requirements: *id002
+description: Simple replacement for ActiveRecord's default to_xml
+email: rob.anderson@paymentcardsolutions.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- README.md
+- lib/model_xml.rb
+- lib/model_xml/block_parser.rb
+- lib/model_xml/generator.rb
+- test/test_block_parser.rb
+- test/test_model_xml.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: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: Ruby object to xml converter
+test_files: []
+