blockscore-happymapper 0.6.0

data/lib/happymapper/anonymous_mapper.rb

@@ -0,0 +1,107 @@
+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)
+
+      happymapper_class = create_happymapper_class_with_element(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)
+    end
+
+    private
+
+    #
+    # Borrowed from Active Support to convert unruly element names into a format
+    # known and loved by Rubyists.
+    #
+    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.downcase!
+      word
+    end
+
+    #
+    # Used internally when parsing to create a class that is capable of
+    # parsing the content. The name of the class is of course not likely
+    # going to match the content it will be able to parse so the tag
+    # value is set to the one provided.
+    #
+    def create_happymapper_class_with_tag(tag_name)
+      happymapper_class = Class.new
+      happymapper_class.class_eval do
+        include HappyMapper
+        tag tag_name
+      end
+      happymapper_class
+    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)
+
+      happymapper_class.namespace element.namespace.prefix if element.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)
+      end
+
+      element.children.each do |element|
+        define_element_on_class(happymapper_class, element)
+      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)
+      # When a text element has been provided create the necessary
+      # HappyMapper content attribute if the text happens to content
+      # some content.
+
+      if element.text? && element.content.strip != ''
+        class_instance.content :content, String
+      end
+
+      # 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(&: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
+
+      class_instance.send(method, underscore(element.name), element_type)
+    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
+    end
+  end
+end

data/lib/happymapper/attribute.rb

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

data/lib/happymapper/element.rb

@@ -0,0 +1,53 @@
+module HappyMapper
+  class Element < Item
+    def find(node, namespace, xpath_options)
+      if self.namespace
+        # from the class definition
+        namespace = self.namespace
+      elsif options[:namespace]
+        namespace = options[:namespace]
+      end
+
+      if options[:single]
+        if options[:xpath]
+          result = node.xpath(options[:xpath], xpath_options)
+        else
+          result = node.xpath(xpath(namespace), xpath_options)
+        end
+
+        if result
+          value = yield(result.first)
+          handle_attributes_option(result, value, xpath_options)
+          value
+        end
+      else
+        target_path = options[:xpath] ? options[:xpath] : xpath(namespace)
+        node.xpath(target_path, xpath_options).collect do |result|
+          value = yield(result)
+          handle_attributes_option(result, value, xpath_options)
+          value
+        end
+      end
+    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)
+
+        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...
+  end
+end

data/lib/happymapper/item.rb

@@ -0,0 +1,156 @@
+module HappyMapper
+  class Item
+    attr_accessor :name, :type, :tag, :options, :namespace
+
+    # options:
+    #   :deep   =>  Boolean False to only parse element's children, True to include
+    #               grandchildren and all others down the chain (// in xpath)
+    #   :namespace => String Element's namespace if it's not the global or inherited
+    #                  default
+    #   :parser =>  Symbol Class method to use for type coercion.
+    #   :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 = {})
+      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))
+
+      @xml_type = self.class.to_s.split('::').last.downcase
+    end
+
+    def constant
+      @constant ||= constantize(type)
+    end
+
+    #
+    # @param [XMLNode] 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?
+        find(node, namespace, xpath_options) { |n| process_node_as_supported_type(n) }
+      elsif constant == XmlContent
+        find(node, namespace, xpath_options) { |n| process_node_as_xml_content(n) }
+      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)
+      end
+    end
+
+    def xpath(namespace = self.namespace)
+      xpath  = ''
+      xpath += './/' if options[:deep]
+      xpath += "#{namespace}:" if namespace
+      xpath += tag
+      # puts "xpath: #{xpath}"
+      xpath
+    end
+
+    def method_name
+      @method_name ||= name.tr('-', '_')
+    end
+
+    #
+    # Convert the value into the correct type.
+    #
+    # @param [String] value the string value parsed from the XML value that will
+    #     be converted to the particular primitive type.
+    #
+    # @return [String,Float,Time,Date,DateTime,Boolean,Integer] the converted value
+    #     to the new type.
+    #
+    def typecast(value)
+      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(&: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) }
+    end
+
+    #
+    # Processes a Nokogiri::XML::Node as a supported type
+    #
+    def process_node_as_supported_type(node)
+      content = node.respond_to?(:content) ? node.content : node
+      typecast(content)
+    end
+
+    #
+    # Process a Nokogiri::XML::Node as XML Content
+    #
+    def process_node_as_xml_content(node)
+      node = node.children if node.respond_to?(:children)
+      node.respond_to?(:to_xml) ? node.to_xml : node.to_s
+    end
+
+    #
+    # A custom parser is a custom parse method on the class. When the parser
+    # option has been set this value is the name of the method which will be
+    # used to parse the node content.
+    #
+    def custom_parser_defined?
+      options[:parser]
+    end
+
+    def process_node_with_custom_parser(node)
+      if node.respond_to?(:content) && !options[:raw]
+        value = node.content
+      else
+        value = node.to_s
+      end
+
+      begin
+        constant.send(options[:parser].to_sym, value)
+      rescue
+        nil
+      end
+    end
+
+    def process_node_with_default_parser(node, parse_options)
+      constant.parse(node, options.merge(parse_options))
+    end
+
+    #
+    # Convert any String defined types into their constant version so that
+    # the method #parse or the custom defined parser method would be used.
+    #
+    # @param [String,Constant] type is the name of the class or the constant
+    #     for the class.
+    # @return [Constant] the constant of the type
+    #
+    def constantize(type)
+      type.is_a?(String) ? convert_string_to_constant(type) : type
+    end
+
+    def convert_string_to_constant(type)
+      names = type.split('::')
+      constant = Object
+      names.each do |name|
+        constant =
+          if constant.const_defined?(name)
+            constant.const_get(name)
+          else
+            constant.const_missing(name)
+          end
+      end
+      constant
+    end
+  end
+end

