pump 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c60ca511d26b937009e1b16e1473b4e664509ab9
-  data.tar.gz: 0f6c9cf439f290237b710c56ed25d87b79ccca5b
+  metadata.gz: b23d242fff172d8de112af6c2fc6f326e101bd14
+  data.tar.gz: 4e369b0d6f692526571a487c1e692199b21d1efb
 SHA512:
-  metadata.gz: cf21d8aa68ff75a6bb584390bdc16880a48c600057834dcb2aac8457c76268a20e294c8900056854a3019f13065f2eccd8e19ac5e70cac17d4f4b3700914a941
-  data.tar.gz: d1441b8fb1321f5452a25d98568ac35bc9e0a5d0b72866eae2bc795b2bdccb3570def280d700e84c203d5d72f05c081dd28a519014f4475c8d093e2b956b6f84
+  metadata.gz: 3593cfcda6c0a33bd2f1cdf0d7010fb6f1b627a11a33c675fa2ab0854771e8b3cd109137d26bb8cf557e41ea21345b4c2b018f0b6a0b3105fa73bfc1c16917e3
+  data.tar.gz: 6c366d3a85852a28c5bb536bd2daed8eaf23f1e2d14972e73fd3c951c00d0dd8dd1895450b65a21d6ab33d1d2ad13529fa0ebc5e949616c7e42969f4019d3c24

data/CHANGES.md

@@ -1,6 +1,13 @@
 ### dev
 
