body_party 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0a12945e49641b602d97e1bf92abfa81a166ee804c56b639919d76616f7e2abf
+  data.tar.gz: dcacbde51918ea152544024f82decbb3accb8e865a862c10dc4e08d6ccb3b7c9
+SHA512:
+  metadata.gz: 4e7a2416b3bcfa2da82278d515537c74792827f937074ce5851eb88c651e12dcf8daa750f2f95b69eb6a012c6cbb2bf89ae6cde6152c943996c88e683f861cfb
+  data.tar.gz: 4dfa60179cf4fd825a8eb3c490d925b913bfbb32a60b2ce13625710682d308d5434c5bf04f921c3f8d4cb69d82cbc2de45c45728abb7b9517123555204ebb84b

data/lib/body_party.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'ox'
+
+require 'xpath_parser'
+require 'xpath_element'
+require 'document'
+require 'node'
+require 'hash_parser'

data/lib/document.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module BodyParty
+  class Document
+    attr_accessor :xpaths, :doc, :type
+
+    def initialize(**args)
+      @xpaths = args.fetch(:xpaths)
+      @type = args.fetch(:type, :xml)
+      @doc = build_doc
+    end
+
+    def generate!
+      xpaths.each do |xpath|
+        xpath_parser = BodyParty::XpathParser.new(xpath)
+        node = create_node_from_xpath(xpath_parser)
+        doc << node unless doc.nodes.any? { |n| node.equal?(n) }
+      end
+      ox = Ox.dump(doc)
+      if type == :hash
+        StringIO.new(ox)
+        parser = HashParser.new
+        Ox.sax_parse(parser, ox)
+        parser.to_h
+      elsif type == :xml
+        ox
+      end
+    end
+
+    def create_node_from_xpath(xpath)
+      root_node = find_or_create_root_node(xpath.root)
+
+      create_child_nodes(root_node, xpath.childrens)
+      root_node
+    end
+
+    # Find last possible parent within the childrens
+    def find_last_child(parent, childrens)
+      return parent if childrens.empty?
+
+      return parent if childrens.count == 1 # Last child will the one to be created
+
+      child_element = childrens.shift
+
+      child = locate_child(parent, child_element)
+
+      if child.nil?
+        childrens.unshift(child_element)
+        return parent
+      end
+
+      find_last_child(child, childrens)
+    end
+
+    def create_child_nodes(root, childrens)
+      return root if childrens.empty?
+
+      root = find_last_child(root, childrens)
+
+      if childrens.count <= 1
+        return root if childrens.empty?
+
+        last_node_name = childrens.shift
+        child = create_node(last_node_name)
+        root << child
+        return root
+      end
+
+      child_name = childrens.shift
+      child = create_node(child_name)
+
+      root << create_child_nodes(child, childrens)
+    end
+
+    def locate_child(parent, child)
+      child_attributes = child.attributes
+      child_name = child.name
+
+      return parent.locate(child_name).first if child_attributes.empty?
+
+      formatted_child_attributes =
+        child_attributes.map { |attr, value| "#{child_name}[@#{attr}=#{value}]" }
+      formatted_child_attributes.all? do |attr|
+        child = parent.locate(attr).last
+        return nil if child.nil?
+        return child if child&.attributes&.transform_keys(&:to_s).to_a == child_attributes
+      end
+    end
+
+    def find_or_create_root_node(xpath)
+      locate_child(doc, xpath) || create_node(xpath)
+    end
+
+    def create_node(element)
+      Node.new(element).node
+    end
+
+    def self.generate(**args)
+      types = %i[hash xml]
+      type = args.fetch(:type, :xml)
+      raise 'Format should be etiher :hash or :xml' unless types.include?(type)
+
+      xpaths = args.fetch(:xpaths)
+      new(xpaths: xpaths, type: type).generate!
+    end
+
+    def build_doc
+      doc = Ox::Document.new
+      instruct = Ox::Instruct.new(:xml)
+
+      instruct[:version] = '1.0'
+      instruct[:encoding] = 'UTF-8'
+      doc << instruct
+      doc
+    end
+  end
+end

