pump 0.0.1 → 0.0.2

data/README.md

@@ -1,29 +1,13 @@
 # Pump
 
-TODO: Write a gem description
+Fast but inflexible XML encoding for ruby objects.
 
-## Installation
+## Quick benchmark
 
-Add this line to your application's Gemfile:
+Serializing an array of 100 random entries 1.000 times.
 
-    gem 'pump'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install pump
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+                                      user     system      total        real
+    Pump::Xml#encode                  1.560000   0.020000   1.580000 (  1.581375)
+    Pump::Xml#encode (optimized)      1.060000   0.010000   1.070000 (  1.067321)
+    Ox                                1.470000   0.000000   1.470000 (  1.467247)
+    ActiveModel#serialize            22.840000   0.040000  22.880000 ( 22.871247)

data/benchmarks/encode.rb

@@ -0,0 +1,107 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'benchmark'
+
+require 'pump'
+require 'ox' rescue nil
+require 'active_model' rescue nil
+
+class Person < Struct.new(:name, :age, :created_at)
+  include ActiveModel::Serializers::Xml if defined?(ActiveModel)
+
+  def attributes
+    {'name' => name, 'age' => age, 'created_at' => created_at}
+  end
+end
+
+# Not optimized pump
+pump = Pump::Xml.new('person', [
+  {:age => :age, :attributes => {:type => 'integer'}},
+  {:"created-at" => :created_at, :typecast => :xmlschema, :attributes => {:type => 'datetime'}, :never_blank => true},
+  {:name => :name}
+])
+
+# Heavily optimized pump
+pump_optimized = Pump::Xml.new('person', [
+  {:age => :age, :attributes => {:type => 'integer'}, :never_blank => true, :skip_encoding => true},
+  {:"created-at" => :created_at, :typecast => :xmlschema, :attributes => {:type => 'datetime'}, :never_blank => true, :skip_encoding => true},
+  {:name => :name, :never_blank => true}
+])
+
+if defined?(Ox)
+  def serialize_with_ox(people)
+    doc = Ox::Document.new(:version => '1.0', :encoding => 'UTF-8')
+    root = Ox::Element.new('people')
+    root[:type] = "array"
+    people.each{|person| serialize_single_with_ox(person, root) }
+    doc << root
+    Ox.dump(doc, :with_xml => true)
+  end
+
+  def serialize_single_with_ox(person, base_root=nil)
+    root = Ox::Element.new('person')
+
+    created_at = Ox::Element.new('created-at')
+    created_at[:type] = "datetime"
+    created_at << person.created_at.xmlschema
+    root << created_at
+
+    age = Ox::Element.new('age')
+    age[:type] = "integer"
+    age << person.age.inspect
+    root << age
+
+    name = Ox::Element.new('name')
+    name << person.name
+    root << name
+
+    unless base_root
+      doc = Ox::Document.new(:version => '1.0', :encoding => 'UTF-8')
+      doc << root
+      Ox.dump(doc, :with_xml => true)
+    else
+      base_root << root
+    end
+  end
+end
+
+# Lets generate some random persons
+array = []
+100.times do
+  array << Person.new((0...(rand(15)+5)).map{ ('a'..'z').to_a[rand(26)] }.join, rand(100), Time.now + rand(1000000))
+end
+
+times = ARGV[1] ? ARGV[1].to_i : 1000
+puts "Starting benchmark serializing array with #{array.size} entries #{times} times\n\n"
+
+Benchmark.bmbm { |x|
+
+  x.report("Pump::Xml#encode") {
+    times.times {
+      pump.encode(array)
+    }
+  }
+
+  x.report("Pump::Xml#encode (optimized)") {
+    times.times {
+      pump_optimized.encode(array)
+    }
+  }
+
+  if defined?(Ox)
+    x.report("Ox") {
+      times.times {
+        serialize_with_ox(array)
+      }
+    }
+  end
+
+  if defined?(ActiveModel)
+    x.report("ActiveModel#serialize") {
+      times.times {
+        array.to_xml
+      }
+    }
+  end
+}

data/lib/pump/version.rb

@@ -1,3 +1,3 @@
 module Pump
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/pump/xml/node.rb

@@ -7,7 +7,7 @@ module Pump
       def initialize(name, attributes={}, nodes=[], options={})
         @name       = name
         @attributes = attributes || {}
-        @options    = options || {}
+        @options    = (options || {}).dup
         @nodes      = []
         Array(nodes).each{|node| add_node(node) }
       end
@@ -19,6 +19,7 @@ module Pump
 
       def add_node(node)
         node.level = level + 1
+        node.options[:extra_indent] = options[:extra_indent]
         nodes << node
       end
 