-[full changelog](http://github.com/yolk/pump/compare/v0.6.2...master)
+[full changelog](http://github.com/yolk/pump/compare/v0.6.3...master)
+
+### 0.6.3 / 2013-07-26
+
+[full changelog](http://github.com/yolk/valvat/compare/v0.6.2...v0.6.3)
+
+* Pump::Xml allow partial output with :fields option
+* Pump::JSON allow partial output with :fields option
 
 ### 0.6.2 / 2013-07-26
 

data/lib/pump/encoder.rb

@@ -41,6 +41,7 @@ module Pump
       @root_name = root_name
       merge_base
 
+      compile_field_map
       compile
     end
 
@@ -53,7 +54,14 @@ module Pump
     # @return [String]
     def encode(object, options={})
       object = object.to_a if defined?(ActiveRecord::Relation) && object.is_a?(ActiveRecord::Relation)
-      object.is_a?(Array) ? encode_array(object, options) : encode_single(object, options)
+      fields_to_hash(options)
+      if object.is_a?(Array)
+        encode_array(object, options)
+      elsif options[:fields]
+        encode_partial_single(object, options)
+      else
+        encode_single(object, options)
+      end
     end
 
     private
@@ -64,6 +72,21 @@ module Pump
 
     def compile_string;end
 
+    def compile_field_map
+      instance_eval("@fields_map = { #{compile_string_fields_map} }")
+    end
+
+    def compile_string_fields_map
+      encoder_config.map do |config|
+        config.keys.first
+      end.inject([]) do |array, name|
+        underscores = name.to_s.underscore
+        dashes = name.to_s.dasherize
+        array << "'#{dashes}' => true" if dashes != underscores
+        array << "'#{underscores}' => true"
+      end.join(',')
+    end
+
     def merge_base
       return unless @encoder_options[:base]
       @base = @encoder_options.delete(:base)
@@ -89,5 +112,13 @@ module Pump
     def merge_base_options
       encoder_options.merge!(base.encoder_options) { |key, v1, v2| v1 }
     end
+
+    def fields_to_hash(options)
+      return unless options[:fields]
+      options[:fields] = options[:fields].inject({}) do |hash, name|
+        hash[name.to_s.underscore.to_sym] = true if @fields_map[name.to_s]
+        hash
+      end
+    end
   end
 end

data/lib/pump/json.rb

@@ -8,13 +8,15 @@ module Pump
     private
 
     OJ_OPTIONS = {
-      :mode => :compat, 
-      :time_format => :xmlschema, 
+      :mode => :compat,
+      :time_format => :xmlschema,
       :second_precision => 0
     }
 
     def compile_string
       main = build_main
+      partial_main = build_main(:partial => true)
+
       <<-EOV
         def encode_single(object, options)
           #{main}
@@ -24,6 +26,14 @@ module Pump
           Oj.dump(json, OJ_OPTIONS)
         end
 
+        def encode_partial_single(object, options)
+          #{partial_main}
+          unless options[:exclude_root_in_json]
+            json = { :'#{format_name(root_name)}' => json }
+          end
+          Oj.dump(json, OJ_OPTIONS)
+        end
+
         def encode_array(objects, options)
           Oj.dump(if options[:exclude_root_in_json]
             objects.map do |object|
@@ -40,52 +50,54 @@ module Pump
       EOV
     end
 
-    def build_main
+    def build_main(options={})
       <<-EOV
+        field_hash = options[:fields]
         json = {}
-        #{build_part(encoder_config)}
+        #{build_part(encoder_config, 'json', options)}
       EOV
     end
 
-    def build_part(config, variable='json')
+    def build_part(config, variable, options, path=[])
       config.inject("") do |str, config|
-        build_key_value_pair(str, config, variable)
+        build_key_value_pair(str, config, variable, options, path)
         str
       end
     end
 
-    def build_key_value_pair(str, config, variable='json')
+    def build_key_value_pair(str, config, variable, options, path)
       name, method_name = config.keys.first, config.values.first
+      condition = build_condition(name, config, options, path)
       if method_name.is_a?(Array) && !config.has_key?(:static_value)
-        build_hash(str, name, method_name, config, variable)
+        build_hash(str, name, method_name, config, variable, options, path, condition)
       elsif config[:array]
-        build_array(str, name, method_name, config, variable)
+        build_array(str, name, method_name, config, variable, options, path, condition)
       else
-        build_simple(str, name, method_name, config, variable)
+        build_simple(str, name, method_name, config, variable, options, path, condition)
       end
     end
 
-    def build_hash(str, name, method_name, config, variable)
-      str << "#{build_condition(config)}\n"
+    def build_hash(str, name, method_name, config, variable, options, path, condition)
+      str << "#{condition}\n" if condition
       str << "#{variable}[:'#{format_name(name)}'] = {}\n"
-      str << build_part(method_name, "#{variable}[:'#{format_name(name)}']")
-      str << "end\n" if build_condition(config)
+      str << build_part(method_name, "#{variable}[:'#{format_name(name)}']", options, path.dup << name)
+      str << "end\n" if condition
     end
 
-    def build_array(str, name, method_name, config, variable)
-      str << "#{build_condition(config)}\n"
+    def build_array(str, name, method_name, config, variable, options, path, condition)
+      str << "#{condition}\n" if condition
       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_part(config[:array], "#{variable}[:'#{format_name(name)}'][-1]")
+        str << build_part(config[:array], "#{variable}[:'#{format_name(name)}'][-1]", options, path.dup << name)
         str << "end\n"
       end
-      str << "end\n" if build_condition(config)
+      str << "end\n" if condition
     end
 
-    def build_simple(str, name, method_name, config, variable)
-      str << "#{variable}[:'#{format_name(name)}']=#{build_value(method_name, config)}#{build_condition(config)}\n"
+    def build_simple(str, name, method_name, config, variable, options, path, condition)
+      str << "#{variable}[:'#{format_name(name)}']=#{build_value(method_name, config)}#{condition}\n"
     end
 
     def build_value(method_name, config)
@@ -93,11 +105,24 @@ module Pump
       "object.#{method_name}"
     end
 
-    def build_condition(config)
+    def build_condition(name, config, options, path)
+      conditions = []
+      conditions << build_partial_condition(name, path) if options[:partial]
+
       if config[:if]
-        " if object.#{config[:if]}"
+        conditions << "object.#{config[:if]}"
       elsif config[:unless]
-        " unless object.#{config[:unless]}"
+        conditions << "!object.#{config[:unless]}"
+      end
+
+      conditions.any? ? " if #{conditions.join(" && ")} " : nil
+    end
+
+    def build_partial_condition(name, path)
+      if path.any?
+        "field_hash[:'#{path.join('.')}']"
+      else
+        "field_hash[:#{name.to_s.underscore}]"
       end
     end
 

data/lib/pump/version.rb

@@ -1,3 +1,3 @@
 module Pump
-  VERSION = "0.6.2"
+  VERSION = "0.6.3"
 end

data/lib/pump/xml.rb

@@ -15,25 +15,30 @@ module Pump
         def encode_array(objects, options)
           "#{TagArray.new(root_name, {}, sub_tags, tag_options)}"
         end
+
+        def encode_partial_single(object, options)
+          field_hash = options[:fields]
+          "#{Tag.new(root_name, {}, sub_tags(true), tag_options)}"
+        end
       EOV
     end
 
-    def sub_tags
+    def sub_tags(partial=false)
       encoder_config.map do |config|
-        build_tag(config)
+        build_tag(config, partial)
       end
     end
 
-    def build_tag(config)
+    def build_tag(config, partial, path=[])
       tag_name, method_name = config.keys.first, config.values.first
       attrs = config[:attributes]
-      options = config.merge({:xml_key_style => encoder_options[:xml_key_style]})
+      options = config.merge({:xml_key_style => encoder_options[:xml_key_style], :partial => partial, :path => path})
       if method_name.is_a?(Array)
-        Tag.new(tag_name, attrs, method_name.map{|conf| build_tag(conf) }, options)
+        Tag.new(tag_name, attrs, method_name.map{|conf| build_tag(conf, partial, path.dup << tag_name) }, options)
       elsif config[:array]
         options.merge!(:array_method => method_name, :array_root => tag_name)
         child_root = config[:child_root] || tag_name.to_s.singularize
-        tags = config[:array].map{|conf| build_tag(conf) }
+        tags = config[:array].map{|conf| build_tag(conf, partial, path.dup << tag_name) }
         TagArray.new(child_root, attrs, tags, options)
       else
         Tag.new(tag_name, attrs, Value.new(method_name), options)

data/lib/pump/xml/tag.rb

@@ -68,15 +68,27 @@ module Pump
       def condition_end
         return unless conditional?
 
+        conditions = []
+
+        if options[:partial]
+          conditions << if options[:path] && options[:path].any?
+            "field_hash[:'#{options[:path].join('.')}']"
+          else
+            "field_hash[:#{name.to_s.underscore}]"
+          end
+        end
+
         if options[:if]
-          "\" if object.#{options[:if]} }"
+          conditions << "object.#{options[:if]}"
         elsif options[:unless]
-          "\" unless object.#{options[:unless]} }"
+          conditions << "!object.#{options[:unless]}"
         end
+
+        "\" if #{conditions.join(" && ")} }" if conditions.any?
       end
 
       def conditional?
-        !!(options[:if] || options[:unless])
+        !!(options[:if] || options[:unless] || options[:partial])
       end
     end
   end

data/spec/pump/json_spec.rb

@@ -156,14 +156,14 @@ describe Pump::Json do
     end
 
     context "deep hash-like nesting" do
-      let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}]}], :instruct => false) }
+      let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}]}]) }
 
       it "returns static string" do
         json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":{\"name\":\"Benny\",\"age\":9}}}")
       end
 
       context "with static_value = nil" do
