xmlable 0.0.0.alpha1

data/lib/xmlable/mixins/content_storage.rb

@@ -0,0 +1,138 @@
+module XMLable
+  module Mixins
+    #
+    # ContentStorage module contains the logic that helps to store XML element
+    #   content.
+    #
+    module ContentStorage
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # Set XML element content
+      #
+      # @param [Nokogiri::XML::Element] node
+      #
+      # @api private
+      #
+      def __set_content(node)
+        val = node.children.select(&:text?).map(&:content).join('').strip
+        @__content = __cast(val)
+      end
+
+      #
+      # Override XML node content
+      #
+      # @param [Object] value
+      #
+      # @api private
+      #
+      def __overwrite_content(val)
+        val = __cast(val)
+        @__node.content = __export_to_xml(val)
+        @__content = val
+      end
+
+      #
+      # Get content value
+      #
+      # @api private
+      #
+      # @return [Object]
+      #
+      def __object
+        __content
+      end
+
+      #
+      # Get content value
+      #
+      # @api private
+      #
+      # @return [Object]
+      #
+      def __content
+        @__content
+      end
+
+      #
+      # Set content value
+      #
+      # @param [Object] value
+      #
+      # @api private
+      #
+      # @return [Object]
+      #
+      def __content=(val)
+        __overwrite_content(val)
+      end
+
+      #
+      # Is this element?
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      #
+      def __empty?
+        return false unless super
+        __empty(__content)
+      end
+
+      #
+      # @return [String]
+      #
+      def to_s
+        __content.to_s
+      end
+
+      #
+      # Get content alias method
+      #
+      # @api private
+      #
+      # @return [String, nil]
+      #
+      def __content_method
+        self.class.__content_method
+      end
+
+      #
+      # Contents methods
+      #
+      # @api private
+      #
+      # @return [Array<String>]
+      #
+      def __content_methods
+        ret = ['__content']
+        ret << __content_method.to_s if __content_method
+        ret
+      end
+
+      module ClassMethods
+        #
+        # Define content method
+        #   If given +false+ name than content isn't available to this element.
+        #
+        # @param [String, Symbol, false]  name
+        #
+        def content(name)
+          @__content_method = name.is_a?(String) ? name.to_sym : name
+        end
+
+        #
+        # Get content method
+        #
+        # @return [String, nil, false]
+        #
+        def __content_method
+          return @__content_method if instance_variable_defined?(:@__content_method)
+          @__content_method = __nested(:@__content_method)
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/document_storage.rb