data/lib/hash_parser.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Thanks to https://github.com/xkwd/oxml
+
+class HashParser < ::Ox::Sax
+  EMPTY_STR = ''
+  TRUE_STR = 'true'
+  FALSE_STR = 'false'
+  DATE_TIME = /^-?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/
+  DATE = /^-?\d{4}-\d{2}-\d{2}(?:Z|[+-]\d{2}:?\d{2})?$/
+  TIME = /^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/
+
+  def initialize(options = {})
+    @memo = {}
+    @arr = []
+    @map = {}
+    @name = nil
+    @last_attr = nil
+    @delete_namespace_attributes = options.fetch(:delete_namespace_attributes, false)
+    @advanced_typecasting = options.fetch(:advanced_typecasting, false)
+  end
+
+  def to_h
+    @memo.to_h
+  end
+
+  def attr(name, str)
+    @last_attr = "#{name}:#{str}"
+    return if @delete_namespace_attributes
+
+    return if name == :version
+    return if name == :encoding
+
+    start_element(name)
+    text(str)
+    end_element(name)
+  end
+
+  def start_element(name)
+    @arr.push(@memo)
+
+    @name = @map[name] ||= name
+
+    @memo = {}
+    text(@memo)
+  end
+
+  def attrs_done
+    return unless @last_attr =~ /nil:true/
+
+    @last_attr = nil
+    @arr.last[@name] = nil
+  end
+
+  def end_element(_name)
+    @memo = @arr.pop
+  end
+
+  def text(value)
+    if @arr.last[@name].is_a?(Array)
+      @arr.last[@name].pop unless value == @memo
+      @arr.last[@name] << cast(value)
+    elsif @arr.last[@name] && value == @memo
+      @arr.last[@name] = [@arr.last[@name], value]
+    else
+      @arr.last[@name] = cast(value)
+    end
+  end
+
+  private
+
+  def cast(value)
+    return if value == EMPTY_STR
+    return value unless @advanced_typecasting
+
+    case value
+    when EMPTY_STR then nil
+    when TRUE_STR then true
+    when FALSE_STR then false
+    when DATE_TIME then DateTime.parse(value)
+    when DATE then Date.parse(value)
+    when TIME then Time.parse(value)
+    else value
+    end
+  end
+end

data/lib/node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module BodyParty
+  Node = Struct.new(:xpath_element) do
+    attr_accessor :node
+
+    def initialize(xpath_element)
+      raise ArgumentError, "xpath_element can't be nil" if xpath_element.nil?
+
+      self.xpath_element = xpath_element
+      self.node = ox_node
+    end
+
+    def ox_node
+      node = Ox::Element.new(xpath_element.name)
+      node << xpath_element.value if xpath_element.value
+
+      xpath_element.attributes.each { |attr, value| node[attr.to_sym] = value }
+      node
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1 @@
+VERSION = "0.0.1.pre"

data/lib/xpath_element.rb

@@ -0,0 +1,24 @@
+module BodyParty
+  class XpathElement
+    attr_accessor :element, :value
+
+    def initialize(element)
+      @element = element
+    end
+    def name
+      element.split(/\[|\?=/).first
+    end
+
+    def value
+      return '' unless element.include?('?=')
+
+      @value ||= element.split('?=').last
+    end
+
+    def attributes
+      return [] if element.nil?
+
+      element.scan(/@(\w+)=([^\s\]]+)/)
+    end
+  end
+end

data/lib/xpath_parser.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BodyParty
+  class XpathParser
+    attr_accessor :xpath
+
+    def initialize(xpath)
+      raise ArgumentError, "XPath shoudn't start with /" if xpath.start_with?('/')
+      @xpath = xpath
+    end
+
+    def nodes
+      @nodes ||= xpath.split('/').map { |element| XpathElement.new(element) }
+    end
+
+    def childrens
+      nodes[1..]
+    end
+
+    def root
+      nodes.first
+    end
+
+    # Each Xpath has one value
+    def value
+      nodes.last.value
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: body_party
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: ruby
+authors:
+- Anas Tammam
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+description: It's easier to generate XML or Hash using xpaths as string
+email: anas.jber@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/body_party.rb
+- lib/document.rb
+- lib/hash_parser.rb
+- lib/node.rb
+- lib/version.rb
+- lib/xpath_element.rb
+- lib/xpath_parser.rb
+homepage: https://github.com/anastammam/body_party
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Convert XPath-like notation into structured XML or Hash formats
+test_files: []