pump 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9047d695a9bb5dbbec84d04fc9a77bebb43c35f8
-  data.tar.gz: eeed27e8e5f98a30fa22271af1e6182cc3178bcd
+  metadata.gz: c4b95096c96dfa59274e8b007a7946f0223e507c
+  data.tar.gz: 12e6c47f2239231db115c160575870739141ef95
 SHA512:
-  metadata.gz: 6c696f69ee33b842a90e2bd2790a802415497a29aed0d274331bdefc7d54bc5c975b9e6cb6cfd53e161f95a37447777ceefb51c58b1a65df83e64829e755e0ab
-  data.tar.gz: f020baf37e32686173e0334193fbd555c93966a3b8924f3ecaa0dd0127a3dbc8c484dba40217ba11a7d682b6bdb4cd27a238bff04cd460dab16708e18443223c
+  metadata.gz: 9725fb7b0bb3152bae3321623744f15e280bfc4edae242836702b3971bd69039007f7c54bc8b1e7a49f49b0d440f7d66db989642b64ad2b8e09858ff1d32e210
+  data.tar.gz: 360c20c887a7c50232df40b77805e86a26d8a8c399695fba4e360121eb721841768918f4738ac6fe957b75bac8d0c161b19eebdee27ebdd95707d45d7ccb758b

data/CHANGES.md

@@ -1,3 +1,10 @@
 ### dev
 
