nokogiri-happymapper 0.6.0 → 0.9.0

data/lib/happymapper/anonymous_mapper.rb

@@ -1,20 +1,19 @@
-module HappyMapper
-  module AnonymousMapper
+# frozen_string_literal: true
 
+module HappyMapper
+  class AnonymousMapper
     def parse(xml_content)
-
       # TODO: this should be able to handle all the types of functionality that parse is able
       #   to handle which includes the text, xml document, node, fragment, etc.
       xml = Nokogiri::XML(xml_content)
 
-      happymapper_class = create_happymapper_class_with_element(xml.root)
+      klass = create_happymapper_class_from_node(xml.root)
 
       # With all the elements and attributes defined on the class it is time
       # for the class to actually use the normal HappyMapper powers to parse
       # the content. At this point this code is utilizing all of the existing
       # code implemented for parsing.
-      happymapper_class.parse(xml_content, :single => true)
-
+      klass.parse(xml_content, single: true)
     end
 
     private
@@ -25,9 +24,9 @@ module HappyMapper
     #
     def underscore(camel_cased_word)
       word = camel_cased_word.to_s.dup
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!('-', '_')
       word.downcase!
       word
     end
@@ -39,76 +38,80 @@ module HappyMapper
     # value is set to the one provided.
     #
     def create_happymapper_class_with_tag(tag_name)
-      happymapper_class = Class.new
-      happymapper_class.class_eval do
+      klass = Class.new
+      klass.class_eval do
         include HappyMapper
         tag tag_name
       end
-      happymapper_class
+      klass
     end
 
     #
     # Used internally to create and define the necessary happymapper
     # elements.
     #
-    def create_happymapper_class_with_element(element)
-      happymapper_class = create_happymapper_class_with_tag(element.name)
+    def create_happymapper_class_from_node(node)
+      klass = create_happymapper_class_with_tag(node.name)
 
-      happymapper_class.namespace element.namespace.prefix if element.namespace
+      klass.namespace node.namespace.prefix if node.namespace
 
-      element.namespaces.each do |prefix,namespace|
-        happymapper_class.register_namespace prefix, namespace
+      node.namespaces.each do |prefix, namespace|
+        klass.register_namespace prefix, namespace
       end
 
-      element.attributes.each do |name,attribute|
-        define_attribute_on_class(happymapper_class,attribute)
+      node.attributes.each_value do |attribute|
+        define_attribute_on_class(klass, attribute)
       end
 
-      element.children.each do |child|
-        define_element_on_class(happymapper_class,child)
+      node.children.each do |child|
+        define_element_on_class(klass, child)
       end
 
-      happymapper_class
+      klass
     end
 
-
     #
     # Define a HappyMapper element on the provided class based on
-    # the element provided.
+    # the node provided.
     #
-    def define_element_on_class(class_instance,element)
-
-      # When a text element has been provided create the necessary
-      # HappyMapper content attribute if the text happens to content
+    def define_element_on_class(klass, node)
+      # When a text node has been provided create the necessary
+      # HappyMapper content attribute if the text happens to contain
       # some content.
 
-      if element.text? and element.content.strip != ""
-        class_instance.content :content, String
+      if node.text?
+        klass.content :content, String if node.content.strip != ''
+        return
       end
 
-      # When the element has children elements, that are not text
-      # elements, then we want to recursively define a new HappyMapper
+      # When the node has child elements, that are not text
+      # nodes, then we want to recursively define a new HappyMapper
       # class that will have elements and attributes.
 
-      element_type = if !element.elements.reject {|e| e.text? }.empty? or !element.attributes.empty?
-        create_happymapper_class_with_element(element)
-      else
-        String
-      end
+      element_type = if node.elements.any? || node.attributes.any?
+                       create_happymapper_class_from_node(node)
+                     else
+                       String
+                     end
+
+      element_name = underscore(node.name)
+      method = klass.elements.find { |e| e.name == element_name } ? :has_many : :has_one
 
-      method = class_instance.elements.find {|e| e.name == element.name } ? :has_many : :has_one
+      options = {}
+      options[:tag] = node.name
+      namespace = node.namespace
+      options[:namespace] = namespace.prefix if namespace
+      options[:xpath] = './' unless element_type == String
 
-      class_instance.send(method,underscore(element.name),element_type)
+      klass.send(method, element_name, element_type, options)
     end
 
     #
     # Define a HappyMapper attribute on the provided class based on
     # the attribute provided.
     #
-    def define_attribute_on_class(class_instance,attribute)
-      class_instance.attribute underscore(attribute.name), String
+    def define_attribute_on_class(klass, attribute)
+      klass.attribute underscore(attribute.name), String, tag: attribute.name
     end
-
   end
-
 end

data/lib/happymapper/attribute.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HappyMapper
   class Attribute < Item
     attr_accessor :default
@@ -5,16 +7,16 @@ module HappyMapper
     # @see Item#initialize
     # Additional options:
     #   :default => Object The default value for this
