xmlable 0.0.0.alpha1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8dac25c2580eed75d306634e799b8dc03d104da5
+  data.tar.gz: f764b71e734d47c4505e89c4b065ac5ba03b743a
+SHA512:
+  metadata.gz: 27a75c87ddd0b08449cd2e0e1da18885aec9b3dbfe113b1cfc6236d1e8e3afd23676aafabcae610eeac48b2525811ab1723c10c3b35e763c446b71e6bee8a4f3
+  data.tar.gz: 0203c91ea3564b0ee5d590bbc5f6ad38785e3943046a30c88e0c131105ca2e94b942bbd0ae6eaa5d25ecd8e854aef074ffbe33942c04952d91522ef18208ceed

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Oleg Yashchuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,245 @@
+# XMLable
+[![Build Status](https://travis-ci.org/zoer/lexer.svg)](https://travis-ci.org/zoer/lexer)
+[![Code Climate](https://codeclimate.com/github/zoer/xmlable/badges/gpa.svg)](https://codeclimate.com/github/zoer/xmlable)
+[![Version Eye](https://www.versioneye.com/ruby/xmlable/badge.png)](https://www.versioneye.com/ruby/xmlable)
+[![Inline docs](http://inch-ci.org/github/zoer/xmlable.png)](http://inch-ci.org/github/zoer/xmlable)
+[![Gem Version](https://badge.fury.io/rb/xmlable.svg)](http://badge.fury.io/rb/xmlable)
+
+XMLable provides an ability to convert XML to Ruby object and back.
+
+This probject is in active development and isn't ready for production yet.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'xmlable'
+```
+
+## Examples
+
+### Basic usage
+```ruby
+# Describe XML structure
+class Catalog
+  include XMLable::Document
+
+  root :catalog do
+    attribute :date, Date
+    element :size, Integer
+    elements :items, tag: 'item' do
+      attribute :position, Integer
+      element :title
+      element :desc, tag: 'description'
+      element :amount, Integer
+    end
+  end
+end
+
+xml = <<-XML
+<?xml version="1.0"?>
+<catalog date="2014-12-20">
+  <size>10</size>
+  <item position="1">
+    <title>Sumac Shoes</title>
+    <description>Capture the beauty</description>
+    <amount>3</amount>
+  </item>
+  <item position="2">
+    <title>Channing Oxford Shoes</title>
+    <description>Hand finished with a wash of color</description>
+  </item>
+</catalog>
+XML
+
+doc = Catalog.from_xml(xml)
+doc.catalog.date # => #<Date: 2014-12-20 ((2457012j,0s,0n),+0s,2299161j)>
+doc.catalog.size # => 10
+doc.catalog.items.size # => 2
+doc.catalog.items[0].title # => "Sumac Shoes"
+doc.catalog.items[0].desc # => "Capture the beauty"
+doc.catalog.items[0].amount # => 3
+doc.catalog.items[0].position # => 1
+
+doc.to_json
+#{
+#  "catalog": {
+#    "date": "2014-12-20",
+#    "size": 10,
+#    "items": [
+#      { "title": "Sumac Shoes", "desc": "Capture the beauty", "amount": 3, "position": 1 },
+#      { "title": "Channing Oxford Shoes", "desc": "Hand finished with a wash of color", "position": 2 }
+#    ]
+#  }
+#}
+
+json = {
+  catalog: {
+    date: "2014-12-20",
+    size: 10,
+    items: [
+      { title: "Sumac Shoes", desc: "Capture the beauty", amount: 3, position: 1 },
+      { title: "Channing Oxford Shoes", desc: "Hand finished with a wash of color", position: 2 }
+    ]
+  }
+}
+
+# Initialize with JSON
+doc = Catalog.new(json)
+doc.catalog.date # => #<Date: 2014-12-20 ((2457012j,0s,0n),+0s,2299161j)>
+doc.catalog.size # => 10
+doc.catalog.items.size # => 2
+doc.catalog.items[0].title # => "Sumac Shoes"
+doc.catalog.items[0].desc # => "Capture the beauty"
+doc.catalog.items[0].amount # => 3
+doc.catalog.items[0].position # => 1
+
+# By default all elements and attribute values are proxied. If you for some
+# reason need to get real value just use the exclamation mark.
+doc.catalog.date! # => #<Date: 2014-12-20 ((2457012j,0s,0n),+0s,2299161j)>
+
+doc.to_xml
+#<?xml version="1.0"?>
+#<catalog date="2014-12-20">
+#  <size>10</size>
+#  <item position="1">
+#    <title>Sumac Shoes</title>
+#    <description>Capture the beauty</description>
+#    <amount>3</amount>
+#  </item>
+#  <item position="2">
+#    <title>Channing Oxford Shoes</title>
+#    <description>Hand finished with a wash of color</description>
+#  </item>
+#</catalog>
+```
+
+### XML with namespaces
+```ruby
+xml = <<-XML
+<?xml version="1.0"?>
+<d:student xmlns="http://example.com" xmlns:d="http://foo.com/student" d:id="11">
+  <d:name d:position="2">Jeff Smith</d:name>
+  <info>
+    <city number="7">Beijing</city>
+  </info>
+</d:student>
+XML
+
+class Student
+  include XMLable::Document
+
+  root :student, namespace: 'd' do
+    namespace nil, 'http://example.com'
+    # the last defined namespace will be set as default for the all following
+    # and nested elements and attributes. If you need to overwrite namespace
+    # just pass namespace: 'prefix' (see the root definition above).
+    namespace :d, 'http://foo.com/student'
+
+    attribute :id, :int
+
+    element :name do
+      attribute :position, :int
+      # You can describe content method of element which has also attributes
+      # besides the content. By default content if present will be exported into JSON with
+      # '__content' key. You can pase 'false' instead of name to ignore it.
+      content :fullname
+    end
+
+    # If namespace setting is passed it will be set as default for the all
+    # nested element and attributes.
+    element :info, namespace: nil do
+      element :city do
+        attribute :number, Integer
+        content :name
+      end
+    end
+  end
+end
+
+student = Student.from_xml(xml)
+student.to_json
+#{
+#  "student": {
+#    "id": 11,
+#    "name": {
+#      "fullname": "Jeff Smith",
+#      "position": 2
+#    },
+#    "info": {
+#      "city": {
+#        "name": "Beijing",
+#        "number": 7
+#      }
+#    }
+#  }
+#}
+
+# Back direction
+other = Student.new(student.to_h)
+
+other.to_xml
+#<?xml version="1.0"?>
+#<d:student xmlns="http://example.com" xmlns:d="http://foo.com/student" d:id="11">
+#  <d:name d:position="2">Jeff Smith</d:name>
+#  <info>
+#    <city number="7">Beijing</city>
+#  </info>
+#</d:student>
+```
+
+### Undescribed document
+It's also possible to load undescribed XML. In this case each XML element(not
+attribute) will be represented as an array, so you have to use indexes to
+access element values.
+```ruby
+xml = <<-XML
+<?xml version="1.0"?>
+<item id="11">
+  <name position="2">Bolt</name>
+  <info>
+    <color>Silver</color>
+  </info>
+</item>
+XML
+
+class Item
+  include XMLable::Document
+end
+
+item = Item.from_xml(xml)
+
+item.root.id # => "11"
+item.root.name[0].position # => "2"
+item.root.name[0] # => "Bolt"
+item.root.info[0].color[0] # => "Silver"
+
+item.to_h
+#{
+#  "item": {
+#    "id": "11"
+#    "name": [{"position": 2", "__content": "Bolt"}]
+#    "info": [{ "color": ["Silver"]}]
+#  }
+#}
+
+item.to_xml
+#<?xml version="1.0"?>
+#<item id="11">
+#  <name position="2">Bolt</name>
+#  <info>
+#    <color>Silver</color>
+#  </info>
+#</item>
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zoer/xmlable.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/lib/xmlable/attribute.rb

@@ -0,0 +1,16 @@
+module XMLable
+  #
+  # Attribute module contains logic for standalone attribute object
+  #
+  module Attribute
+    def self.included(base)
+      base.include Mixins::Object
+      base.include Mixins::Castable
+      base.include Mixins::ValueStorage
+      base.include Mixins::StandaloneAttribute
+      base.include Mixins::OptionsStorage
+      base.include Mixins::BareValue
+      base.include Mixins::Instantiable
+    end
+  end
+end

data/lib/xmlable/builder.rb

@@ -0,0 +1,189 @@
+module XMLable
+  #
+  # Builder class builds object that represents XML attribute and values
+  #
+  class Builder
+    include Singleton
+
+    class << self
+      #
+      # Build document object from XML document
+      #
+      # @param [Nokogiri::XML::Document] document
+      # @param [XMLable::Handlers::Document] handler
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def build_document(document, handler)
+        obj = handler.proxy.new({}, document, handler)
+        populate_document(obj, document)
+      end
+
+      #
+      # Build attribute object from XML attribute
+      #
+      # @param [Nogogiri::XML::Attribute] attribute
+      # @param [XMLable::Handlers::Base] handler
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def build_attribute(attribute, handler)
+        obj = handler.proxy.new({}, attribute, handler)
+        populate_attribute(obj, attribute)
+      end
+
+      #
+      # Build element object from XML element
+      #
+      # @param [Nogogiri::XML::Element] node
+      # @param [XMLable::Handlers::Base] handler
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def build_element(node, handler)
+        obj = handler.proxy.new({}, node, handler)
+        populate_element(obj, node)
+      end
+
+      #
+      # Populate document object
+      #
+      # @param [XMLable::Mixins::Object] obj
+      # @param [Nogogiri::XML::Document] node
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def populate_document(obj, node)
+        obj.__set_root(node.root)
+        obj
+      end
+
+      #
+      # Populate element object
+      #
+      # @param [XMLable::Mixins::Object] obj
+      # @param [Nogogiri::XML::Element] node
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def populate_element(obj, node)
+        node.namespace_definitions.each { |ns| obj.__set_namespace_definition(ns) }
+        node.elements.each { |el| obj.__set_element(el) }
+        node.attributes.each { |_, att| obj.__set_attribute(att) }
+        obj.__set_content(node)
+        obj
+      end
+
+      #
+      # Populate attribute object
+      #
+      # @param [XMLable::Mixins::Object] obj
+      # @param [Nogogiri::XML::Attr] node
+      #
+      # @return [XMLable::Mixins::Object]
+      #
+      def populate_attribute(obj, node)
+        obj.tap { |o| o.__set_value(node) }
+      end
+
+      #
+      # Find defined type
+      #
+      # @param [Object] type
+      #
+      # @return [Class] returns found type or define new one if it's not found
+      #
+      def find_type(type)
+        type = type.to_s if type.is_a?(Symbol)
+        klass = instance.defined_types[type]
+        klass ? klass : define_type(type)
+      end
+
+      #
+      # Wrap type with additional logic
+      #
+      # @param [Class] klass
+      #
+      # @return [Class] returns wrapped class
+      #
+      def wrap_type(klass, &block)
+        Class.new do
+          include Mixins::Object
+          include Mixins::Wrapper
+          include Mixins::Castable
+          include Mixins::OptionsStorage
+          class_eval(&block) if block_given?
+        end
+      end
+
+      #
+      # Inherit type and set additional settings
+      #
+      # @param [Class] klass
+      #
+      # @return [Class] returns wrapped class
+      #
+      def inherit_type(klass, &block)
+        Class.new(klass) do
+          class_eval(&block) if block_given?
+        end
+      end
+
+      #
+      # Define new type
+      #
+      # @param [Array<Object>] names type's names(aliases)
+      #
+      # @return [Class]
+      #
+      def define_type(*names, &block)
+        names = names.map { |n| n.is_a?(Symbol) ? n.to_s : n }
+        main = names.first
+        klass = wrapped_type?(main) ? wrap_type(main, &block) : inherit_type(main, &block)
+        names.each { |n| instance.defined_types[n] = klass }
+        klass
+      end
+
+      #
+      # Is the given class wrapped?
+      #
+      # @return [Boolean]
+      #
+      def wrapped_type?(klass)
+        return true  if !klass.is_a?(Class)
+        return false if klass.ancestors.include?(Mixins::StandaloneElement)
+        return false if klass.ancestors.include?(Mixins::StandaloneAttribute)
+        true
+      end
+
+      #
+      # Get proxy for the given type
+      #
+      # @param [Object] type type's name
+      #
+      # @return [Class] returns type's proxy class
+      #
+      def proxy_for(type)
+        find_type(type).dup
+      end
+
+      #
+      # Get container proxy for the given class
+      #
+      # @param [Class] klass
+      #
+      # @return [Class]
+      #
+      def container_proxy_for(klass)
+        Class.new(klass) { include Mixins::Container }
+      end
+    end
+
+    # @return [Hash]
+    attr_reader :defined_types
+
+    def initialize
+      @defined_types = {}
+    end
+  end
+end

data/lib/xmlable/document.rb

@@ -0,0 +1,16 @@
+module XMLable
+  #
+  # Document module contains logic for XML document object
+  #
+  module Document
+    def self.included(base)
+      base.include Mixins::Object
+      base.include Mixins::Export
+      base.include Mixins::OptionsStorage
+      base.include Mixins::Instantiable
+      base.include Mixins::Castable
+      base.include Mixins::DocumentStorage
+      base.include Mixins::RootStorage
+    end
+  end
+end

data/lib/xmlable/element.rb

@@ -0,0 +1,19 @@
+module XMLable
+  #
+  # Element module contains logic for standalone element object
+  #
+  module Element
+    def self.included(base)
+      base.include Mixins::Object
+      base.include Mixins::Castable
+      base.include Mixins::ElementsStorage
+      base.include Mixins::AttributesStorage
+      base.include Mixins::ContentStorage
+      base.include Mixins::StandaloneElement
+      base.include Mixins::OptionsStorage
+      base.include Mixins::NamespaceDefinitionsStorage
+      base.include Mixins::BareValue
+      base.include Mixins::Instantiable
+    end
+  end
+end

data/lib/xmlable/exports/base.rb

@@ -0,0 +1,78 @@
+module XMLable
+  module Exports
+    #
+    # Base class contains the base export logic
+    #
+    class Base
+      #
+      # Initialize
+      #
+      # @param [XMLable::Mixins::Object] element
+      # @param [Hash] opts
+      #
+      def initialize(element, opts = {})
+        @element = element
+        @opts = opts
+      end
+
+      #
+      # Is this object empty?
+      #
+      # @param [Nokogiri::XML::Node] node
+      #
+      # @return [Boolean]
+      #
+      def empty?(node)
+        node.instance_variable_get(:@__element).__empty?
+      end
+
+      #
+      # Is the object described by user?
+      #
+      # @param [Nokogiri::XML::Node] node
+      #
+      # @return [Boolean]
+      #
+      def described?(node)
+        node.instance_variable_get(:@__handler).described?
+      end
+
+      #
+      # Get node's nested options
+      #
+      # @param [Nokogiri::XML::Node] node
+      #
+      # @return [XMLable::Options::Storage]
+      #
+      def node_nested_options(node)
+        return Options::Storage.new unless node
+        parent = node.respond_to?(:parent) ? node.parent : nil
+        node_nested_options(parent).merge_opts(node_options(node))
+      end
+
+      #
+      # Get node's options
+      #
+      # @param [Nokogiri::XML::Node] node
+      #
+      # @return [XMLable::Options::Storage]
+      #
+      def node_options(node)
+        h = node.instance_variable_get(:@__handler)
+        h && h.options? ? h.options : Options::Storage.new
+      end
+
+      #
+      # Merge node's options
+      #
+      # @param [Nokogiri::XML::Node] node
+      # @param [XMLable::Options::Storage] opts
+      #
+      # @return [XMLable::Options::Storage]
+      #
+      def node_merged_opts(node, opts = Options::Storage.new)
+        opts.merge_opts(node_options(node))
+      end
+    end
+  end
+end