xmlable 0.0.0.alpha1

data/lib/xmlable/exports/json_exporter.rb

@@ -0,0 +1,208 @@
+module XMLable
+  module Exports
+    #
+    # JSONExporter class exports object into JSON format
+    #
+    class JSONExporter < Base
+      #
+      # Export into JSON format
+      #
+      # @return [Hash]
+      #
+      def export
+        opts = node_nested_options(@element.__node)
+        export_object(@element, opts)
+      end
+
+      #
+      # Is object empty?
+      #
+      # @param [XMLable::Mixins::Object] el
+      #
+      # @return [Boolean]
+      #
+      def empty?(el)
+        el.__empty?
+      end
+
+      #
+      # Is object described by user?
+      #
+      # @param [XMLable::Handlers::Base, XMLable::Mixins::Object]
+      #
+      # @return [Boolean]
+      #
+      #
+      def described?(obj)
+        handler = obj.is_a?(XMLable::Handlers::Base) ? obj : obj.__handler
+        handler.described?
+      end
+
+      #
+      # Get object's key
+      #
+      # @param [XMLable::Handlers::Base, XMLable::Mixins::Object]
+      #
+      # @return [String]
+      #
+      def key(obj, opts)
+        handler = obj.is_a?(XMLable::Handlers::Base) ? obj : obj.__handler
+        handler.method_name
+      end
+
+      #
+      # Get object's handlers
+      #
+      # @param [XMLable::Mixins::Object] el
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Array<XMLable::Handler::Base>]
+      #
+      def object_handlers(el, opts)
+        handlers = []
+        if el.respond_to?(:__attributes_handlers)
+          el.__attributes_handlers.storage.each do |h|
+            next if opts.drop_undescribed_attributes? && !described?(h)
+            handlers << h
+          end
+        end
+        if el.respond_to?(:__elements_handlers)
+          el.__elements_handlers.storage.each do |h|
+            next if opts.drop_undescribed_elements? && !described?(h)
+            handlers << h
+          end
+        end
+        handlers
+      end
+
+      #
+      # Export group of elements
+      #
+      # @param [XMLable::Mixins::Container<XMLable::Mixins::Object>] els
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Array<Hash>]
+      #
+      def export_elements(els, opts)
+        els.each_with_object([]) do |e, arr|
+          next if opts.drop_empty_elements? && empty?(e)
+          arr << export_object(e, opts)
+        end
+      end
+
+      #
+      # Export attribute object's value
+      #
+      # @param [XMLable::Mixins::Object] el
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Object]
+      #
+      def export_value(el, opts)
+        el.__export_to_json(el.__object)
+      end
+
+      #
+      # Export element object's content
+      #
+      # @param [XMLable::Mixins::Object] el
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Object]
+      #
+      def export_content(el, opts)
+        el.__export_to_json(el.__object)
+      end
+
+      #
+      # Get object key
+      #
+      # @param [XMLable::Handlers::Base, XMLable::Mixins::Object]
+      #
+      def key(obj, opts)
+        handler = obj.is_a?(XMLable::Handlers::Base) ? obj : obj.__handler
+        handler.method_name
+      end
+
+      #
+      # Export element object
+      #
+      # @param [XMLable::Mixins::Object] el
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Object]
+      #
+      def export_element(el, opts)
+        opts = node_merged_opts(el.__node, opts)
+        handlers = object_handlers(el, opts)
+        content = export_content(el, opts)
+        return content if handlers.size == 0
+
+        ret = export_element_children(el, opts)
+
+        if !content.to_s.empty? || !opts.drop_empty_elements?
+          content_method = el.__content_method
+          if (content_method || !opts.drop_undescribed_elements?) && content_method != false
+            ret["#{content_method || '__content'}"] = content unless content.to_s.empty?
+          end
+        end
+
+        ret
+      end
+
+      #
+      # Export element's nested objects
+      #
+      # @param [XMLable::Mixins::Object] el
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Hash]
+      #
+      def export_element_children(el, opts)
+        object_handlers(el, opts).each_with_object({}) do |h, memo|
+          obj = el[h.method_name]
+          if h.is_a?(Handlers::Element)
+            next if opts.drop_empty_elements? && empty?(obj)
+          elsif h.is_a?(Handlers::Attribute)
+            next if opts.drop_empty_attributes? && empty?(obj)
+          end
+          memo[key(h, opts)] = export_object(obj, opts)
+        end
+      end
+
+      #
+      # Export root object
+      #
+      # @param [XMLable::Mixins::Object] el
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Hash{String => Object}]
+      #
+      def export_root(el, opts)
+        tag = described?(el.root) ? key(el.root, opts) : el.__node.root.name
+        if !opts.drop_empty_elements? || !empty?(el.root)
+          value = export_object(el.root, opts)
+        end
+        { tag => value }
+      end
+
+      #
+      # Export object
+      #
+      # @param [XMLable::Mixins::Object, XMLable::Mixins::Container] obj
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Object]
+      #
+      def export_object(obj, opts)
+        case obj
+        when Mixins::Container       then export_elements(obj, opts)
+        when Mixins::ElementsStorage then export_element(obj, opts)
+        when Mixins::RootStorage     then export_root(obj, opts)
+        when Mixins::ValueStorage    then export_value(obj, opts)
+        else fail("Don't know how to export #{obj.class.ancestors.inspect}.")
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/exports/xml_exporter.rb