-        let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}], :static_value => nil}], :instruct => false) }
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}], :static_value => nil}]) }
 
         it "uses static value" do
           json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":null}}")
@@ -171,7 +171,7 @@ describe Pump::Json do
       end
 
       context "with static_value = {}" do
-        let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}], :static_value => {}}], :instruct => false) }
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}], :static_value => {}}]) }
 
         it "uses static value" do
           json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":{}}}")
@@ -187,7 +187,7 @@ describe Pump::Json do
       ]) }
 
       let(:json) { Pump::Json.new('person', [{:name => :name}, {:children => :children,
-                                            :array => [{:name => :name}]}], :instruct => false) }
+                                            :array => [{:name => :name}]}]) }
 
       it "returns json string" do
         json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[{\"name\":\"Lilly\"},{\"name\":\"Lena\"}]}}")
@@ -195,7 +195,7 @@ describe Pump::Json do
 
       context "with static_value = nil" do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:children => :children,
-                                            :array => [{:name => :name}], :static_value => nil}], :instruct => false) }
+                                            :array => [{:name => :name}], :static_value => nil}]) }
         it "uses static value" do
           json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[]}}")
         end
@@ -203,7 +203,7 @@ describe Pump::Json do
 
       context "with static_value = []" do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:children => :children,
-                                            :array => [{:name => :name}], :static_value => []}], :instruct => false) }
+                                            :array => [{:name => :name}], :static_value => []}]) }
         it "uses static value" do
           json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[]}}")
         end
@@ -240,6 +240,57 @@ describe Pump::Json do
       it "returns json string without root" do
         json.encode(person, :exclude_root_in_json => true).should eql("{\"name\":\"Benny\"}")
       end
