sax_stream 1.0.10 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9395f1b5e7aa07c6f15c8c8c469390d4a5ce513b
-  data.tar.gz: 6becdfc0f14741255c572618536a150239efb27b
+  metadata.gz: 82bb680bba7d2bcd8a63f9a4c2aa32df0bfe54b4
+  data.tar.gz: da983be14a8e7987696782d022e968977e8cb433
 SHA512:
-  metadata.gz: 56051cea3ad5495498b5f5b0d5454d67b37ad99d5b29d3e890b3b1ff33cc091c4b88ee7461ec39b1ddf5a75e36fcbc94e017f9aeb9b624562150eccba48a68b6
-  data.tar.gz: 86bfa74d30e96e52b8226a540e34d39946bf5b78a57124e34e94e1733bfa1568e1fcc85e1dad143d3c555fa56e2091f9974d4be954a74eef5df48881f8fb4ed0
+  metadata.gz: 2a05a4969707727138d3e6990c669219728f5a6602b88ac8710c766c6e92fa94f58bf049ba375011d769e58de8f059df14a9f6659235cfdcbba4513b61c56c68
+  data.tar.gz: e8bc73f976ccac10a0541eb8f7dbaccc2db2d2789e848a19bce8848ec5b5a13a9de00be8c71f988549f17a09515d69a0af371673407e73f66c6ec6a6c3d96c7b

data/lib/sax_stream/internal/element_stack.rb

@@ -19,6 +19,10 @@ module SaxStream
           end
         end
 
+        def relative_attributes
+          @attrs
+        end
+
         def content
           @content
         end
@@ -77,6 +81,10 @@ module SaxStream
         @elements.last.attributes(path)
       end
 
+      def relative_attributes
+        @elements.last.relative_attributes
+      end
+
       def record_characters(string)
         # indented_puts "  record: #{string.inspect}"
         if @elements.last

data/lib/sax_stream/internal/field_mappings.rb

@@ -0,0 +1,124 @@
+module SaxStream
+  module Internal
+    class FieldMappings
+      class MappingOptions
+        def initialize(element, key)
+          @element = element
+          @key = key
+          @attributes = parse_attributes(key) if key.is_a?(String)
+        end
+
+        def element
+          @element
+        end
+
+        def allows_mapping?(key, attributes)
+          compare_attributes(attributes)
+        end
+
+        def method_missing(name, *params)
+          @element.send(name, *params)
+        end
+
+        private
+
+        def parse_attributes(key)
+          matches = key.match(/\[(.*)\]/)
+          if matches
+            return hashify_attribute(matches[1])
+          end
+        end
+
+        def hashify_attribute(string)
+          parts = string.split('=')
+          {parts[0] => parts[1]}
+        end
+
+        def compare_attributes(attributes)
+          return true unless @attributes
+
+          attributes_hash = Hash[*attributes.flatten]
+
+          result = !@attributes.detect do |key, value|
+            inner_result = attributes_hash[key] != value
+            inner_result
+          end
+          result
+        end
+      end
+
+      def initialize
+        @mappings ||= CoreExtensions::OrderedHash.new
+      end
+
+      def store(key, mapping)
+        parsed_key = build_key_from_array(key)
+        new_value = MappingOptions.new(mapping, key)
+
+        if class_mappings[parsed_key]
+          unless class_mappings[parsed_key].is_a?(Array)
+            old_value = class_mappings[parsed_key]
+            class_mappings[parsed_key] = [old_value]
+          end
+          class_mappings[parsed_key] << new_value
+          puts "stored array for #{parsed_key}"
+        else
+          class_mappings[parsed_key] = new_value
+        end
+      end
+
+      def class_mappings
+        @mappings
+      end
+
+      def field_mapping(key, attributes = [])
+        result = find_non_regex_mapping(key) || regex_field_mapping(key)
+
+        unless result.is_a?(Array)
+          result = [result]
+        end
+        result.compact!
+
+        result.detect do |one_result|
+          one_result.element if one_result.allows_mapping?(key, attributes)
+        end
+      end
+
+      private
+
+      def find_non_regex_mapping(key)
+        class_mappings[key]
+      end
+
+      def regex_field_mapping(key)
+        regex_mappings.each do |regex, mapping|
+          return mapping if regex =~ key
+        end
+        nil
+      end
+
+      def regex_mappings
+        @regex_mappings ||= class_mappings.reject do |key, mapping|
+          !key.is_a?(Regexp)
+        end
+      end
+
+      def build_key_from_array(key_array)
+        if key_array.is_a?(Array)
+          joined_key = "(#{key_array.join('|')})".gsub('*', '[^/]+')
+          Regexp.new(joined_key)
+        else
+          build_key_regex(key_array)
+        end
+      end
+
+      def build_key_regex(key)
+        if key.include?('*')
+          Regexp.new(key.gsub('*', '[^/]+'))
+        else
+          key.sub(/\[.*\]/, '')
+        end
+      end
+    end
+  end
+end

data/lib/sax_stream/internal/mapper_handler.rb

@@ -76,7 +76,7 @@ module SaxStream
         end
 
         def start_child_node(name, attrs)
-          handler = @mapper_class.child_handler_for(prefix_with_element_stack(name), @collector, @stack, @current_object)
+          handler = @mapper_class.child_handler_for(prefix_with_element_stack(name), attrs, @collector, @stack, @current_object)
           if handler
             @stack.push(handler)
             handler.start_element(name, attrs)