@@ -0,0 +1,179 @@
+module XMLable
+  module Exports
+    #
+    # XMLExporter class exports the data into XML format
+    #
+    class XMLExporter < Base
+      #
+      # @see XMLable::Exports::Base#initialize
+      #
+      def initialize(*)
+        super
+        @node = @element.__node
+        @document = @node.document? ? @node : @node.document
+      end
+
+      #
+      # Export the data into XML format
+      #
+      # @return [String]
+      #
+      def export
+        opts = node_nested_options(@element.__node)
+        builder.tap { |b| export_node(@element.__node, opts.merge(xml: b)) }
+      end
+
+      private
+
+      #
+      # XML builder
+      #
+      # @return [Nokogiri::XML:::Builder]
+      #
+      def builder
+        opts = {}
+        opts[:encoding] = @document.encoding if @document.encoding
+        ::Nokogiri::XML::Builder.new(opts)
+      end
+
+      #
+      # Get element's attributes
+      #
+      # @param [Nokogiri::XML::Element] node XML element
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Hash{String => String}]
+      #
+      def node_attributes(node, opts)
+        return {} unless node.respond_to?(:attributes)
+        attrs = node.attributes.values.select do |att|
+          next if opts.drop_undescribed_attributes? && !described?(att)
+          next if opts.drop_empty_attributes? && empty?(att)
+          true
+        end
+        attrs.each_with_object({}) do |a, hash|
+          name = [a.name]
+          name.unshift(a.namespace.prefix) if a.namespace && a.namespace.prefix
+          hash[name.join(':')] = a.value
+        end
+      end
+
+      #
+      # Get node's namespaces
+      #
+      # @param [Nokogiri::XML::Node] node
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Hash{String => String}]
+      #
+      def node_namespaces(node, opts)
+        return {} unless node.respond_to?(:namespace_definitions)
+
+        node.namespace_definitions.each_with_object({}) do |n, obj|
+          name = ["xmlns", n.prefix].compact.join(":")
+          obj[name] = n.href
+        end
+      end
+
+      #
+      # Export XML document
+      #
+      # @param [Nokogiri::XML::Document] doc
+      # @param [XMLable::Options::Storage] opts
+      #
+      def export_document(doc, opts)
+        export_node(doc.root, opts)
+      end
+
+      #
+      # Export XML element
+      #
+      # @param [Nokogiri::XML::Element] node
+      # @param [XMLable::Options::Storage] opts
+      #
+      def export_element(node, opts)
+        opts = node_merged_opts(node, opts)
+        ns = node.namespace
+        if ns && !node_ns_definition(node, ns.prefix)
+          opts[:xml] = opts[:xml][ns.prefix] if ns.prefix
+        end
+        opts[:xml].send("#{node.name}_", element_args(node, opts)) do |xml|
+          if ns && node_ns_definition(node, ns)
+            xml.parent.namespace = node_ns_definition(xml.parent, ns.prefix)
+          end
+          if !opts.drop_empty_elements? || !empty?(node)
+            export_node_children(node, opts.merge(xml: xml))
+          end
+        end
+      end
+
+      #
+      # Get XML element's attributes and namespace definitions
+      #
+      # @param [Nokogiri::XML::Element] node
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [Hash{String => String}]
+      #
+      def element_args(node, opts)
+        node_namespaces(node, opts).merge(node_attributes(node, opts))
+      end
+
+      #
+      # Get element's namespace definition
+      #
+      # @param [Nokogiri::XML::Element] node
+      # @param [Nokogiri::XML::Namespace, String] ns
+      #
+      # @return [Nokogiri::XML::Namespace, nil] returns namespace if it's found,
+      #   otherwise +nil+
+      #
+      def node_ns_definition(node, ns)
+        prefix = ns.is_a?(Nokogiri::XML::Namespace) ? ns.prefix : ns
+        node.namespace_definitions.find { |n| n.prefix == prefix }
+      end
+
+      #
+      # Export nodes' children
+      #
+      # @param [Nokogiri::XML::Element] node
+      # @param [XMLable::Options::Storage] opts
+      #
+      def export_node_children(node, opts)
+        node.children.each do |child|
+          next if child.is_a?(Nokogiri::XML::Attr)
+          if child.is_a?(Nokogiri::XML::Element)
+            next if opts.drop_empty_elements? && empty?(child)
+            next if opts.drop_undescribed_elements? && !described?(child)
+          end
+          export_node(child, opts)
+        end
+      end
+
+      #
+      # Export XML text node
+      #
+      # @param [Nokogiri::XML::Text] node
+      # @param [XMLable::Options::Storage] opts
+      #
+      def export_text(node, opts)
+        opts[:xml].text(node.text)
+      end
+
+      #
+      # Export XML node
+      #
+      # @param [Nokogiri::XML::Node] node
+      # @param [XMLable::Options::Storage] opts
+      #
+      def export_node(node, opts)
+        case node
+        when Nokogiri::XML::Document then export_document(node, opts)
+        when Nokogiri::XML::Element  then export_element(node, opts)
+        when Nokogiri::XML::Text     then export_text(node, opts)
+        else fail "Don't know how to export node: #{node}"
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/exports.rb

