nokogiri-happymapper 0.6.0 → 0.7.0

data/lib/happymapper/anonymous_mapper.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 module HappyMapper
   module 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)
@@ -13,8 +13,7 @@ module HappyMapper
       # 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)
-
+      happymapper_class.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
@@ -56,59 +55,58 @@ module HappyMapper
 
       happymapper_class.namespace element.namespace.prefix if element.namespace
 
-      element.namespaces.each do |prefix,namespace|
+      element.namespaces.each do |prefix, namespace|
         happymapper_class.register_namespace prefix, namespace
       end
 
-      element.attributes.each do |name,attribute|
-        define_attribute_on_class(happymapper_class,attribute)
+      element.attributes.each_value do |attribute|
+        define_attribute_on_class(happymapper_class, attribute)
       end
 
       element.children.each do |child|
-        define_element_on_class(happymapper_class,child)
+        define_element_on_class(happymapper_class, child)
       end
 
       happymapper_class
     end
 
-
     #
     # Define a HappyMapper element on the provided class based on
     # the element provided.
     #
-    def define_element_on_class(class_instance,element)
-
+    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
+      # HappyMapper content attribute if the text happens to contain
       # some content.
 
-      if element.text? and element.content.strip != ""
-        class_instance.content :content, String
-      end
+      class_instance.content :content, String if element.text? && (element.content.strip != '')
 
       # When the element has children elements, that are not text
       # elements, 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 !element.elements.reject(&:text?).empty? || !element.attributes.empty?
+                       create_happymapper_class_with_element(element)
+                     else
+                       String
+                     end
+
+      method = class_instance.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] = element.name
+      namespace = element.namespace
+      options[:namespace] = namespace.prefix if namespace
 
-      class_instance.send(method,underscore(element.name),element_type)
+      class_instance.send(method, underscore(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(class_instance, attribute)
+      class_instance.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,18 @@ 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 result.respond_to?(:attribute_nodes)
+      return unless options[:attributes].is_a?(Hash)
+      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.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...
+      result.attribute_nodes.each do |xml_attribute|
+        next unless (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)
 
+        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
@@ -31,7 +33,6 @@ module HappyMapper
     # @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,28 +98,30 @@ 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)
+      begin
+        Time.parse(value.to_s)
+      rescue StandardError
+        Time.at(value.to_i)
+      end
     end
 
+    # rubocop:disable Style/DateTime
     register_type DateTime do |value|
       DateTime.parse(value.to_s) if value && !value.empty?
     end
+    # rubocop:enable Style/DateTime
 
     register_type Date do |value|
       Date.parse(value.to_s) 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|
@@ -134,7 +137,5 @@ module HappyMapper
         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.7.0'
 end

data/spec/attribute_default_value_spec.rb

@@ -1,46 +1,45 @@
-require 'spec_helper'
-
-describe "Attribute Default Value" do
+# frozen_string_literal: true
 
-  context "when given a default value" do
+require 'spec_helper'
 
+describe 'Attribute Default Value' do
+  context 'when given a default value' do
     class Meal
       include HappyMapper
       tag 'meal'
-      attribute :type, String, :default => 'omnivore'
+      attribute :type, String, default: 'omnivore'
     end
 
     let(:subject) { Meal }
     let(:default_meal_type) { 'omnivore' }
 
-    context "when no value has been specified" do
-      it "returns the default value" do
+    context 'when no value has been specified' do
+      it 'returns the default value' do
         meal = subject.parse('<meal />')
         expect(meal.type).to eq default_meal_type
       end
     end
 
-    context "when saving to xml" do
-
-      let(:expected_xml) { %{<?xml version="1.0"?>\n<meal/>\n} }
+    context 'when saving to xml' do
+      let(:expected_xml) { %(<?xml version="1.0"?>\n<meal/>\n) }
 
-      it "the default value is not included" do
+      it 'the default value is not included' do
         meal = subject.new
         expect(meal.to_xml).to eq expected_xml
       end
     end
 
-    context "when a new, non-nil value has been set" do
-      it "returns the new value" do
+    context 'when a new, non-nil value has been set' do
+      it 'returns the new value' do
         meal = subject.parse('<meal />')
         meal.type = 'vegan'
 
         expect(meal.type).to_not eq default_meal_type
       end
 
-      let(:expected_xml) { %{<?xml version="1.0"?>\n<meal type="kosher"/>\n} }
+      let(:expected_xml) { %(<?xml version="1.0"?>\n<meal type="kosher"/>\n) }
 
-      it "saves the new value to the xml" do
+      it 'saves the new value to the xml' do
         meal = subject.new
         meal.type = 'kosher'
         expect(meal.to_xml).to eq expected_xml