-[full changelog](http://github.com/yolk/pump/compare/v0.0.1...master)
+[full changelog](http://github.com/yolk/pump/compare/v0.0.1...master)
+
+### 0.6.0 / 2013-07-24
+
+[full changelog](http://github.com/yolk/valvat/compare/v0.5.1...v0.6.0)
+
+* Added JSON serialization
+* Added simple inheritance for encoders

data/README.md

@@ -1,6 +1,6 @@
 # Pump
 
-Fast but inflexible XML encoding for ruby objects.
+Fast but inflexible XML and JSON encoding for ruby objects.
 
 ## Quick benchmark
 

data/benchmarks/encode.rb

@@ -4,17 +4,26 @@ require 'rubygems'
 require 'benchmark'
 
 require 'pump'
-require 'ox' rescue nil
-require 'active_model' rescue nil
+require 'ox'
+require 'oj'
+require 'yajl'
+require 'active_model'
 
 class Person < Struct.new(:name, :age, :created_at)
   include ActiveModel::Serializers::Xml if defined?(ActiveModel)
+  include ActiveModel::Serializers::JSON if defined?(ActiveModel)
 
   def attributes
     {'name' => name, 'age' => age, 'created_at' => created_at}
   end
 end
 
+pump_json = Pump::Json.new('person', [
+  {:age => :age, :attributes => {:type => 'integer'}},
+  {:"created-at" => :created_at, :typecast => :xmlschema, :attributes => {:type => 'datetime'}, :never_nil => true},
+  {:name => :name}
+])
+
 # Not optimized pump
 pump = Pump::Xml.new('person', [
   {:age => :age, :attributes => {:type => 'integer'}},
@@ -77,6 +86,12 @@ puts "Starting benchmark serializing array with #{array.size} entries #{times} t
 
 Benchmark.bmbm { |x|
 
+  x.report("Pump::Json#encode") {
+    times.times {
+      pump_json.encode(array)
+    }
+  }
+
   x.report("Pump::Xml#encode") {
     times.times {
       pump.encode(array)
@@ -97,11 +112,33 @@ Benchmark.bmbm { |x|
     }
   end
 
+  if defined?(Oj)
+    x.report("Oj") {
+      times.times {
+        Oj.dump(array.map(&:attributes), :mode => :compat)
+      }
+    }
+  end
+
+  if defined?(Yajl)
+    x.report("Yajl") {
+      times.times {
+        Yajl::Encoder.encode(array.map(&:attributes))
+      }
+    }
+  end
+
   if defined?(ActiveModel)
-    x.report("ActiveModel#serialize") {
+    x.report("ActiveModel#to_xml") {
       times.times {
         array.to_xml
       }
     }
+
+    x.report("ActiveModel#to_json") {
+      times.times {
+        array.to_json
+      }
+    }
   end
 }

data/gemfiles/activesupport-3-2

@@ -1,6 +1,7 @@
 source "http://rubygems.org"
 
 gem "activemodel", "3.2.13"
+gem "oj"
 
 gem 'rspec', '>= 2.4.0'
 gem 'rake'

data/gemfiles/activesupport-4

@@ -1,6 +1,7 @@
 source "http://rubygems.org"
 
 gem "activemodel", "4.0"
+gem "oj"
 
 gem 'rspec', '>= 2.4.0'
 gem 'rake'

data/lib/pump.rb

@@ -1,5 +1,6 @@
 require "pump/version"
 require "pump/xml"
+require "pump/json"
 require "pump/object"
 require "pump/array"
 

data/lib/pump/array.rb

@@ -3,7 +3,13 @@ module Pump
     def pump_to_xml(options={})
       encoder = get_pump_encoder(options[:set], :xml)
       return to_xml(options) unless encoder
-      encoder.encode(self)
+      encoder.encode(self, options)
+    end
+
+    def pump_to_json(options={})
+      encoder = get_pump_encoder(options[:set], :json)
+      return to_json(options) unless encoder
+      encoder.encode(self, options)
     end
 
     private

data/lib/pump/dsl.rb

@@ -0,0 +1,57 @@
+module Pump
+  class Dsl
+    def initialize(&blk)
+      raise ArgumentError unless block_given?
+      instance_eval(&blk)
+    end
+
+    def config
+      @config ||= []
+    end
+
+    private
+
+    def tag(name, options={}, &blk)
+      method = if block_given?
+        self.class.new(&blk).config
+      else
+        options.delete(:from) || (name.to_s =~ /-/ ? name.to_s.gsub('-', '_').to_sym : name)
+      end
+      config << ({ name => method }).merge(options)
+    end
+    alias_method :string, :tag
+
+    def integer(name, options={})
+      with_type('integer', name, options)
+    end
+
+    def float(name, options={})
+      with_type('float', name, options)
+    end
+
+    def boolean(name, options={})
+      with_type('boolean', name, options)
+    end
+
+    def date(name, options={})
+      with_type('date', name, options)
+    end
+
+    def datetime(name, options={})
+      options[:typecast] = :xmlschema unless options.has_key?(:typecast)
+      with_type('datetime', name, options)
+    end
+    alias_method :time, :datetime
+
+    def with_type(type, name, options)
+      (options[:attributes] ||= {}).merge!({:type => type})
+      options[:xmlsafe] = true unless options.has_key?(:xmlsafe)
+      tag(name, options)
+    end
+
+    def array(name, options={}, &blk)
+      options[:array] = self.class.new(&blk).config
+      tag(name, options)
+    end
+  end
+end

data/lib/pump/encoder.rb

@@ -0,0 +1,92 @@
+require "pump/dsl"
+
+module Pump
+  class Encoder
+    attr_reader :root_name, :encoder_config, :encoder_options, :base
+
+    # Creates a new XML-encoder with a root tag named after +root_name+.
+    #
+    # @example Create a simple encoder for a person with a name attribute:
+    #   Pump::Xml.new :person do
+    #     tag :name
+    #   end
+    #
+    # @example Create the same without usage of the DSL:
+    #   Pump::Xml.new :person, [{:name => :name}]
+    #
+    # @example Create the same but without the xml instruct
+    #   Pump::Xml.new :person, :instruct => false do
+    #     tag :name
+    #   end
+    #
+    # @example The same again without DSL:
+    #
+    #   Pump::Xml.new :person, [{:name => :name}], :instruct => false
+    #
+    # @param [String, Symbol] root_name         the name of the used root tag
+    # @param [Array<Hash>] encoder_config       optional config for all tags
+    # @param [Hash] encoder_options             optional encoder_options for the whole encoder
+    # @yield an optional block to create the encoder with the Pump::Dsl
+    #
+    # @return [self]
+    def initialize(root_name, encoder_config=nil, encoder_options={}, &blk)
+      if encoder_config.is_a?(Array)
+        @encoder_config  = encoder_config
+        @encoder_options = encoder_options || {}
+      else
+        raise ArgumentError unless block_given?
+        @encoder_options = encoder_config || {}
+        @encoder_config = Pump::Dsl.new(&blk).config
+      end
+      @root_name = root_name
+      merge_base
+
+      compile
+    end
+
+    # Encode a object or an array of objects to an XML-string.
+    #
+    # @param [Object, Array<Object>] object object or an array of objects to
+    #    encode to XML. The only requirement: The given objects must respond
+    #    to all methods configured during initalization of the Pump::Xml instance.
+    #
+    # @return [String]
+    def encode(object, options={})
+      object.is_a?(Array) ? encode_array(object, options) : encode_single(object, options)
+    end
+
+    private
+
+    def compile
+      compile_string && instance_eval(compile_string)
+    end
+
+    def compile_string;end
+
+    def merge_base
+      return unless @encoder_options[:base]
+      @base = @encoder_options.delete(:base)
+
+      merge_base_config
+      merge_base_options
+    end
+
+    def merge_base_config
+      original_encoder_config = @encoder_config
+      @encoder_config = base.encoder_config.dup
+      original_encoder_config.each do |it|
+        key = it.keys.first
+        index = @encoder_config.index{|config| config.keys.first == key}
+        if index
+          @encoder_config[index] = it
+        else
+          @encoder_config.push(it)
+        end
+      end
+    end
+
+    def merge_base_options
+      encoder_options.merge!(base.encoder_options) { |key, v1, v2| v1 }
+    end
+  end
+end

data/lib/pump/json.rb

@@ -0,0 +1,97 @@
+require "pump/encoder"
+require "oj"
+
+module Pump
+  class Json < Encoder
+
+    private
+
+    def compile_string
+      <<-EOV
+        def encode_single(object, options)
+          json = {}
+          #{build_string(encoder_config)}
+          unless options[:exclude_root_in_json]
+            json = { :'#{format_name(root_name)}' => json }
+          end
+          Oj.dump(json, :mode => :compat)
+        end
+
+        def encode_array(objects, options)
+          Oj.dump(if options[:exclude_root_in_json]
+            objects.map do |object|
+              json = {}
+              #{build_string(encoder_config)}
+              json
+            end
+          else
+            objects.map do |object|
+              json = {}
+              #{build_string(encoder_config)}
+              { :'#{format_name(root_name)}' => json }
+            end
+          end, :mode => :compat)
+        end
+      EOV
+    end
+
+    def build_string(config, variable='json')
+      config.inject("") do |str, config|
+        build_key_value_pair(str, config, variable)
+        str
+      end
+    end
+
+    def build_key_value_pair(str, config, variable='json')
+      name, method_name = config.keys.first, config.values.first
+      if method_name.is_a?(Array) && !config.has_key?(:static_value)
+        build_hash(str, name, method_name, config, variable)
+      elsif config[:array]
+        build_array(str, name, method_name, config, variable)
+      else
+        build_simple(str, name, method_name, config, variable)
+      end
+    end
+
+    def build_hash(str, name, method_name, config, variable)
+      str << "#{build_condition(config)}\n"
+      str << "#{variable}[:'#{format_name(name)}'] = {}\n"
+      str << build_string(method_name, "#{variable}[:'#{format_name(name)}']")
+      str << "end\n" if build_condition(config)
+    end
+
+    def build_array(str, name, method_name, config, variable)
+      str << "#{build_condition(config)}\n"
+      str << "#{variable}[:'#{format_name(name)}'] = []\n"
+      unless config.has_key?(:static_value)
+        str << "object.#{method_name}.each do |object| "
+        str << "#{variable}[:'#{format_name(name)}'] << {}\n"
+        str << build_string(config[:array], "#{variable}[:'#{format_name(name)}'][-1]")
+        str << "end\n"
+      end
+      str << "end\n" if build_condition(config)
+    end
+
+    def build_simple(str, name, method_name, config, variable)
+      str << "#{variable}[:'#{format_name(name)}']=#{build_value(method_name, config)}#{build_condition(config)}\n"
+    end
+
+    def build_value(method_name, config)
+      return config[:static_value].inspect if config.has_key?(:static_value)
+      "object.#{method_name}"
+    end
+
+    def build_condition(config)
+      if config[:if]
+        " if object.#{config[:if]}"
+      elsif config[:unless]
+        " unless object.#{config[:unless]}"
+      end
+    end
+
+    def format_name(name)
+      return name if encoder_options[:underscore] == false
+      name.to_s.underscore
+    end
+  end
+end

data/lib/pump/object.rb

@@ -9,9 +9,18 @@ module Pump
     def pump_to_xml(options={})
       encoder = self.class.pumps.get(options[:set], :xml)
       if encoder
-        encoder.encode(self)
+        encoder.encode(self, options)
       else
-        self.to_xml(options)
+        to_xml(options)
+      end
+    end
+
+    def pump_to_json(options={})
+      encoder = self.class.pumps.get(options[:set], :json)
+      if encoder
+        encoder.encode(self, options)
+      else
+        to_json(options)
       end
     end
 
@@ -21,7 +30,14 @@ module Pump
       end
 
       def add_pump(name, set=nil, options={}, &block)
-        pumps.add(set, :xml, Pump::Xml.new(name, options, &block))
+        if options[:base]
+          xml_options = options.dup.merge({:base => pumps.get(options[:base], :xml)})
+          json_options = options.dup.merge({:base => pumps.get(options[:base], :json)})
+        else
+          xml_options, json_options = options, options
+        end
+        pumps.add(set, :xml, Pump::Xml.new(name, xml_options, &block))
+        pumps.add(set, :json, Pump::Json.new(name, json_options, &block))
       end
     end
   end

data/lib/pump/version.rb

@@ -1,3 +1,3 @@
 module Pump
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end