@@ -0,0 +1,11 @@
+module XMLable
+  #
+  # Exports module contains the export classes
+  #
+  module Exports
+  end
+end
+
+require_relative 'exports/base'
+require_relative 'exports/xml_exporter'
+require_relative 'exports/json_exporter'

data/lib/xmlable/handlers/attribute.rb

@@ -0,0 +1,41 @@
+module XMLable
+  module Handlers
+    #
+    # Attribute handles XML attributes objects
+    #
+    class Attribute < Base
+      include Mixins::Namespace
+      include Mixins::Described
+      include Mixins::Tag
+
+      #
+      # @see XMLable::Handler::Base#inject_class
+      #
+      def inject_wraped(klass)
+        klass.class_eval do
+          include XMLable::Mixins::ValueStorage
+          include XMLable::Mixins::Instantiable
+        end
+        klass
+      end
+
+      #
+      # @see XMLable::Handler::Base#proxy
+      #
+      def proxy
+        @proxy ||= type_class.tap { |a| a.class_eval(&@block) if block_settings?  }
+      end
+
+      #
+      # Create attribute object from the XML attribute
+      #
+      # @param [Nokogiri::XML::Attr] attribute
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def from_xml_attribute(attribute)
+        Builder.build_attribute(attribute, self)
+      end
+    end
+  end
+end

data/lib/xmlable/handlers/attribute_none.rb

@@ -0,0 +1,10 @@
+module XMLable
+  module Handlers
+    #
+    # AttributeNone represents null object pattern for the
+    #   XMLable::Handlers::Attribute class
+    #
+    class AttributeNone < Attribute
+    end
+  end
+end

data/lib/xmlable/handlers/base.rb

@@ -0,0 +1,103 @@
+module XMLable
+  module Handlers
+    #
+    # Base contains base handlers logic
+    #
+    class Base
+      # @return [Object]
+      attr_reader :type
+
+      # @return [#call] returns block with additional settings
+      attr_reader :block
+
+      #
+      # @param [String, Symbol] name element/attribute name
+      # @param [Hash] opts adtional handler options
+      # @option opts [Object] :tag element/attribute tag name
+      # @option opts [Object] :type element/attribute class object
+      # @option opts [Object] :container elements container
+      #
+      def initialize(name, opts = {}, &block)
+        @name = name.to_s
+        @type = opts.delete(:type) || String
+        @block = block
+      end
+
+      #
+      # Type class for the handler element
+      #
+      # @return [#new] returns class to store elements and attributes
+      #
+      def type_class
+        klass = Builder.proxy_for(@type)
+        wrapped_type? ? inject_wraped(klass) : klass
+      end
+
+      #
+      # Proxy object which holds element data
+      #
+      # @return [#new]
+      #
+      def proxy
+        raise NotImplementedError
+      end
+
+      #
+      # Inject type class with addtional logic
+      #
+      # @param [Class] klass
+      #
+      # @return [Class]
+      #
+      def inject_wraped(klass)
+      end
+
+      def wrapped_type?
+        Builder.wrapped_type?(type)
+      end
+
+      def options?
+        !options.nil?
+      end
+
+      def options
+        proxy.__options
+      end
+
+      #
+      # Handler's element method name
+      #
+      # @return [String]
+      #
+      def method_name
+        @name
+      end
+
+      #
+      # Does the handler have additional settins
+      #
+      # @return [Boolean]
+      #
+      def block_settings?
+        @block != nil
+      end
+
+      #
+      # Factory to build a handler
+      #
+      # @return [XMLable::Handlers::Base]
+      #
+      def self.build(*args, &block)
+        name = args.shift.to_s
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        opts[:type] = args.shift if args.size > 0
+        opts[:container] = args.shift if args.size > 0
+
+        # standalone
+        opts[:tag] = opts[:type].__tag if opts[:type].respond_to?(:__tag)
+
+        new(name, opts, &block)
+      end
+    end
+  end
+end