@@ -0,0 +1,136 @@
+module XMLable
+  module Mixins
+    #
+    # DocumentStorage module contains the logic to work with XML document
+    #
+    module DocumentStorage
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # @param [Hash] args document initial params
+      # @param [Nokogiri::XML::Document] doc XML document
+      # @param [XMLable::Handlers::Document] handler document's handler
+      #
+      def initialize(args = {}, doc = nil, handler = nil)
+        doc ||= Nokogiri::XML::Document.new
+        handler ||= Handlers::Document.new(self.class)
+        super
+      end
+
+      #
+      # Get XML document version
+      #
+      # @return [String, nil]
+      #
+      def version
+        __node.version
+      end
+
+      #
+      # Get XML document encoding
+      #
+      # @return [String, nil]
+      #
+      def encoding
+        __node.encoding
+      end
+
+      #
+      # Get document's handler
+      #
+      # @api private
+      #
+      # @return [XMLable::Handlers::Document]
+      #
+      def __document_handler
+        self.class.__document_handler
+      end
+
+      module ClassMethods
+        #
+        # Define document params
+        #
+        # @param [Hash] opts
+        #
+        def document(opts = {})
+          opt(opts) if opts.size > 0
+        end
+
+        #
+        # Set the Nokogiri's parsing params
+        #
+        def nokogiri_parse(*args)
+          args.each do |opt|
+            __nokogiri_parse_options.send(opt) if __nokogiri_parse_options.respond_to?(opt)
+          end
+        end
+
+        #
+        # Set the Nokogiri's export params
+        #
+        def nokogiri_export(*args)
+          __nokogiri_export_options.tap do |opts|
+            opts.merge!(args.pop) if args.last.is_a?(Hash)
+            args.each { |opt| opts.save_with.send(opt) if opts.save_with.respond_to?(opt) }
+          end
+        end
+
+        #
+        # Nokogiri's options for parsing
+        #
+        # @api private
+        #
+        # @return [Nokogiri::XML::ParseOptions]
+        #
+        def __nokogiri_parse_options
+          @__nokogiri_parse_options ||= Nokogiri::XML::ParseOptions.new.recover
+        end
+
+        #
+        # Nokogiri's options for exporting
+        #
+        # @api private
+        #
+        # @return [Nokogiri::XML::ParseOptions]
+        #
+        def __nokogiri_export_options
+          @__nokogiri_export_options ||= Options::NokogiriExport.new
+        end
+
+        #
+        # Get document's handler
+        #
+        # @api private
+        #
+        # @return [XMLable::Handlers::Document]
+        #
+        def __document_handler
+          @__document_handler ||= Handlers::Document.new(self)
+        end
+
+        #
+        # Initialize document from XML
+        #
+        # @param [Nokogiri::XML::Document, String] xml
+        # @param [Hash] _opts
+        #
+        # @return [XMLable::Document]
+        #
+        def from_xml(xml, _opts = {})
+          xml = '' unless xml
+          if xml.is_a?(String)
+            doc = Nokogiri::XML(xml) do |config|
+              config.options  = __nokogiri_parse_options.to_i
+            end
+          elsif xml.is?(Nokogiri::XML::Document)
+            doc = xml
+          else raise "Don't know how to parse '#{xml.class}'"
+          end
+          __document_handler.from_xml_document(doc)
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/elements_storage.rb

@@ -0,0 +1,219 @@
+module XMLable
+  module Mixins
+    #
+    # ElementsStorage module contains the logic to store XML elements
+    #
+    module ElementsStorage
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # Set element from XML Node
+      #
+      # @param [Symbol] name tag name
+      # @param [Nokogiri::XML::Element, nil] el
+      #
+      # @api private
+      #
+      def __set_element(el, opts = {})
+        unless el.is_a?(Nokogiri::XML::Element)
+          el = Nokogiri::XML::Element.new(opts[:tag], @__node)
+          @__node << el
+          if opts[:namespace]
+            el.namespace = el.namespace_scopes.find { |n| n.prefix == opts[:namespace] }
+          end
+        end
+        h = __elements_handlers.for_xml_object(el)
+        el.instance_variable_set(:@__handler, h)
+        __initialize_elements_container(h) << h.from_xml_element(el)
+      end
+
+      #
+      # Initialize elements container
+      #
+      # @param [XMLable::Handlers::Element, XMLable::Handlers::Elements, XMLable::Handlers::ElementNone] h
+      #
+      # @api private
+      #
+      # @return [XMLable::Mixins::Container]
+      #
+      def __initialize_elements_container(h)
+        __elements[h.key] ||= h.container_for_xml_element(__node)
+      end
+
+      #
+      # Elements which current object holds
+      #
+      # @api private
+      #
+      # @return [Hash(String => Array<XMLable::Mixins::Object>)]
+      #
+      def __elements
+        @__elements ||= {}
+      end
+
+      #
+      # Is this object empty?
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      #
+      def __empty?
+        return false unless super
+        __elements.values.all?(&:__empty?)
+      end
+
+      def method_missing(name, *args, &blocks)
+        h = __has_element_handler?(name)
+        return super unless h
+
+        if name.to_s.end_with?('=')
+          __element_object_set(h, args.first)
+        else
+          __element_object_get(h)
+        end
+      end
+
+      #
+      # Elements handlers storage
+      #
+      # @api private
+      #
+      # @return [XMLable::Handlers::Storage]
+      #
+      def __elements_handlers
+        @__elements_handler ||= self.class.__elements_handlers.clone
+      end
+
+      #
+      # Does this object contain element with given key?
+      #
+      # @return [XMLable::Mixins::Object, false]
+      #
+      def key?(key)
+        super || __has_element_handler?(key)
+      end
+
+      #
+      # Get element object by its key
+      #
+      # @param [String] key element key
+      #
+      # @return [XMLable::Mixins::Object, nil]
+      #
+      def [](key)
+        h = __has_element_handler?(key)
+        h ? __element_object_get(h) : super
+      end
+
+      #
+      # Set element value
+      #
+      # @param [String] key element key
+      # @param [Object] val new value
+      #
+      # @return [XMLable::Mixins::Object, nil]
+      #
+      def []=(key, val)
+        h = __has_element_handler?(key)
+        h ? __element_object_set(h, val) : super
+      end
+
+      #
+      # Find element handler by its key
+      #
+      # @param [Symbol, String] key
+      #
+      # @api private
+      #
+      # @return [XMLable::Handlers::Element, XMLable::Handlers::ElementNone, nil]
+      #
+      def __has_element_handler?(key)
+        key = key.to_s.gsub(/[=!]$/, '')
+        __elements_handlers.storage.find { |h| h.method_name == key }
+      end
+
+      #
+      # Get element object
+      #
+      # @param [XMLable::Handlers::Element, XMLable::Handlers::Elements, XMLable::Handlers::ElementNone] h
+      #
+      # @api private
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def __element_object_get(h)
+        unless __elements.key?(h.key)
+          if h.single?
+            __set_element(nil, tag: h.tag, namespace: h.namespace_prefix)
+          else
+            __initialize_elements_container(h)
+          end
+        end
+        ret = __elements[h.key]
+        h.single? ? ret.first : ret
+      end
+
+      #
+      # Set element object value
+      #
+      # @param [XMLable::Handlers::Element, XMLable::Handlers::Elements, XMLable::Handlers::ElementNone] h
+      # @param [Object] val
+      #
+      # @api private
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def __element_object_set(h, val)
+        __element_object_get(h).__overwrite_content(val)
+      end
+
+      #
+      # Set element object value
+      #
+      # @param [XMLable::Handlers::Element, XMLable::Handlers::Elements, XMLable::Handlers::ElementNone] h
+      # @param [Object] val
+      #
+      # @api private
+      #
+      def __element_object_initialize(h, val)
+        obj = __element_object_get(h)
+
+        val = { '__content' => val } unless val.respond_to?(:each)
+        if h.single?
+          obj.__initialize_with(val)
+        else
+          val.map { |v| obj.new(v) }
+        end
+      end
+
+      module ClassMethods
+
+        #
+        # Elements handlers storage
+        #
+        # @api private
+        #
+        # @return [XMLable::Handlers::Storage]
+        #
+        def __elements_handlers
+          @__elements_handlers ||=
+            __nested(:@__elements_handlers) || Handlers::Storage.new(default: Handlers::ElementNone)
+        end
+
+        %i[element elements].each do |m|
+          define_method m do |*args, &block|
+            opts = args.last.is_a?(Hash) ? args.pop : {}
+            if __default_namespace && !opts.key?(:namespace)
+              opts[:namespace] = __default_namespace
+            end
+            h = XMLable::Handlers.const_get(__method__.to_s.capitalize).build(*args, opts, &block)
+            __elements_handlers << h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/export.rb

@@ -0,0 +1,45 @@
+module XMLable
+  module Mixins
+    #
+    # Export modules contains method to export
+    #
+    module Export
+      #
+      # Export to XML
+      #
+      # @param [Hash] opts
+      #
+      # @return [String] returns exported XML
+      #
+      def to_xml(opts = {})
+        exporter = Exports::XMLExporter.new(self, opts)
+        opts = self.class.__nokogiri_export_options.merge(opts)
+        exporter.export.to_xml(opts).strip
+      end
+
+      #
+      # Export to JSON
+      #
+      # @param [Hash] opts
+      # @option opts [Boolean] :pretty enable pretty print
+      #
+      # @return [String] returns exported JSON
+      #
+      def to_json(opts = {})
+        ret = to_h(opts)
+        opts[:pretty] ? JSON.pretty_generate(ret) : ret.to_json
+      end
+
+      #
+      # Export to hash
+      #
+      # @param [Hash] opts
+      #
+      # @return [Hash]
+      #
+      def to_h(opts = {})
+        Exports::JSONExporter.new(self, opts).export
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/instantiable.rb

@@ -0,0 +1,47 @@
+module XMLable
+  module Mixins
+    #
+    # Instantiable module contains the logic to initialize the new elements
+    #
+    module Instantiable
+      #
+      # @param [Object] items initial params
+      # @param [Nokogiri::XML::Node] node
+      # @param [XMLable::Handlers::Base] handler
+      #
+      def initialize(items = nil, node = nil, handler = nil)
+        super(node, handler)
+        __initialize_with(items) if items
+      end
+
+      #
+      # Initialize object with given value
+      #
+      # @param [Object] value
+      #
+      def __initialize_with(value)
+        if value.is_a?(Hash)
+          value.each do |key, val|
+            if respond_to?(:__overwrite_content) && __content_methods.include?(key.to_s)
+              next __overwrite_content(val)
+            end
+
+            h = key?(key)
+            case h
+            when Handlers::Attribute then __attribute_object_initialize(h, val)
+            when Handlers::Root then __root_object_initialize(h, val)
+            when Handlers::Element then __element_object_initialize(h, val)
+            else raise h.inspect
+            end
+          end
+        else
+          case __handler
+          when Handlers::Attribute then __overwrite_value(value)
+          when Handlers::Element then __overwrite_content(value)
+          else raise h.inspect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/namespace_definitions_storage.rb

@@ -0,0 +1,105 @@
+module XMLable
+  module Mixins
+    #
+    # NamespaceDefinitionsStorage module contains the logic to manage with XML
+    #   namespaces definitions
+    #
+    module NamespaceDefinitionsStorage
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # @see XMLable::Mixins::Object#initialize
+      #
+      def initialize(*)
+        super
+        __define_namespaces(__namespace_definitions)
+      end
+
+      #
+      # Define XML namespaces
+      #
+      # @param [Array<XMLable::Handlers::Namespace>] handlers
+      #
+      # @api private
+      #
+      def __define_namespaces(handlers)
+        handlers.each do |h|
+          next if __node.namespace_scopes.find { |ns| ns.prefix == h.prefix }
+          __node.add_namespace_definition(h.prefix ? h.prefix.to_s : nil, h.href)
+        end
+      end
+
+      #
+      # Set XML namespace
+      #
+      # @param [Nokogiri::XML::Namespace] ns
+      #
+      # @api private
+      #
+      def __set_namespace_definition(ns)
+        __namespace_definitions << ns
+      end
+
+      #
+      # Get namespace definition handlers
+      #
+      # @api private
+      #
+      # @return [XMLable::Handlers::Storage]
+      #
+      def __namespace_definitions
+        @__namespace_definitions ||= self.class.__namespace_definitions.clone
+      end
+
+      module ClassMethods
+        #
+        # Define XML namespace
+        #
+        # @see XMLable::Handlers::Base#build
+        #
+        def namespace(*args)
+          opts = args.last.is_a?(Hash) ? args.pop : {}
+          default = opts.delete(:default) || true
+          h = Handlers::Namespace.new(*args, opts)
+          self.__default_namespace = h.prefix if default
+          __namespace_definitions << h
+        end
+
+        #
+        # Default namespace prefix
+        #
+        # @api private
+        #
+        # @return [Symbol, nil]
+        #
+        def __default_namespace
+          @__default_namespace
+        end
+
+        #
+        # Set default namespace prefix
+        #
+        # @api private
+        #
+        # @param [Symbol, nil]
+        #
+        def __default_namespace=(val)
+          @__default_namespace = val
+        end
+
+        #
+        # Get namespace definition handlers
+        #
+        # @api private
+        #
+        # @return [XMLable::Handlers::Storage]
+        #
+        def __namespace_definitions
+          @__namespace_definitions ||= []
+        end
+      end
+    end
+  end
+end