xmlable 0.0.0.alpha1

data/lib/xmlable/mixins/object.rb

@@ -0,0 +1,95 @@
+module XMLable
+  module Mixins
+    #
+    # Base class contains base item's methods
+    #
+    module Object
+      # @return [Nokogiri::XML::Node]
+      attr_reader :__node
+      # @return [XMLable::Handlers::Base]
+      attr_reader :__handler
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # Initialize
+      #
+      # @param [Nokogiri::XML::Node] node item's XML node
+      # @param [XMLable::Handlers::Base] handler item's handler
+      #
+      def initialize(node, handler)
+        @__node    = node
+        @__handler = handler
+        __inject_node(@__node, @__handler)
+      end
+
+      #
+      # Is this object empty?
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      #
+      def __empty?
+        true
+      end
+
+      #
+      # Does this object have a nested object with given key
+      #
+      # @return [Object, false]
+      #
+      def key?(*)
+        false
+      end
+
+      #
+      # Get nested object
+      #
+      def [](*)
+      end
+
+      #
+      # get nested object value
+      #
+      def []=(*)
+      end
+
+      private
+
+      #
+      # Inject XML node and handler with the curren object
+      #
+      # @param [Nokogiri::XML::Node] node item's XML node
+      # @param [XMLable::Handlers::Base] handler item's handler
+      #
+      # @api private
+      #
+      def __inject_node(node, handler)
+        node.instance_variable_set(:@__handler, handler)
+        node.instance_variable_set(:@__element, self)
+      end
+
+      module ClassMethods
+        #
+        # Get inherited object value if it's set
+        #
+        # @param [String, Symbol] var varibale name
+        #
+        # @return [Object, nil]
+        #
+        def __nested(var)
+          klass = superclass
+          obj = nil
+          loop do
+            obj = klass.instance_variable_get(var)
+            break if obj || !(klass = klass.superclass)
+          end
+          obj ? obj.clone : nil
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/options_storage.rb

@@ -0,0 +1,39 @@
+module XMLable
+  module Mixins
+    #
+    # OptionsStorage modules contains method to manage with addtional options
+    #
+    module OptionsStorage
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        #
+        # Set the export options
+        #
+        def on_export(*args)
+          args.each { |opt| __options.opt_set(opt, true) }
+        end
+
+        #
+        # Set the before export options
+        #
+        def before_export(&block)
+          __options.opt_set(:before_export, block) if block_given?
+        end
+
+        #
+        # Get the options storage
+        #
+        # @api private
+        #
+        # @return [XMLable::Options::Strage]
+        #
+        def __options
+          @__options ||= __nested(:@__options) || Options::Storage.new
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/root_storage.rb

@@ -0,0 +1,162 @@
+module XMLable
+  module Mixins
+    #
+    # RootStorage module contains the logic to manage with XML root element
+    #
+    module RootStorage
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # Set XML root element
+      #
+      # @param [Nokogiri::XML::Element, nil] node
+      #
+      def __set_root(node)
+        unless node.is_a?(Nokogiri::XML::Element)
+          node = Nokogiri::XML::Element.new(__root_handler.tag.to_s, @__node)
+          @__node.root = node
+        end
+        node.instance_variable_set(:@__handler, __root_handler)
+        @root = __root_handler.from_xml_element(node)
+        if __root_handler.namespace_prefix
+          node.namespace = node.namespace_scopes.find do |n|
+            n.prefix == __root_handler.namespace_prefix
+          end
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        return super unless key?(name)
+        return root unless name.to_s.end_with?('=')
+        self.root = args.first
+      end
+
+      #
+      # Is the current object empty?
+      #
+      # @return [Boolean]
+      #
+      def __empty?
+        return false unless super
+        __empty(root)
+      end
+
+      #
+      # Get root object
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def root
+        __set_root(nil) unless instance_variable_defined?(:@root)
+        @root
+      end
+
+      #
+      # Get unwraped root object's value
+      #
+      # @return [Object]
+      #
+      def root!
+        root.__object
+      end
+
+      #
+      # Initialize root object with params
+      #
+      # @param [XMLable::Handlers::Root, XMLable::Handlers::RootNone] h root's handler
+      # @param [Object] value
+      #
+      def __root_object_initialize(h, value)
+        return self.root = value unless value.is_a?(Hash)
+        value.each do |key, val|
+          root[key].__initialize_with(val)
+        end
+      end
+
+      #
+      # Set root object content
+      #
+      # @param [Object] val
+      #
+      def root=(val)
+        @root.__overwrite_content(val)
+      end
+
+      #
+      # Does this object has root object with given key?
+      #
+      # @return [Boolean]
+      #
+      def key?(key)
+        names = ['root', __root_handler.method_name]
+        return __root_handler if names.include?(key.to_s)
+        super
+      end
+
+      #
+      # Get root object by key
+      #
+      # @param [String] key
+      #
+      def [](key)
+        root if key?(key)
+      end
+
+      #
+      # Set root object value
+      #
+      # @param [String] key
+      # @param [Object] val
+      #
+      def []=(key, val)
+        self.root = val if key?(key)
+      end
+
+      #
+      # Cureent root object's handler
+      #
+      # @return [XMLable::Handlers::Root, XMLable::Handlers::RootNone]
+      #
+      def __root_handler
+        self.class.__root_handler
+      end
+
+      module ClassMethods
+        #
+        # Define root handler
+        #
+        # @see XMLable::Handler::Base#build
+        #
+        def root(*args, &block)
+          @__root_handler = Handlers::Root.build(*args, &block)
+          __define_root(@__root_handler)
+        end
+
+        #
+        # Define root object methods
+        #
+        # @param [XMLable::Handlers::Root] h root's handler
+        #
+        def __define_root(h)
+          return if h.method_name == 'root'
+          define_method(h.method_name) { root }
+          define_method("#{h.method_name}=") { |val| self.root = val }
+          define_method("#{h.method_name}!") { root! }
+          define_method("__initialize_#{h.method_name}") { |val| __initialize_root(val) }
+        end
+
+        #
+        # Root object's handler
+        #
+        # @return [XMLable::Handlers::Root, XMLable::Handlers::RootNone]
+        #
+        def __root_handler
+          @__root_handler ||=
+            __nested(:@__root_handler) || Handlers::RootNone.build(:root)
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/standalone_attribute.rb

@@ -0,0 +1,34 @@
+module XMLable
+  module Mixins
+    #
+    # StandaloneAttribute module contains standalone attribute's logic
+    #
+    module StandaloneAttribute
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        #
+        # Describe attribute name/tag
+        #
+        # @param [String, Symbol] tag
+        #
+        def attr_name(tag)
+          @__tag = tag.to_s
+        end
+
+        #
+        # Get attribute name/tag
+        #
+        # @api private
+        #
+        # @return [String]
+        #
+        def __tag
+          @__tag
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/standalone_element.rb

@@ -0,0 +1,47 @@
+module XMLable
+  module Mixins
+    #
+    # StandaloneElement module contains standalone element's logic
+    #
+    module StandaloneElement
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      #
+      # @param [Nokogiri::XML::Element] node XML element
+      # @param [XMLable::Handlers::Document] handler element's handler
+      #
+      def initialize(node = nil, handler = nil)
+        unless node
+          doc = Nokogiri::XML::Document.new
+          node = Nokogiri::XML::Element.new(self.class.__tag, doc)
+        end
+        handler = self.class.__standalone_element_handler unless handler
+        super
+      end
+
+      module ClassMethods
+        #
+        # Describe element's tag name
+        #
+        # @param [String, Symbol] name
+        #
+        def tag(name)
+          @__tag = name.to_s
+        end
+
+        #
+        # Get tag name
+        #
+        # @api private
+        #
+        # @return [String]
+        #
+        def __tag
+          @__tag
+        end
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/value_storage.rb

@@ -0,0 +1,84 @@
+module XMLable
+  module Mixins
+    #
+    # ValueStorage modules contains the logic to manage XML attributes values
+    #
+    module ValueStorage
+      #
+      # Set XML attribute value
+      #
+      # @param [Nokogiri::XML::Attr] node XML attribute node
+      #
+      # @api private
+      #
+      def __set_value(node)
+        self.__value = __cast(node.content)
+      end
+
+      #
+      # Set value
+      #
+      # @api private
+      #
+      # @param [Object] val
+      #
+      def __value=(val)
+        @__value = val
+      end
+
+      #
+      # Overwrite XML attribute's value
+      #
+      # @api private
+      #
+      # @param [Object] val
+      #
+      def __overwrite_value(val)
+        @__node.content = __export_to_xml(val)
+        self.__value = val
+      end
+
+      #
+      # Get unwraped attribute object's value
+      #
+      # @api private
+      #
+      # @return [Object]
+      #
+      def __object
+        __value
+      end
+
+      #
+      #
+      # Get attribute value
+      #
+      # @api private
+      #
+      # @return [Object]
+      #
+      def __value
+        @__value
+      end
+
+      #
+      # Is this element empty?
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      #
+      def __empty?
+        return false unless super
+        __empty(__value)
+      end
+
+      #
+      # @return [String]
+      #
+      def to_s
+        __value.to_s
+      end
+    end
+  end
+end

data/lib/xmlable/mixins/wrapper.rb

@@ -0,0 +1,37 @@
+module XMLable
+  module Mixins
+    #
+    # Wrapper module contains methods to wrap the primitive classes
+    #
+    module Wrapper
+      def method_missing(*args, &block)
+        __object.send(*args, &block)
+      end
+
+      #
+      # @return [String]
+      #
+      def to_s(*args)
+        __object.to_s(*args)
+      end
+
+      #
+      # Is wrapped class inherits from given class?
+      #
+      # @param [Class] klass
+      #
+      # @param [Boolean]
+      #
+      def is_a?(klass)
+        __object.is_a?(klass)
+      end
+
+      #
+      # @return [String]
+      #
+      def inspect
+        "[Wrapper(#{__object.class})] #{__object.inspect}"
+      end
+    end
+  end
+end

data/lib/xmlable/mixins.rb

@@ -0,0 +1,25 @@
+module XMLable
+  #
+  # Mixins module contains object mixins modules
+  #
+  module Mixins
+  end
+end
+
+require_relative 'mixins/object'
+require_relative 'mixins/standalone_element'
+require_relative 'mixins/standalone_attribute'
+require_relative 'mixins/value_storage'
+require_relative 'mixins/elements_storage'
+require_relative 'mixins/attributes_storage'
+require_relative 'mixins/container'
+require_relative 'mixins/content_storage'
+require_relative 'mixins/document_storage'
+require_relative 'mixins/root_storage'
+require_relative 'mixins/options_storage'
+require_relative 'mixins/namespace_definitions_storage'
+require_relative 'mixins/export'
+require_relative 'mixins/bare_value'
+require_relative 'mixins/instantiable'
+require_relative 'mixins/castable'
+require_relative 'mixins/wrapper'

data/lib/xmlable/options/nokogiri_export.rb

@@ -0,0 +1,19 @@
+module XMLable
+  module Options
+    #
+    # NokogiriExport class contains Nokogiri's export settings
+    #
+    # @see http://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/Node/SaveOptions
+    #
+    class NokogiriExport < Hash
+      #
+      # Nokogiri's save_with options
+      #
+      # @return [Nokogiri::XML::Node::SaveOptions.new]
+      #
+      def save_with
+        self[:save_with] ||= Nokogiri::XML::Node::SaveOptions.new
+      end
+    end
+  end
+end

data/lib/xmlable/options/storage.rb

@@ -0,0 +1,97 @@
+module XMLable
+  module Options
+    #
+    # Storage class stores handlers options
+    #
+    class Storage < Hash
+      #
+      # Initialize
+      #
+      # @param [Hash] hash initial params
+      #
+      def new(hash = {})
+        opts_set(hash)
+      end
+
+      #
+      # Set multiple options
+      #
+      # @param [Hash] hash
+      #
+      def opts_set(hash)
+        hash.each { |key, value| opt_set(key, value) }
+      end
+
+      #
+      # Set option
+      #
+      # @param [String, Symbol] key
+      # @param [Object] value
+      #
+      # @return [XMLable::Options::Storage]
+      #
+      def opt_set(key, value)
+        key = key.to_s
+        value = false if key =~ /^no_/
+        key = key.sub(/^no_/, '').to_sym
+        method = "opt_set_#{key}"
+        respond_to?(method) ? send(method, value) : opt_default_set(key, value)
+        self
+      end
+
+      #
+      # Set the drop empty objects
+      #
+      # @param [Boolean]
+      #
+      def opt_set_drop_empty(value)
+        self[:drop_empty_attributes] = self[:drop_empty_elements] = value
+      end
+
+      #
+      # Set the drop undescribed objects
+      #
+      # @param [Boolean]
+      #
+      def opt_set_drop_undescribed(value)
+        self[:drop_undescribed_attributes] = self[:drop_undescribed_elements] = value
+      end
+
+      #
+      # Default option setter
+      #
+      # @param [String, Symbol] key
+      # @param [Object] value
+      #
+      def opt_default_set(key, value)
+        self[key.to_sym] = value
+      end
+
+      %i[undescribed empty].each do |m|
+        %i[attributes elements].each do |e|
+          define_method("drop_#{m}_#{e}?") { fetch(:"drop_#{m}_#{e}", false) }
+        end
+      end
+
+      #
+      # Merge options
+      #
+      # @param [Hash, XMLable::Options::Storage] opts
+      #
+      # @return [XMLable::Options::Storage]
+      #
+      def merge_opts(other)
+        merger = proc do |_, v1, v2|
+          if [v1, v2].all? { |h| h.is_a?(Hash) }
+            v1.merge(v2, &merger)
+          elsif [v1, v2].all? { |h| h.is_a?(Array) }
+            v1 + v2
+          else
+            v2
+          end
+        end
+        merge(other, &merger)
+      end
+    end
+  end
+end

data/lib/xmlable/options.rb

@@ -0,0 +1,9 @@
+module XMLable
+  #
+  # Options module contains the options handlers
+  #
+  module Options
+  end
+end
+require_relative 'options/storage'
+require_relative 'options/nokogiri_export'

data/lib/xmlable/types.rb

@@ -0,0 +1,31 @@
+XMLable::Builder.tap do |b|
+  b.define_type :string, :str, String do
+    cast { |val| val.to_s }
+  end
+
+  b.define_type :integer, :int, Integer do
+    cast { |val| val.to_i }
+    export_to_json { |val| val }
+  end
+
+  b.define_type :float, Float do
+    cast { |val| val.to_f }
+    export_to_json { |val| val }
+  end
+
+
+  b.define_type :date, Date do
+    cast do |val|
+      Date.parse(val) if val.is_a?(String) && !val.empty?
+    end
+    export { |val| val.is_a?(Date) ? val.to_s : val }
+  end
+
+  b.define_type :bool, :boolean do
+    cast do |val|
+      !['false', '0', ''].include?(val.to_s.downcase)
+    end
+
+    export_to_json { |val| val }
+  end
+end

data/lib/xmlable/version.rb

@@ -0,0 +1,4 @@
+module XMLable
+  # @return [String] returns gem version
+  VERSION = '0.0.0.alpha1'
+end