data/lib/happymapper/supported_types.rb

@@ -0,0 +1,137 @@
+module HappyMapper
+  module SupportedTypes
+    extend self
+
+    #
+    # All of the registerd supported types that can be parsed.
+    #
+    # All types defined here are set through #register.
+    #
+    def types
+      @types ||= []
+    end
+
+    #
+    # Add a new converter to the list of supported types. A converter
+    # is an object that adheres to the protocol which is defined with two
+    # methods #apply?(value,convert_to_type) and #apply(value).
+    #
+    # @example Defining a class that would process `nil` or values that have
+    #   already been converted.
+    #
+    #     class NilOrAlreadyConverted
+    #       def apply?(value,convert_to_type)
+    #         value.kind_of?(convert_to_type) || value.nil?
+    #       end
+    #
+    #       def apply(value)
+    #         value
+    #       end
+    #     end
+    #
+    #
+    def register(type_converter)
+      types.push type_converter
+    end
+
+    #
+    # An additional shortcut registration method that assumes that you want
+    # to perform a conversion on a specific type. A block is provided which
+    # is the operation to perform when #apply(value) has been called.
+    #
+    # @example Registering a DateTime parser
+    #
+    #     HappyMapper::SupportedTypes.register_type DateTime do |value|
+    #       DateTime.parse(value,to_s)
+    #     end
+    #
+    def register_type(type, &block)
+      register CastWhenType.new(type, &block)
+    end
+
+    #
+    # Many of the conversions are based on type. When the type specified
+    # matches then perform the action specified in the specified block.
+    # If no block is provided the value is simply returned.
+    #
+    class CastWhenType
+      attr_reader :type
+
+      def initialize(type, &block)
+        @type = type
+        @apply_block = block || no_operation
+      end
+
+      def no_operation
+        ->(value) { value }
+      end
+
+      def apply?(_value, convert_to_type)
+        convert_to_type == type
+      end
+
+      def apply(value)
+        @apply_block.call(value)
+      end
+    end
+
+    #
+    # For the cases when the value is nil or is already the
+    # intended type then no work needs to be done and the
+    # value simply can be returned.
+    #
+    class NilOrAlreadyConverted
+      def type
+        NilClass
+      end
+
+      def apply?(value, convert_to_type)
+        value.is_a?(convert_to_type) || value.nil?
+      end
+
+      def apply(value)
+        value
+      end
+    end
+
+    register NilOrAlreadyConverted.new
+
+    register_type String, &:to_s
+
+    register_type Float, &:to_f
+
+    register_type Time do |value|
+      begin
+        Time.parse(value.to_s)
+      rescue
+        Time.at(value.to_i)
+      end
+    end
+
+    register_type DateTime do |value|
+      DateTime.parse(value.to_s)
+    end
+
+    register_type Date do |value|
+      Date.parse(value.to_s)
+    end
+
+    register_type Boolean do |value|
+      %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+)/ ? Regexp.last_match(1) : value_to_s)
+        rescue ArgumentError
+          nil
+        end
+      else
+        value_to_i
+      end
+    end
+  end
+end