-    def initialize(name, type, o={})
+    def initialize(name, type, options = {})
       super
-      self.default = o[:default]
+      self.default = options[:default]
     end
 
-    def find(node, namespace, xpath_options)
+    def find(node, _namespace, xpath_options)
       if options[:xpath]
-        yield(node.xpath(options[:xpath],xpath_options))
+        yield(node.xpath(options[:xpath], xpath_options))
       else
-        yield(node[tag])
+        yield(node.attributes[tag])
       end
     end
   end

data/lib/happymapper/element.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module HappyMapper
   class Element < Item
-
     def find(node, namespace, xpath_options)
       if self.namespace
         # from the class definition
@@ -10,11 +11,11 @@ module HappyMapper
       end
 
       if options[:single]
-        if options[:xpath]
-          result = node.xpath(options[:xpath], xpath_options)
-        else
-          result = node.xpath(xpath(namespace), xpath_options)
-        end
+        result = if options[:xpath]
+                   node.xpath(options[:xpath], xpath_options)
+                 else
+                   node.xpath(xpath(namespace), xpath_options)
+                 end
 
         if result
           value = yield(result.first)
@@ -22,7 +23,7 @@ module HappyMapper
           value
         end
       else
-        target_path = options[:xpath] ? options[:xpath] : xpath(namespace)
+        target_path = options[:xpath] || xpath(namespace)
         node.xpath(target_path, xpath_options).collect do |item|
           value = yield(item)
           handle_attributes_option(item, value, xpath_options)
@@ -32,24 +33,20 @@ module HappyMapper
     end
 
     def handle_attributes_option(result, value, xpath_options)
-      if options[:attributes].is_a?(Hash)
-        result = result.first unless result.respond_to?(:attribute_nodes)
+      return unless options[:attributes].is_a?(Hash)
 
-        return unless result.respond_to?(:attribute_nodes)
+      result = result.first unless result.respond_to?(:attribute_nodes)
+      return unless result.respond_to?(:attribute_nodes)
 
-        result.attribute_nodes.each do |xml_attribute|
-          if attribute_options = options[:attributes][xml_attribute.name.to_sym]
-            attribute_value = Attribute.new(xml_attribute.name.to_sym, *attribute_options).from_xml_node(result, namespace, xpath_options)
+      result.attribute_nodes.each do |xml_attribute|
+        next unless (attribute_options = options[:attributes][xml_attribute.name.to_sym])
 
-            result.instance_eval <<-EOV
-                def value.#{xml_attribute.name.gsub(/\-/, '_')}
-            #{attribute_value.inspect}
-                end
-            EOV
-          end # if attributes_options
-        end # attribute_nodes.each
-      end # if options[:attributes]
-    end # def handle...
+        attribute_value = Attribute.new(xml_attribute.name.to_sym, *attribute_options)
+                                   .from_xml_node(result, namespace, xpath_options)
 
+        method_name = xml_attribute.name.tr('-', '_')
+        value.define_singleton_method(method_name) { attribute_value }
+      end
+    end
   end
 end

data/lib/happymapper/item.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HappyMapper
   class Item
     attr_accessor :name, :type, :tag, :options, :namespace
@@ -11,12 +13,12 @@ module HappyMapper
     #   :raw    =>  Boolean Use raw node value (inc. tags) when parsing.
     #   :single =>  Boolean False if object should be collection, True for single object
     #   :tag    =>  String Element name if it doesn't match the specified name.
-    def initialize(name, type, o={})
+    def initialize(name, type, options = {})
       self.name = name.to_s
       self.type = type
-      #self.tag = o.delete(:tag) || name.to_s
-      self.tag = o[:tag] || name.to_s
-      self.options = { :single => true }.merge(o.merge(:name => self.name))
+      # self.tag = options.delete(:tag) || name.to_s
+      self.tag = options[:tag] || name.to_s
+      self.options = { single: true }.merge(options.merge(name: self.name))
 
       @xml_type = self.class.to_s.split('::').last.downcase
     end
@@ -26,12 +28,11 @@ module HappyMapper
     end
 
     #
-    # @param [XMLNode] node the xml node that is being parsed
+    # @param [Nokogiri::XML::Element] node the xml node that is being parsed
     # @param [String] namespace the name of the namespace
     # @param [Hash] xpath_options additional xpath options
     #
     def from_xml_node(node, namespace, xpath_options)
-
       namespace = options[:namespace] if options.key?(:namespace)
 
       if suported_type_registered?
@@ -41,9 +42,8 @@ module HappyMapper
       elsif custom_parser_defined?
         find(node, namespace, xpath_options) { |n| process_node_with_custom_parser(n) }
       else
-        process_node_with_default_parser(node,:namespaces => xpath_options)
+        process_node_with_default_parser(node, namespaces: xpath_options)
       end
-
     end
 
     def xpath(namespace = self.namespace)