+
+      it "returns json string without root on array" do
+        json.encode([person], :exclude_root_in_json => true).should eql("[{\"name\":\"Benny\"}]")
+      end
+    end
+
+    context "with :fields option" do
+      let(:json) { Pump::Json.new('person', [
+        {:name => :name}, {:age => :age}, {:last_name => :last_name},
+        {:parent => [{:name => :name}, {:age => :age}]}
+      ])}
+
+      it "returns only specified fields" do
+        json.encode(person, :fields => ['name']).should eql("{\"person\":{\"name\":\"Benny\"}}")
+        json.encode(person, :fields => ['age']).should eql("{\"person\":{\"age\":9}}")
+      end
+
+      it "ignores unknown fields" do
+        json.encode(person, :fields => ['name', 'unknown']).should eql("{\"person\":{\"name\":\"Benny\"}}")
+        json.encode(person, :fields => ['unknown']).should eql("{\"person\":{}}")
+      end
+
+      it "accepts dasherized and underscored field names" do
+        json.encode(person, :fields => ['name', 'last-name']).should eql("{\"person\":{\"name\":\"Benny\",\"last_name\":\"Hellman\"}}")
+        json.encode(person, :fields => ['name', 'last_name']).should eql("{\"person\":{\"name\":\"Benny\",\"last_name\":\"Hellman\"}}")
+      end
+
+      context "deep hash-like nesting" do
+        it "adds all keys if fields contains parent" do
+          json.encode(person, :fields => ['name', 'parent']).should eql(
+            "{\"person\":{\"name\":\"Benny\",\"parent\":{\"name\":\"Benny\",\"age\":9}}}"
+          )
+        end
+      end
+
+      context "deep array-like nesting" do
+        let(:person) {
+          Struct.new(:name, :age, :children).new('Gustav', 1, [
+            Struct.new(:name, :age).new('Lilly', 2),
+            Struct.new(:name, :age).new('Lena', 3)
+        ]) }
+
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age}, {:children => :children,
+                                              :array => [{:name => :name}, {:age => :age}]}]) }
+
+        it "adds all keys if fields contains children" do
+          json.encode(person, :fields => ['name', 'children']).should eql(
+            "{\"person\":{\"name\":\"Gustav\",\"children\":[{\"name\":\"Lilly\",\"age\":2},{\"name\":\"Lena\",\"age\":3}]}}"
+          )
+        end
+      end
     end
   end
 end

data/spec/pump/xml_spec.rb

@@ -332,5 +332,52 @@ describe Pump::Xml do
         end
       end
     end
+
+    context "with :fields option" do
+      let(:xml) { Pump::Xml.new('person', [
+        {:name => :name}, {:age => :age}, {:last_name => :last_name},
+        {:parent => [{:name => :name}, {:age => :age}]}
+      ])}
+
+      it "returns only specified fields" do
+        xml.encode(person, :fields => ['name']).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<person>\n  <name>Benny</name>\n</person>\n")
+        xml.encode(person, :fields => ['age']).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<person>\n  <age>9</age>\n</person>\n")
+      end
+
+      it "ignores unknown fields" do
+        xml.encode(person, :fields => ['name', 'unknown']).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<person>\n  <name>Benny</name>\n</person>\n")
+        xml.encode(person, :fields => ['unknown']).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<person>\n</person>\n")
+      end
+
+      it "accepts dasherized and underscored field names" do
+        xml.encode(person, :fields => ['name', 'last-name']).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<person>\n  <name>Benny</name>\n  <last-name>Hellman</last-name>\n</person>\n")
+        xml.encode(person, :fields => ['name', 'last_name']).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<person>\n  <name>Benny</name>\n  <last-name>Hellman</last-name>\n</person>\n")
+      end
+
+      context "deep hash-like nesting" do
+        it "adds all keys if fields contains parent" do
+          xml.encode(person, :fields => ['name', 'parent']).should eql(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<person>\n  <name>Benny</name>\n  <parent>\n    <name>Benny</name>\n    <age>9</age>\n  </parent>\n</person>\n"
+          )
+        end
+      end
+
+      context "deep array-like nesting" do
+        let(:person) {
+          Struct.new(:name, :age, :children).new('Gustav', 1, [
+            Struct.new(:name, :age).new('Lilly', 2),
+            Struct.new(:name, :age).new('Lena', 3)
+        ]) }
+
+        let(:xml) { Pump::Xml.new('person', [{:name => :name}, {:age => :age}, {:children => :children,
+                                              :array => [{:name => :name}, {:age => :age}]}]) }
+
+        it "adds all keys if fields contains children" do
+          xml.encode(person, :fields => ['name', 'children']).should eql(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<person>\n  <name>Gustav</name>\n  <children type=\"array\">\n    <child>\n      <name>Lilly</name>\n      <age>2</age>\n    </child>\n    <child>\n      <name>Lena</name>\n      <age>3</age>\n    </child>\n  </children>\n</person>\n"
+          )
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pump
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.3
 platform: ruby
 authors:
 - Sebastian Munz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-26 00:00:00.000000000 Z
+date: 2013-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport