xmlable 0.0.0.alpha1

data/lib/xmlable/handlers/mixins/described.rb

@@ -0,0 +1,19 @@
+module XMLable
+  module Handlers
+    module Mixins
+      #
+      # Described module contains described and null object handlers logic
+      #
+      module Described
+        #
+        # Is this handlers described by user or not?
+        #
+        # @return [Boolean]
+        #
+        def described?
+          !self.class.name.end_with?('None')
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/handlers/mixins/namespace.rb

@@ -0,0 +1,40 @@
+module XMLable
+  module Handlers
+    module Mixins
+      #
+      # Namespace contains
+      #
+      module Namespace
+        #
+        # @see XMLable::Handlers::Base#initialize
+        #
+        def initialize(*args, &block)
+          if args.last.is_a?(Hash)
+            @namespace = args.last.delete(:namespace)
+            @namespace = @namespace.to_s if @namespace
+          end
+          super
+        end
+
+        #
+        # Get handler object namespace
+        #
+        # @return [String, nil]
+        #
+        def namespace_prefix
+          @namespace if @namespace
+        end
+
+        #
+        # Get handler combined key.
+        #   It adds namespace to key if it exists.
+        #
+        # @return [String, nil]
+        #
+        def key
+          [@namespace, @tag].compact.map(&:to_s).join(":")
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/handlers/mixins/tag.rb

@@ -0,0 +1,24 @@
+module XMLable
+  module Handlers
+    module Mixins
+      #
+      # Tag module contains tagable handlers
+      #
+      module Tag
+        # @return [String] returns XML object tag name
+        attr_reader :tag
+
+        #
+        # @see XMLable::Handler::Base#intialize
+        #
+        def initialize(*args, &block)
+          super
+          if args.last.is_a?(Hash)
+            @tag = args.last.delete(:tag)
+            @tag = @tag ? @tag.to_s : @name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/handlers/namespace.rb

@@ -0,0 +1,26 @@
+module XMLable
+  module Handlers
+    #
+    # Namespace handles XML namespace objects
+    #
+    class Namespace
+      # @return [Symbol, nil] returns namespace's prefix
+      attr_reader :prefix
+      # @return [Symbol] returns namespace's URI
+      attr_reader :prefix, :href
+
+      #
+      # @param [Symbol, String, nil] prefix_or_href namespace's URI or prefix
+      # @param [String] href namespace's URI
+      #
+      def initialize(prefix_or_href = nil, href = nil, _opts = {})
+        if prefix.to_s =~ URI.regexp
+          @href = prefix_or_href
+        else
+          @prefix = prefix_or_href
+          @href = href
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/handlers/root.rb

@@ -0,0 +1,9 @@
+module XMLable
+  module Handlers
+    #
+    # Root handles XML root element
+    #
+    class Root < Element
+    end
+  end
+end

data/lib/xmlable/handlers/root_none.rb

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

data/lib/xmlable/handlers/storage.rb

@@ -0,0 +1,104 @@
+module XMLable
+  module Handlers
+    #
+    # Storage stores handlers
+    #
+    class Storage
+      # @return [Array<XMLable::Handlers::Base>]
+      attr_reader :storage
+
+      #
+      # @param [Hash] opts additional options
+      # @option opts [XMLable::Handlers::Base] :default default handler's class
+      # @param [Array] storage initial handlers to store
+      #
+      def initialize(opts = {}, storage = [])
+        @opts = opts
+        @storage = storage
+      end
+
+      #
+      # Find or create handler for the XML node
+      #
+      # @param [XML::Nokogiri::Node] node
+      #
+      # @return [XMLable::Handlers::Base]
+      #
+      def for_xml_object(node)
+        tag = node.name.to_s
+        namespace = node.namespace.prefix if node.namespace
+        namespace = namespace.to_s if namespace
+        handler_with_tag!(tag, namespace: namespace)
+      end
+
+      #
+      # Append new handler to storage
+      #
+      # @note Described handler is always on top of the list
+      #
+      # @param [XMLable::Handler::Base] handler
+      #
+      def <<(handler)
+        @storage << handler
+        @storage = @storage.sort_by { |h| !h.described?.to_s }
+      end
+
+      #
+      # Find handler with given tag
+      #
+      # @param [String] tag element tag name
+      # @param [Hash] opts
+      # @option opts [String, nil] :namespace element namespace
+      #
+      # @return [XMLable::Handlers::Base, nil] returns handler if it's found,
+      #   otherwise return +nil+
+      #
+      def handler_with_tag(tag, opts = {})
+        match = @storage.find { |h| h.tag == tag }
+        return match if !match || !opts.key?(:namespace)
+        return match if opts[:namespace] == false
+        match.namespace_prefix == opts[:namespace] ? match : nil
+      end
+
+      #
+      # Find handler with given tag or create a new one
+      #
+      # @param [String] tag element tag name
+      # @param [Hash] opts
+      # @option opts [String, nil] :namespace element namespace
+      #
+      # @return [XMLable::Handlers::Base]
+      #
+      def handler_with_tag!(tag, opts = {})
+        match = handler_with_tag(tag, opts)
+        return match if match
+        default_handler.build(tag, opts).tap { |h| self << h }
+      end
+
+      #
+      # Clone handlers storage
+      #
+      # @return [XMLable::Handers::Storage]
+      #
+      def clone
+        self.class.new(@opts, storage.clone)
+      end
+
+      #
+      # Default handler class
+      #
+      # @return [XMLable::Handlers::Base] returns null object handler
+      #
+      def default_handler
+        @opts[:default]
+      end
+
+      #
+      # @return [String]
+      #
+      def inspect
+        "#<XMLable::Handlers::Storage #{@storage.map(&:key).join(', ')} >"
+      end
+    end
+  end
+end

data/lib/xmlable/handlers.rb

@@ -0,0 +1,23 @@
+module XMLable
+  #
+  # Handlers module contains the handlers objects
+  #
+  module Handlers
+  end
+end
+
+require_relative 'handlers/mixins/namespace'
+require_relative 'handlers/mixins/described'
+require_relative 'handlers/mixins/tag'
+
+require_relative 'handlers/base'
+require_relative 'handlers/attribute'
+require_relative 'handlers/attribute_none'
+require_relative 'handlers/element'
+require_relative 'handlers/elements'
+require_relative 'handlers/element_none'
+require_relative 'handlers/root'
+require_relative 'handlers/root_none'
+require_relative 'handlers/document'
+require_relative 'handlers/namespace'
+require_relative 'handlers/storage'

data/lib/xmlable/mixins/attributes_storage.rb

@@ -0,0 +1,195 @@
+module XMLable
+  module Mixins
+    #
+    # AttributesStorage module contains the logic for object that able to
+    #   store XML attributes
+    #
+    module AttributesStorage
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # Set XML attribute
+      #
+      # @param [Nokogiri::XML::Attr, nil] att
+      # @param [Hash] opts
+      # @option opts [String] :tag attribute's name
+      # @option opts [String] :namespace attribute's namespace
+      #
+      # @api private
+      #
+      def __set_attribute(att, opts = {})
+        unless att
+          @__node[opts[:tag]] = att
+          att = @__node.attributes[opts[:tag]]
+          if opts[:namespace]
+            att.namespace = att.namespace_scopes.find { |n| n.prefix == opts[:namespace] }
+          end
+        end
+        h = __attributes_handlers.for_xml_object(att)
+        att.instance_variable_set(:@__handler, h)
+        __attributes[h.key] = h.from_xml_attribute(att)
+      end
+
+      #
+      # Attributes which current object holds
+      #
+      # @api private
+      #
+      # @return [Hash(String => Array<XMLable::Mixins::Object>)]
+      #
+      def __attributes
+        @__attributes ||= {}
+      end
+
+      #
+      # Is this object empty?
+      #
+      # @api private
+      #
+      # @return [Hash(String => Array<XMLable::Mixins::Object>)]
+      #
+      def __empty?
+        return false unless super
+        __attributes.values.all?(&:__empty?)
+      end
+
+      def method_missing(name, *args, &block)
+        h = __has_attribute_handler?(name)
+        return super unless h
+
+        if name.to_s.end_with?('=')
+          __attribute_object_set(h, args.first)
+        else
+          __attribute_object_get(h)
+        end
+      end
+
+      #
+      # Does this object contain attribute with given key?
+      #
+      # @return [XMLable::Mixins::Object, false]
+      #
+      def key?(key)
+        super || __has_attribute_handler?(key)
+      end
+
+      #
+      # Get attribute object by its key
+      #
+      # @param [String] key attribute key
+      #
+      # @return [XMLable::Mixins::Object, nil]
+      #
+      def [](key)
+        h = __has_attribute_handler?(key)
+        h ? __attribute_object_get(h) : super
+      end
+
+      #
+      # Set attribute value
+      #
+      # @param [String] key attribute key
+      # @param [Object] val new value
+      #
+      # @return [XMLable::Mixins::Object, nil]
+      #
+      def []=(key, val)
+        h = __has_attribute_handler?(key)
+        h ? __attribute_object_set(h, val) : super
+      end
+
+      #
+      # Find attribute handler by its key
+      #
+      # @param [Symbol, String] key
+      #
+      # @api private
+      #
+      # @return [XMLable::Handlers::Attribute, XMLable::Handlers::AttributeNone, nil]
+      #
+      def __has_attribute_handler?(key)
+        key = key.to_s.gsub(/[=!]$/, '')
+        __attributes_handlers.storage.find { |h| h.method_name == key }
+      end
+
+      #
+      # Get attribute object
+      #
+      # @param [XMLable::Handlers::Attribute, XMLable::Handlers::AttributeNone] h
+      #
+      # @api private
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def __attribute_object_get(h)
+        unless __attributes.key?(h.key)
+          __set_attribute(nil, tag: h.tag, namespace: h.namespace_prefix)
+        end
+        __attributes[h.key]
+      end
+
+      #
+      # Set attribute object value
+      #
+      # @param [XMLable::Handlers::Attribute, XMLable::Handlers::AttributeNone, nil] h
+      # @param [Object] val new value
+      #
+      # @api private
+      #
+      def __attribute_object_set(h, val)
+        __attribute_object_get(h).__overwrite_value(val)
+      end
+
+      #
+      # Initialize attribute object with value
+      #
+      # @param [XMLable::Handlers::Attribute, XMLable::Handlers::AttributeNone, nil] h
+      # @param [Object] val
+      #
+      # @api private
+      #
+      def __attribute_object_initialize(h, value)
+        __attribute_object_get(h).__overwrite_value(value)
+      end
+
+      #
+      # Attributes handlers storage
+      #
+      # @return [XMLable::Handlers::Storage]
+      #
+      def __attributes_handlers
+        @__attributes_handler ||= self.class.__attributes_handlers.clone
+      end
+
+      module ClassMethods
+        #
+        # Attributes handlers storage
+        #
+        # @return [XMLable::Handlers::Storage]
+        #
+        def __attributes_handlers
+          @__attributes_handlers ||=
+            __nested(:@__attributes_handlers) || Handlers::Storage.new(default: Handlers::AttributeNone)
+        end
+
+        #
+        # Describe object attribute
+        #
+        # @see XMLable::Handler::Base#build
+        #
+        # @return [XMLable::Handlers::Storage]
+        #
+        def attribute(*args, &block)
+          opts = args.last.is_a?(Hash) ? args.pop : {}
+          if __default_namespace && !opts.key?(:namespace)
+            opts[:namespace] = __default_namespace
+          end
+          h = Handlers::Attribute.build(*args, opts, &block)
+          __attributes_handlers << h
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/bare_value.rb

@@ -0,0 +1,41 @@
+module XMLable
+  module Mixins
+    #
+    # BareValue contains logic to get the bare value.
+    #   All XML object such as Integer, Date, String, etc are wrapped with the
+    #   proxy classes. This module helps to unwrap the real value.
+    #
+    module BareValue
+      def method_missing(name, *args, &block)
+        return super unless name.to_s =~ /!$/
+        return super unless key?(name)
+        name = name.to_s.gsub(/!$/,'').to_sym
+        __extract_bare_value(super)
+      end
+
+      #
+      # Get object value
+      #   It unwraps the object value if object key ends with '!' symbol.
+      #
+      # @return [XMLable::Mixins::Object, Object, nil]
+      #
+      def [](key)
+        return super unless key.to_s =~ /!$/
+        __extract_bare_value(super)
+      end
+
+      #
+      # Unwrap objects
+      #
+      # @param [XMLable::Mixins::Object, Array<XMLable::Mixins::Object>] obj
+      #
+      # @api private
+      #
+      # @return [Object, Array<Object>]
+      #
+      def __extract_bare_value(obj)
+        obj.respond_to?(:map) ?  obj.map(&:__object) : obj.__object
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/castable.rb

@@ -0,0 +1,93 @@
+module XMLable
+  module Mixins
+    #
+    # Castable module contains the logic that helps to cast values from
+    #   different forms to XML/JSON and back.
+    #
+    module Castable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # Cast object from XML value
+      #
+      # @param [String] val
+      #
+      # @api private
+      #
+      # @return [Object]
+      #
+      def __cast(val)
+        val
+      end
+
+      #
+      # Export value to XML/JSON
+      #
+      # @param [Object] val
+      #
+      # @api private
+      #
+      # @return [Object]
+      #
+      def __export(val)
+        val.to_s
+      end
+
+      #
+      # Export value to XML
+      #
+      # @param [Object] val
+      #
+      # @api private
+      #
+      # @return [String]
+      #
+      def __export_to_xml(val)
+        __export(val).to_s
+      end
+
+      #
+      # Export value to JSON
+      #
+      # @param [Object] val
+      #
+      # @api private
+      #
+      # @return [Object]
+      #
+      def __export_to_json(val)
+        __export(val).to_s
+      end
+
+      #
+      # Is this object empty?
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      #
+      def __empty(val)
+        val.respond_to?(:empty?) && val.empty? ||
+          val.is_a?(String) && val == '' ||
+          val.nil?
+      end
+
+      module ClassMethods
+        # @return [Array<Symbol>] retuns list of the setup methods
+        CAST_METHODS = %i[cast export export_to_json export_to_xml empty]
+
+        #
+        # Override method missing to get the setup methods be available
+        #
+        # @see XMLable::Mixins::Castable::ClassMethods::CAST_METHODS
+        #
+        def method_missing(name, *args, &block)
+          return super unless CAST_METHODS.include?(name)
+          define_method("__#{name}", &block) if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/container.rb

@@ -0,0 +1,71 @@
+module XMLable
+  module Mixins
+    #
+    # Container module contains the logic for the XML objects groups
+    #
+    module Container
+      # @return [XMLable::Handlers::Elements]
+      attr_reader :__handler
+
+      #
+      # Create new element
+      #
+      # @param [Object] args element initial params
+      #
+      # @return [XMLable::Mixins::Object] returns created element
+      #
+      def new(args = nil)
+        xml = Nokogiri::XML::Element.new(@__handler.tag.to_s, @__parent_node)
+        el = @__handler.from_xml_element(xml)
+        el.__initialize_with(args) if args
+        @__parent_node << xml
+        self << el
+        el
+      end
+
+      #
+      # Set current object handler
+      #
+      # @param [XMLable::Handlers::Elements] handler
+      #
+      # @api private
+      #
+      def __set_handler(handler)
+        @__handler = handler
+      end
+
+      #
+      # Parent XML node
+      #
+      # @api private
+      #
+      # @param [Nokogiri::XML::Node]
+      #
+      def __set_parent_node(node)
+        @__parent_node = node
+      end
+
+      #
+      # Initialize container with params
+      #
+      # @api private
+      #
+      # @param [Array<Object>] val
+      #
+      def __initialize_with(val)
+        val.each { |v| new(v) }
+      end
+
+      #
+      # Does this container contain only empty objects?
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      #
+      def __empty?
+        all?(&:__empty?)
+      end
+    end
+  end
+end