data/lib/sax_stream/mapper.rb

@@ -1,6 +1,7 @@
 require 'sax_stream/internal/mapping_factory'
 require 'sax_stream/internal/xml_builder'
 require 'sax_stream/core_extensions/ordered_hash'
+require 'sax_stream/internal/field_mappings'
 
 module SaxStream
   # Include this module to make your class map an XML node. For usage examples, see the READEME.
@@ -78,23 +79,23 @@ module SaxStream
       end
 
       def map_element_stack_top_onto_object(object, element_stack)
-        map_key_onto_object(object, element_stack.path, element_stack.content)
+        map_key_onto_object(object, element_stack.path, element_stack.content, element_stack.relative_attributes)
         element_stack.attributes.each do |key, value|
           map_key_onto_object(object, key, value)
         end
       end
 
-      def map_key_onto_object(object, key, value)
+      def map_key_onto_object(object, key, value, attributes = [])
         if value
-          mapping = field_mapping(key)
+          mapping = field_mapping(key, attributes)
           if mapping
             mapping.map_value_onto_object(object, value)
           end
         end
       end
 
-      def child_handler_for(key, collector, handler_stack, current_object)
-        mapping = field_mapping(key)
+      def child_handler_for(key, attributes, collector, handler_stack, current_object)
+        mapping = field_mapping(key, attributes)
         if mapping
           mapping.handler_for(key, collector, handler_stack, current_object)
         end
@@ -108,12 +109,6 @@ module SaxStream
         @mappings_incuding_inherited ||= parent_class_values(:mappings, CoreExtensions::OrderedHash.new).merge(class_mappings).freeze
       end
 
-      def regex_mappings
-        @regex_mappings ||= mappings.reject do |key, mapping|
-          !key.is_a?(Regexp)
-        end
-      end
-
       def should_collect?
         @collect
       end
@@ -123,52 +118,39 @@ module SaxStream
         @group_keys[group_name] ||= []
       end
 
+      def field_mapping(key, attributes = [])
+        field_mappings.field_mapping(key, attributes) || parent_field_mapping(key, attributes)
+      end
+
       private
 
+        def class_mappings
+          field_mappings.class_mappings
+        end
+
         def store_relation_mapping(key, mapping)
           class_relation_mappings << mapping
           store_field_mapping(key, mapping)
         end
 
         def store_field_mapping(key, mapping)
-          key = build_key_from_array(key)
-          class_mappings[key] = mapping
+          field_mappings.store(key, mapping)
         end
 
-        def build_key_from_array(key_array)
-          if key_array.is_a?(Array)
-            joined_key = "(#{key_array.join('|')})".gsub('*', '[^/]+')
-            Regexp.new(joined_key)
-          else
-            build_key_regex(key_array)
-          end
+        def field_mappings
+          @field_mappings ||= Internal::FieldMappings.new
         end
 
-        def build_key_regex(key)
-          key.include?('*') ? Regexp.new(key.gsub('*', '[^/]+')) : key
-        end
-
-        def field_mapping(key)
-          mappings[key] || regex_field_mapping(key)
-        end
-
-        def regex_field_mapping(key)
-          regex_mappings.each do |regex, mapping|
-            return mapping if regex =~ key
-          end
-          nil
+        def parent_field_mapping(*params)
+          parent_class_values :field_mapping, nil, *params
         end
 
         def class_relation_mappings
           @relation_mappings ||= []
         end
 
-        def class_mappings
-          @mappings ||= CoreExtensions::OrderedHash.new
-        end
-
-        def parent_class_values(method_name, default)
-          superclass && superclass.respond_to?(method_name) ? superclass.send(method_name) : default
+        def parent_class_values(method_name, default = nil, *params)
+          superclass && superclass.respond_to?(method_name) ? superclass.send(method_name, *params) : default
         end
 
         def mapping_options=(values)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sax_stream
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.1.0
 platform: ruby
 authors:
 - Craig Ambrose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-07 00:00:00.000000000 Z
+date: 2015-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -32,12 +32,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ./LICENSE
+- ./README.markdown
 - lib/sax_stream/collectors/block_collector.rb
 - lib/sax_stream/collectors/naive_collector.rb
 - lib/sax_stream/core_extensions/ordered_hash.rb
 - lib/sax_stream/errors.rb
 - lib/sax_stream/internal/combined_handler.rb
 - lib/sax_stream/internal/element_stack.rb
+- lib/sax_stream/internal/field_mappings.rb
 - lib/sax_stream/internal/handler_stack.rb
 - lib/sax_stream/internal/mapper_handler.rb
 - lib/sax_stream/internal/mapping_factory.rb
@@ -51,12 +54,10 @@ files:
 - lib/sax_stream/internal/xml_builder.rb
 - lib/sax_stream/mapper.rb
 - lib/sax_stream/parser.rb
+- lib/sax_stream/types.rb
 - lib/sax_stream/types/boolean.rb
 - lib/sax_stream/types/decimal.rb
 - lib/sax_stream/types/integer.rb
-- lib/sax_stream/types.rb
-- ./LICENSE
-- ./README.markdown
 homepage: http://github.com/craigambrose/sax_stream
 licenses: []
 metadata: {}
@@ -76,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A streaming XML parser which builds objects and passes them to a collecter