@@ -26,8 +27,12 @@ module Pump
         @level || options[:level] || 0
       end
 
-      def indent
-        (level)*(options[:indent] || 2)
+      def tabs
+        " " * ((level + extra_indent) * 2)
+      end
+
+      def extra_indent
+        options[:extra_indent] || 0
       end
     end
   end

data/lib/pump/xml/tag.rb

@@ -7,9 +7,7 @@ module Pump
 
       def initialize(*args)
         super
-        if value_nodes?
-          nodes.first.options = options
-        end
+        nodes.first.options = options if value_nodes?
       end
 
       def to_s
@@ -32,15 +30,15 @@ module Pump
 
       def prefix
         if level == 0
-          options[:instruct] ? INSTRUCT : ""
+          options[:instruct] ? INSTRUCT : (tabs)
         else
-          "\n#{" "*indent}"
+          "\n#{tabs}"
         end
       end
 
       def value_and_close_tag(path=nil)
         value = value_nodes? ? nodes.first.to_s(path) : (nodes.map(&:to_s).join << "\n")
-        ">#{value}</#{name}>"
+        ">#{value}#{tabs unless value_nodes?}</#{name}>"
       end
 
       def value_and_close_tag_with_blank_check

data/lib/pump/xml/tag_array.rb

@@ -0,0 +1,32 @@
+require 'pump/xml/node'
+require 'active_support/core_ext/string/inflections'
+
+module Pump
+  class Xml
+    class TagArray < Node
+      def initialize(name, attributes={}, nodes=[], options={})
+        tag = Tag.new(name, attributes, nodes, {:level => 1, :extra_indent => options[:extra_indent]})
+        array_root = options[:array_root] || name.pluralize
+        super(array_root, {}, [tag], options)
+      end
+
+      def to_s
+        "#{prefix}<#{name} type=\\\"array\\\"#{loop_and_close_tag}"
+      end
+
+      private
+
+      def prefix
+        options[:instruct] ? "#{Tag::INSTRUCT}" : tabs
+      end
+
+      def loop_and_close_tag
+        "\#{ objects.empty? ? \" />\" : \">#{tag_loop}#{tabs}</#{name}>\" }"
+      end
+
+      def tag_loop
+        "\#{objects.map{|object| \"#{nodes.first}\" }.join('')}\n"
+      end
+    end
+  end
+end

data/lib/pump/xml/value.rb

@@ -10,7 +10,17 @@ module Pump
       end
 
       def to_s(plain_path=nil)
-        "\#{#{plain_path || plain}#{'.to_s.encode(:xml => :text)' unless options[:skip_encoding]}}"
+        "\#{#{plain_path || plain}#{cast}}"
+      end
+
+      private
+
+      def cast
+        if options[:typecast]
+          ".#{options[:typecast]}"
+        elsif !options[:skip_encoding]
+          '.to_s.encode(:xml => :text)'
+        end
       end
     end
   end

data/lib/pump/xml.rb

@@ -1,38 +1,54 @@
 require "pump/xml/tag"
 require "pump/xml/value"
+require "pump/xml/tag_array"
 
 module Pump
   class Xml
-    def initialize(root_name, tags)
-      @root_name = root_name
-      @tags = tags
-      build
+    attr_reader :root_tag_name, :tag_config, :options
+
+    def initialize(root_tag_name, tag_config, options={})
+      @root_tag_name = root_tag_name
+      @tag_config    = tag_config
+      @options       = options
+
+      compile
     end
 
-    def serialize(object)
-      # "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<#{@root_name}>\n  <name>#{record.name}</name>\n</#{@root_name}>"
+    def encode(object)
+      Array === object ? encode_array(object) : encode_single(object)
     end
 
     private
 
-    def build
-      self.instance_eval build_string
+    def compile
+      instance_eval(compile_string)
     end
 
-    def build_string
-      root_node = Tag.new(@root_name, {}, tags, {:instruct => true})
+    def compile_string
       <<-EOV
-        def serialize(object)
-          "#{root_node}"
+        def encode_single(object)
+          "#{Tag.new(root_tag_name, {}, sub_tags, tag_options)}"
+        end
+
+        def encode_array(objects)
+          "#{TagArray.new(root_tag_name, {}, sub_tags, tag_options)}"
         end
       EOV
     end
 
-    def tags
-      @tags.map do |options|
-        tag_name, method_name = options.keys.first, options.values.first
-        Tag.new(tag_name, options[:attributes], Value.new(method_name), options)
+    def sub_tags
+      tag_config.map do |config|
+        tag_name, method_name = config.keys.first, config.values.first
+        Tag.new(tag_name, config[:attributes], Value.new(method_name), config)
       end
     end