data/lib/xmlable/handlers/document.rb

@@ -0,0 +1,33 @@
+module XMLable
+  module Handlers
+    #
+    # Document class handles XML document
+    #
+    class Document < Base
+      #
+      # @param [Class] type
+      #
+      def initialize(type)
+        @type = type
+      end
+
+      #
+      # @see XMLable::Handler::Base#proxy
+      #
+      def proxy
+        @type
+      end
+
+      #
+      # Create document object from the XML document
+      #
+      # @param [Nokogiri::XML::Document] doc
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def from_xml_document(doc)
+        Builder.build_document(doc, self)
+      end
+    end
+  end
+end

data/lib/xmlable/handlers/element.rb

@@ -0,0 +1,89 @@
+module XMLable
+  module Handlers
+    class Element < Base
+      include Mixins::Namespace
+      include Mixins::Described
+      include Mixins::Tag
+
+      #
+      # @see XMLable::Handler::Base#initialize
+      #
+      def initialize(name, opts = {}, &block)
+        @container_type = opts.delete(:container) || Array
+        super(name, opts, &block)
+      end
+
+      #
+      # Proxy class for elements objects
+      #
+      # @return [Class]
+      #
+      def container_proxy
+        @container_proxy ||= Builder.container_proxy_for(@container_type)
+      end
+
+      #
+      # Create elements container for XML element
+      #
+      # @parent [Nokogiri::XML::Element]
+      #
+      # @return [#each]
+      #
+      def container_for_xml_element(parent)
+        container_proxy.new.tap do |c|
+          c.__set_parent_node(parent)
+          c.__set_handler(self)
+        end
+      end
+
+      #
+      # @see XMLable::Handler::Base#inject_wraped
+      #
+      def inject_wraped(klass)
+        klass.class_eval do
+          include XMLable::Mixins::ContentStorage
+          include XMLable::Mixins::AttributesStorage
+          include XMLable::Mixins::ElementsStorage
+          include XMLable::Mixins::NamespaceDefinitionsStorage
+          include XMLable::Mixins::BareValue
+          include XMLable::Mixins::Instantiable
+        end
+        klass
+      end
+
+      #
+      # @see XMLable::Handler::Base#proxy
+      #
+      def proxy
+        @proxy ||= type_class.tap do |p|
+          p.__default_namespace = namespace_prefix
+          p.class_eval(&@block) if block_settings?
+        end
+      end
+
+      #def dynamic?
+        #@block != nil
+      #end
+
+      #
+      # Is this handler for multiple elements objects or not?
+      #
+      # @return [Boolean]
+      #
+      def single?
+        true
+      end
+
+      #
+      # Create element object from the XML element
+      #
+      # @param [Nokogiri::XML::Element] element
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def from_xml_element(element)
+        Builder.build_element(element, self)
+      end
+    end
+  end
+end

data/lib/xmlable/handlers/element_none.rb

@@ -0,0 +1,10 @@
+module XMLable
+  module Handlers
+    #
+    # ElementNone represents null object pattern for the
+    #   XMLable::Handlers::Element class
+    #
+    class ElementNone < Elements
+    end
+  end
+end

data/lib/xmlable/handlers/elements.rb

@@ -0,0 +1,15 @@
+module XMLable
+  module Handlers
+    #
+    # Elements handles group of XML elements
+    #
+    class Elements < Element
+      #
+      # @see XMLable::Handlers::Element#single?
+      #
+      def single?
+        false
+      end
+    end
+  end
+end