@@ -51,7 +51,7 @@ module HappyMapper
       xpath += './/' if options[:deep]
       xpath += "#{namespace}:" if namespace
       xpath += tag
-      #puts "xpath: #{xpath}"
+      # puts "xpath: #{xpath}"
       xpath
     end
 
@@ -72,19 +72,18 @@ module HappyMapper
       typecaster(value).apply(value)
     end
 
-
     private
 
     # @return [Boolean] true if the type defined for the item is defined in the
     #     list of support types.
     def suported_type_registered?
-      SupportedTypes.types.map {|caster| caster.type }.include?(constant)
+      SupportedTypes.types.map(&:type).include?(constant)
     end
 
     # @return [#apply] the typecaster object that will be able to convert
     #   the value into a value with the correct type.
     def typecaster(value)
-      SupportedTypes.types.find { |caster| caster.apply?(value,constant) }
+      SupportedTypes.types.find { |caster| caster.apply?(value, constant) }
     end
 
     #
@@ -113,21 +112,21 @@ module HappyMapper
     end
 
     def process_node_with_custom_parser(node)
-      if node.respond_to?(:content) && !options[:raw]
-        value = node.content
-      else
-        value = node.to_s
-      end
+      value = if node.respond_to?(:content) && !options[:raw]
+                node.content
+              else
+                node.to_s
+              end
 
       begin
         constant.send(options[:parser].to_sym, value)
-      rescue
+      rescue StandardError
         nil
       end
     end
 
-    def process_node_with_default_parser(node,parse_options)
-      constant.parse(node,options.merge(parse_options))
+    def process_node_with_default_parser(node, parse_options)
+      constant.parse(node, options.merge(parse_options))
     end
 
     #
@@ -155,6 +154,5 @@ module HappyMapper
       end
       constant
     end
-
   end
 end

data/lib/happymapper/supported_types.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module HappyMapper
   module SupportedTypes
-    extend self
+    module_function
 
     #
     # All of the registerd supported types that can be parsed.
@@ -45,8 +47,8 @@ module HappyMapper
     #       DateTime.parse(value,to_s)
     #     end
     #
-    def register_type(type,&block)
-      register CastWhenType.new(type,&block)
+    def register_type(type, &block)
+      register CastWhenType.new(type, &block)
     end
 
     #
@@ -57,16 +59,16 @@ module HappyMapper
     class CastWhenType
       attr_reader :type
 
-      def initialize(type,&block)
+      def initialize(type, &block)
         @type = type
         @apply_block = block || no_operation
       end
 
       def no_operation
-        lambda {|value| value }
+        ->(value) { value }
       end
 
-      def apply?(value,convert_to_type)
+      def apply?(_value, convert_to_type)
         convert_to_type == type
       end
 
@@ -81,13 +83,12 @@ module HappyMapper
     # value simply can be returned.
     #
     class NilOrAlreadyConverted
-
       def type
         NilClass
       end
 
-      def apply?(value,convert_to_type)
-        value.kind_of?(convert_to_type) || value.nil?
+      def apply?(value, convert_to_type)
+        value.is_a?(convert_to_type) || value.nil?
       end
 
       def apply(value)
@@ -97,44 +98,35 @@ module HappyMapper
 
     register NilOrAlreadyConverted.new
 
-    register_type String do |value|
-      value.to_s
-    end
+    register_type String, &:to_s
 
-    register_type Float do |value|
-      value.to_f
-    end
+    register_type Float, &:to_f
 
     register_type Time do |value|
-      Time.parse(value.to_s) rescue Time.at(value.to_i)
+      Time.parse(value.to_s)
+    rescue StandardError
+      Time.at(value.to_i)
     end
 
     register_type DateTime do |value|
-      DateTime.parse(value.to_s) if value && !value.empty?
+      DateTime.parse(value.to_s, true, Date::ITALY) if value && !value.empty?
     end
 
     register_type Date do |value|
-      Date.parse(value.to_s) if value && !value.empty?
+      Date.parse(value.to_s, true, Date::ITALY) if value && !value.empty?
     end
 
     register_type Boolean do |value|
-      ['true', 't', '1'].include?(value.to_s.downcase)
+      %w(true t 1).include?(value.to_s.downcase)
     end
 
     register_type Integer do |value|
       value_to_i = value.to_i
-      if value_to_i == 0 && value != '0'
-        value_to_s = value.to_s
-        begin
-          Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
-        rescue ArgumentError
-          nil
-        end
+      if value_to_i == 0 && !value.to_s.start_with?('0')
+        nil
       else
         value_to_i
       end
     end
-
   end
-
 end

data/lib/happymapper/text_node.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module HappyMapper
   class TextNode < Item
-
-    def find(node, namespace, xpath_options)
-      yield(node.children.detect{|c| c.text?})
+    def find(node, _namespace, _xpath_options)
+      yield(node.children.detect(&:text?))
     end
   end
 end

data/lib/happymapper/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HappyMapper
-  VERSION = "0.6.0"
+  VERSION = '0.9.0'
 end