+
+    def tag_options
+      {:instruct => add_instruct?, :extra_indent => options[:extra_indent], :array_root => options[:array_root] }
+    end
+
+    def add_instruct?
+      options.has_key?(:instruct) ? options[:instruct] : true
+    end
   end
 end

data/pump.gemspec

@@ -8,15 +8,17 @@ Gem::Specification.new do |gem|
   gem.version       = Pump::VERSION
   gem.authors       = ["Sebastian Munz"]
   gem.email         = ["sebastian@yo.lk"]
-  gem.description   = %q{Fast but inflexible XML dumping for ruby objects.}
-  gem.summary       = %q{Fast but inflexible XML dumping for ruby objects.}
+  gem.description   = %q{Fast but inflexible XML encoding for ruby objects.}
+  gem.summary       = %q{Fast but inflexible XML encoding for ruby objects.}
   gem.homepage      = "https://github.com/yolk/pump"
+  gem.license       = 'MIT'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.add_dependency 'activesupport'
   gem.add_development_dependency 'rspec',       '>= 2.12.0'
   gem.add_development_dependency 'guard-rspec', '>=2.2.2'
 end

data/spec/pump/xml/tag_array_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Pump::Xml::TagArray do
+  describe ".new" do
+    it "requires one parameter" do
+      lambda{ Pump::Xml::TagArray.new }.should raise_error(ArgumentError)
+      lambda{ Pump::Xml::TagArray.new('tag') }.should_not raise_error
+    end
+  end
+end

data/spec/pump/xml_spec.rb

@@ -9,17 +9,87 @@ describe Pump::Xml do
     end
   end
 
-  describe "#serialize" do
-    let(:person) { Struct.new(:name, :age).new('Benny', 9) }
+  describe "#encode" do
+    let(:person) { Struct.new(:name, :age, :last_name).new('Benny', 9, 'Hellman') }
     let(:xml) { Pump::Xml.new('person', [{:name => :name}]) }
 
     it "requires one object" do
-      lambda{ xml.serialize }.should raise_error(ArgumentError)
-      lambda{ xml.serialize(person) }.should_not raise_error
+      lambda{ xml.encode }.should raise_error(ArgumentError)
+      lambda{ xml.encode(person) }.should_not raise_error
     end
 
     it "returns xml string" do
-      xml.serialize(person).should eql("#{XML_INSTRUCT}<person>\n  <name>Benny</name>\n</person>")
+      xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <name>Benny</name>\n</person>")
+    end
+
+    context "with array" do
+
+      context "with one entry" do
+        let(:people) { [person] }
+
+        it "returns xml string" do
+          xml.encode(people).should eql("#{XML_INSTRUCT}<people type=\"array\">\n  <person>\n    <name>Benny</name>\n  </person>\n</people>")
+        end
+      end
+
+      context "with multiple entries" do
+        let(:people) { [person, Struct.new(:name, :age).new('Carlo', 5)] }
+
+        it "returns xml string" do
+          xml.encode(people).should eql("#{XML_INSTRUCT}<people type=\"array\">\n  <person>\n    <name>Benny</name>\n  </person>\n  <person>\n    <name>Carlo</name>\n  </person>\n</people>")
+        end
+      end
+
+      context "with empty array" do
+        let(:people) { [] }
+
+        it "returns xml string" do
+          xml.encode(people).should eql("#{XML_INSTRUCT}<people type=\"array\" />")
+        end
+      end
+
+      context "with no instruct" do
+        let(:xml) { Pump::Xml.new('person', [{:name => :name}], :instruct => false) }
+        let(:people) { [] }
+
+        it "returns xml string" do
+          xml.encode(people).should eql("<people type=\"array\" />")
+        end
+      end
+
+      context "with extra_indent" do
+        let(:people) { [person] }
+        let(:xml) { Pump::Xml.new('person', [{:name => :name}], :instruct => false, :extra_indent => 1) }
+
+        it "returns xml string" do
+          xml.encode(people).should eql("  <people type=\"array\">\n    <person>\n      <name>Benny</name>\n    </person>\n  </people>")
+        end
+      end
+
+      context "with array_root" do
+        let(:people) { [person] }
+        let(:xml) { Pump::Xml.new('person', [{:name => :name}], :instruct => false, :array_root => "personas") }
+
+        it "returns xml string" do
+          xml.encode(people).should eql("<personas type=\"array\">\n  <person>\n    <name>Benny</name>\n  </person>\n</personas>")
+        end
+      end
+    end
+
+    context "with no instruct" do
+      let(:xml) { Pump::Xml.new('person', [{:name => :name}], :instruct => false) }
+
+      it "returns xml string" do
+        xml.encode(person).should eql("<person>\n  <name>Benny</name>\n</person>")
+      end
+    end
+
+    context "with extra_indent" do
+      let(:xml) { Pump::Xml.new('person', [{:name => :name}], :instruct => false, :extra_indent => 1) }
+
+      it "returns xml string" do
+        xml.encode(person).should eql("  <person>\n    <name>Benny</name>\n  </person>")
+      end
     end
 
     context "with attribute" do
@@ -31,16 +101,15 @@ describe Pump::Xml do
       end
 
       it do
-        xml.serialize(person).should eql("#{XML_INSTRUCT}<person>\n  <name>Benny</name>\n  <age type=\"integer\">9</age>\n</person>")
+        xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <name>Benny</name>\n  <age type=\"integer\">9</age>\n</person>")
       end
-
     end
 
     context "with blank name" do
       let(:person) { Struct.new(:name, :age).new('', 9) }
 
       it do
-        xml.serialize(person).should eql("#{XML_INSTRUCT}<person>\n  <name/>\n</person>")
+        xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <name/>\n</person>")
       end
     end
 
@@ -48,14 +117,56 @@ describe Pump::Xml do
       let(:person) { Struct.new(:name, :age).new(nil, 9) }
 
       it do
-        xml.serialize(person).should eql("#{XML_INSTRUCT}<person>\n  <name/>\n</person>")
+        xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <name/>\n</person>")
       end
 
       context "and with :nil_check => true" do
         let(:xml) { Pump::Xml.new('person', [{:name => :name, :nil_check => true}]) }
 
         it do
-          xml.serialize(person).should eql("#{XML_INSTRUCT}<person>\n  <name nil=\"true\"/>\n</person>")
+          xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <name nil=\"true\"/>\n</person>")
+        end
+      end
+    end
+
+    context "with multiple attrubutes" do
+      let(:xml) { Pump::Xml.new('person', [{:name => :name}, {:age => :age}]) }
+
+      it "returns xml string" do
+        xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <name>Benny</name>\n  <age>9</age>\n</person>")
+      end
+    end
+
+    context "with renamed attrubutes" do
+      let(:xml) { Pump::Xml.new('person', [{"last-name" => :last_name}]) }
+
+      it "returns xml string" do
+        xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <last-name>Hellman</last-name>\n</person>")
+      end
+    end
+
+    context "with date attribute" do
+      let(:person) { Struct.new(:at).new(Date.new(2013, 2, 7)) }
+      let(:xml) { Pump::Xml.new('person', [{:at => :at, :attributes => {:type => 'date'}}]) }
+
+      it "returns xml string" do
+        xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <at type=\"date\">2013-02-07</at>\n</person>")
+      end
+    end
+
+    context "with datetime attribute" do
+      let(:person) { Struct.new(:at).new(Time.new(2013, 2, 7, 0, 0, 0)) }
+      let(:xml) { Pump::Xml.new('person', [{:at => :at, :typecast => :xmlschema, :attributes => {:type => 'datetime'}}]) }
+
+      it "returns xml string" do
+        xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <at type=\"datetime\">2013-02-07T00:00:00+01:00</at>\n</person>")
+      end
+
+      context "but nil" do
+        let(:person) { Struct.new(:at).new(nil) }
+
+        it "returns xml string" do
+          xml.encode(person).should eql("#{XML_INSTRUCT}<person>\n  <at type=\"datetime\"/>\n</person>")
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pump
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-29 00:00:00.000000000 Z
+date: 2013-02-08 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -43,7 +59,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.2.2
-description: Fast but inflexible XML dumping for ruby objects.
+description: Fast but inflexible XML encoding for ruby objects.
 email:
 - sebastian@yo.lk
 executables: []
@@ -60,19 +76,23 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/encode.rb
 - lib/pump.rb
 - lib/pump/version.rb
 - lib/pump/xml.rb
 - lib/pump/xml/node.rb
 - lib/pump/xml/tag.rb
+- lib/pump/xml/tag_array.rb
 - lib/pump/xml/value.rb
 - pump.gemspec
+- spec/pump/xml/tag_array_spec.rb
 - spec/pump/xml/tag_spec.rb
 - spec/pump/xml/value_spec.rb
 - spec/pump/xml_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/yolk/pump
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -94,8 +114,9 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Fast but inflexible XML dumping for ruby objects.
+summary: Fast but inflexible XML encoding for ruby objects.
 test_files:
+- spec/pump/xml/tag_array_spec.rb
 - spec/pump/xml/tag_spec.rb
 - spec/pump/xml/value_spec.rb
 - spec/pump/xml_spec.rb