roundtrip_xml 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5849fafbc85b77e0d69f8e666fb448c2ad1e4587
-  data.tar.gz: ebbb32cf50068e62bf885db90bf2f1e511dc1615
+  metadata.gz: b5d0171291e731011fc69e726421dc68b3ceb039
+  data.tar.gz: 1aaaa7152a29b616cbfd7e43b003ccf1b625ffa9
 SHA512:
-  metadata.gz: e64a54d09659d4954280f0ebd543162a8d53369840b882fcf789aff98aead6b5e3027c53622f39dcc6622b8534d3790d6bd7e9678e132ecfca543a456e212d19
-  data.tar.gz: bafb364f19e5f0c248feac36ea2a49732124b92057c3e4289995a35fd0cb965db82978d450ef3958308a38d66772cfbe339d164fc9a1d1eb6264e09d29264ed6
+  metadata.gz: de71838561d98d183d2e83b2a0311cd3db0c66f89911771ba8ea90a954b9d9ad7d6aa97e14cfd8b5aac6a78a4f5f34c13b56e7825aebac5496f866c63fb6a42a
+  data.tar.gz: bf4e7a4d49cccafad9ec1c21a4953bd9ccc9dd7b5eca652b8cdb65daecc0b04deafbcf3b5aa18000fa7342c0dc2babcf28a33ab45db1bfc6685471de0f5e24b3

data/lib/roundtrip_xml.rb

@@ -4,3 +4,7 @@ require './lib/roundtrip_xml/base_cleanroom'
 require './lib/roundtrip_xml/root_cleanroom'
 require './lib/roundtrip_xml/roxml_builder'
 require './lib/roundtrip_xml/plain_accessors'
+require './lib/roundtrip_xml/utils'
+require './lib/roundtrip_xml/extractor'
+require './lib/roundtrip_xml/roxml_subclass_helpers'
+require './lib/roundtrip_xml/sexp_dsl_builder'

data/lib/roundtrip_xml/base_cleanroom.rb

@@ -53,27 +53,20 @@ class BaseCleanroom
     plain_accessors = @el.class.plain_accessors
     hash = {}
     @value_holder ||= {}
-    if plain_accessors != 0
-      hash = plain_accessors.inject({}) {|h, a| h[a] = @el.send(a); h}
-    end
+    hash = plain_accessors.inject({}) {|h, a| h[a] = @el.send(a); h}
     child = @runtime.create_cleanroom(clazz)
     child.inherit_properties @value_holder.merge(hash)
-    # child.inherit_properties(@args, @value_holder) if instance_variable_defined?(:@args)
+
     child.evaluate &block
     child.evaluate &child.get_el.process if child.get_el.respond_to? :process
-    # evaluate the ROXML object's proc, which further modifies the element
-    # child.evaluate &child.get_el.class.proc if child.respond_to? :proc
+
     child.get_el
   end
 
   def inherit_properties(props)
     @value_holder = props
     props.each do |name, val|
-      # @value_holder.class.send(:attr_accessor, arg)
-      # @value_holder.send("#{arg}=".to_sym, value_holder.send(arg))
-      # create_method(arg) do
-      #   @value_holder.send(arg)
-      # end
+
       self.class.send(:attr_reader, name)
       self.instance_variable_set("@#{name}".to_sym, val)
       self.class.send(:expose, name)

data/lib/roundtrip_xml/dsl_runtime.rb

@@ -3,26 +3,44 @@ require 'nokogiri'
 require 'roundtrip_xml/roxml_builder'
 require 'roundtrip_xml/root_cleanroom'
 require 'roundtrip_xml/base_cleanroom'
+require 'roundtrip_xml/utils'
+require 'roundtrip_xml/sexp_dsl_builder'
+require 'tree'
+require 'set'
 # Class which evaluates DSL and read XML files to populate the namespace with classes
 class DslRuntime
+  include Utils
   def initialize()
     @classes = {}
+    @root_classes = Set.new
   end
-  def populate(files)
-    files.each {|f| populate_from_file f }
+  def populate(files, root_method=nil)
+    files.map {|f| populate_from_file f, root_method }
   end
 
-  def populate_from_file (file)
-    populate_raw File.read(file)
+  def populate_from_file (file, root_method=nil)
+    populate_raw File.read(file), root_method
 
   end
 
-  def populate_raw (raw)
+  def populate_raw (raw, root_method = nil)
     builder = RoxmlBuilder.new (Nokogiri::XML(raw).root), @classes
     new_classes = builder.build_classes
+    @root_classes << builder.root_class_name
     @classes.merge! new_classes
-  end
+    if root_method
+      roxml_root = fetch(builder.root_class_name).from_xml raw
+
+      extractor = Extractor.new roxml_root.send(root_method), self
 
+      new_objs = extractor.convert_roxml_objs
+      subclasses = extractor.subclasses
+      roxml_root.send("#{root_method}=", new_objs)
+      builder = SexpDslBuilder.new [roxml_root], subclasses, self
+
+      builder.write_roxml_objs
+    end
+  end
 
   def fetch(class_name)
     @classes[class_name]
@@ -47,7 +65,116 @@ class DslRuntime
   def fetch_cleanroom(root_class)
     BaseCleanroom.new(fetch(root_class).new, self)
   end
+
   def create_cleanroom(root_class)
     BaseCleanroom.new(root_class.new, self)
   end
+
+  def marshal_dump
+    classes = @classes.inject({}) do |hash, (name, clazz)|
+      hash[name] = {xml_name: clazz.tag_name }
+      hash[name][:attrs] = clazz.roxml_attrs.map do |accessor|
+        type = accessor.sought_type.class == Class ?
+          accessor.sought_type.class_name : accessor.sought_type
+        from = accessor.sought_type == :attr ? "@#{accessor.name}" : accessor.name
+        {
+          name: accessor.accessor,
+          opts: {
+            as: accessor.array? ? [type] : type,
+            from: from
+          }
+        }
+      end
+      hash
+    end
+
+    {
+      root_classes: @root_classes,
+      classes: classes
+    }
+  end
+
+  def deserialize_class(node, config)
+    clazz = fetch(node.name) || new_roxml_class(config[:xml_name])
+    config[:attrs].each do |attr|
+      type_is_parent = node.parentage && node.parentage.any? {|n| n.name == attr[:opts][:as]}
+      if type_is_parent
+        add_unprocessed_attr attr, clazz
+      else
+        clazz.xml_accessor attr[:name], transform_accessor_opts(attr[:opts])
+      end
+    end
+    clazz
+  end
+
+  def add_unprocessed_attr(attr_config, clazz)
+    @unprocessed_attrs ||= []
+    @unprocessed_attrs << AttrJob.new(attr_config, clazz)
+  end
+
+  def transform_accessor_opts(opts)
+    attr_type = opts[:as]
+    is_array = attr_type.class == Array
+    type = is_array ? attr_type.first : attr_type
+    if is_array
+      opts[:as] = [fetch(type)]
+    else
+      opts[:as] = fetch type
+    end
+    opts
+  end
+
+  def marshal_load(data)
+    initialize
+    @root_classes.merge data[:root_classes]
+    trees = @root_classes.map {|clazz| hash_to_tree data[:classes], clazz}
+    trees.each do |tree|
+      tree.postordered_each do |node|
+        @classes[node.name] = deserialize_class(node, node.content)
+      end
+    end
+    @unprocessed_attrs.each do |job|
+      clazz = job.class
+      config = job.config
+      clazz.xml_accessor config[:name], transform_accessor_opts(config[:opts])
+    end if @unprocessed_attrs
+  end
+
+  def hash_to_tree(hash, root_name, processed = [])
+    node = Tree::TreeNode.new(root_name, hash[root_name])
+    processed << root_name
+    children = child_classes(hash, hash[root_name])
+    children.each do |name|
+      node << hash_to_tree(hash, name, processed) unless processed.include? name
+    end
+    node
+  end
+
+  def child_classes(hash, config)
+    config[:attrs].map do |attr|
+      attr_type = attr[:opts][:as]
+      type = attr_type.class == Array ? attr_type.first : attr_type
+      type if hash.key? type
+    end.compact
+  end
+
+
+  def serialize(path)
+    file = File.new path, 'w'
+    Marshal.dump self, file
+    file.close
+  end
+
+  def self.load(path)
+    file = File.open path, 'r'
+    Marshal.load file
+  end
+end
+
+class AttrJob
+  attr_accessor :class, :config
+  def initialize(config, clazz)
+    self.config = config
+    self.class = clazz
+  end
 end

data/lib/roundtrip_xml/extractor.rb

@@ -0,0 +1,81 @@
+require 'roxml'
+require 'nokogiri'
+require 'roundtrip_xml/utils'
+require 'hashdiff'
+require 'set'
+require 'roundtrip_xml/utils'
+require 'multiset'
+require 'roundtrip_xml/roxml_subclass_helpers.rb'
+
+class Extractor
+  include Utils
+  attr_reader :subclasses
+  def initialize(roxml_objs, runtime)
+    @roxml_objs = roxml_objs
+    @hashes = @roxml_objs.map { |obj| obj.to_hash }
+    @runtime = runtime
+    @subclass_names = Multiset.new
+    @subclasses = []
+  end
+  def list_diffs
+
+    HashDiff.best_diff(@hashes[0], @hashes[6]).sort_by do |diff|
+      m = diff[1].match(/\./)
+      m ? m.size : 0
+    end.map {|diff| diff[1]}
+  end
+
+  def similar_fields
+    keys = Set.new @hashes[0].keys
+    diff_keys = Set.new
+    @hashes.each do |hash_1|
+      @hashes.each do |hash_2|
+        diffs = HashDiff.best_diff(hash_1, hash_2).map do |diff|
+          diff[1].match(/(\w+)\.?/)[1]
+        end
+        diff_keys.merge diffs
+      end
+    end
+    keys = keys - diff_keys
+    key_hash = keys.inject({}) do |hash, key|
+      hash[key] = @hashes[0][key]
+      hash
+    end
+    [key_hash, diff_keys]
+  end
+
+  def create_romxl_class(keys, parent)
+    @subclass_names << parent
+    name = "#{parent.to_s}#{@subclass_names.count(parent)}"
+    clazz = new_roxml_class name, @runtime.fetch(parent) do
+      include RoxmlSubclassHelpers
+    end
+    clazz.defaults = keys
+    @runtime.add_class name, clazz
+    @subclasses << clazz
+    name
+  end
+
+  def convert_roxml(obj, keys, class_name)
+    parent = @runtime.fetch(class_name)
+    new = parent.new
+    parent.plain_accessors.each do |new_accessor|
+      old_accessor = new_accessor.to_s.gsub(VAR_SUFIX, '').to_sym
+      new.send "#{new_accessor}=", obj.send(old_accessor)
+    end
+
+    keys.each do |accessor|
+      new.send "#{accessor}=", obj.send(accessor)
+    end
+    new
+  end
+
+  def convert_roxml_objs
+    fields, diff_keys = similar_fields
+    parent_name = @roxml_objs[0].class.class_name
+    name = create_romxl_class fields, parent_name
+    @roxml_objs.map do |roxml|
+      convert_roxml roxml, diff_keys, name
+    end
+  end
+end

data/lib/roundtrip_xml/plain_accessors.rb

@@ -4,14 +4,18 @@ module PlainAccessors
   end
 
   module ClassMethods
-    def plain_accessor(name)
-      @plain_accessors ||= []
-      @plain_accessors << name
-      attr_accessor name
+    def plain_accessor(name, default = nil)
+      @plain_accessors ||= {}
+      @plain_accessors[name] = default
+      attr_writer name
+      define_method(name) do
+        instance_variable_get "@#{name}" || @plain_accessors[name]
+      end
     end
 
-    def plain_accessors
-      @plain_accessors || []
+    def plain_accessors(hash = false)
+      return @plain_accessors || {} if hash
+      (@plain_accessors && @plain_accessors.keys) || []
     end
   end
 end

data/lib/roundtrip_xml/roxml_builder.rb

@@ -1,9 +1,10 @@
 # require 'roxml'
 require 'nokogiri'
-require 'roundtrip_xml/plain_accessors'
+require 'roundtrip_xml/utils'
 # Builds dynamic classes based on an XML file.
 # Classes that already exist in the DslRuntime instance are modified if necessary, not overridden.
 class RoxmlBuilder
+  include Utils
   def initialize (root, current_classes = {})
     # @type Nokogiri::Element
     @root = root
@@ -11,21 +12,15 @@ class RoxmlBuilder
     # @type Map<Symbol, ROXML>
     @generated_classes = current_classes
 
-    @root_class = @generated_classes[name_to_sym(root.name)] || Class.new do
-      include ROXML
-      include PlainAccessors
-      xml_convention :dasherize
-      xml_name root.name
-      def attributes
-        self.class.roxml_attrs
-      end
-    end
+    @root_class = @generated_classes[name_to_sym(root.name)] || new_roxml_class(@root.name)
 
     @generated_classes[ name_to_sym(@root.name)] = @root_class
     @nodes = {}
   end
+  def root_class_name
+    name_to_sym @root.name
+  end
   def build_classes
-    # @root_class.xml_name (@root.name)
     @root.attributes.values.to_a.concat(@root.children.to_a).each do |child|
       default_opts = {from:child.name}
       if is_leaf_element?(child)
@@ -46,14 +41,6 @@ class RoxmlBuilder
     @generated_classes
   end
 
-  def name_to_sym(name, lower_case = false)
-    # name.gsub('-', '_').to_sym
-    new_name = name.split('-').collect(&:capitalize).join
-    new_name[0] = new_name[0].downcase! if lower_case
-    new_name.to_sym
-  end
-
-
   def add_accessor(name, opts = {}, node)
     attrs = @root_class.roxml_attrs
     attr = attrs.find do |a|

data/lib/roundtrip_xml/roxml_subclass_helpers.rb

@@ -0,0 +1,11 @@
+module RoxmlSubclassHelpers
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  module ClassMethods
+    attr_writer :defaults
+    def defaults
+      @defaults || {}
+    end
+  end
+end

data/lib/roundtrip_xml/sexp_dsl_builder.rb

@@ -0,0 +1,108 @@
+# require 'rubygems'
+require 'ruby2ruby'
+require 'ruby_parser'
+require 'pp'
+require 'sexp_processor'
+
+class SexpDslBuilder
+  def exp
+    rub = <<EOF
+bar 'adf'
+foo do
+  a "a" do
+    a1 1
+    a2 2
+  end
+  a "a" do
+    a1 3
+    a2 4
+  end
+  b "b"
+  c "c"
+end
+EOF
+
+    # s = Sexp.from_array arr
+    # processor = Ruby2Ruby.new
+    # processor.process(s)
+    parser = RubyParser.new
+    s = parser.process(rub)
+    s
+  end
+
+  attr_accessor :roxml_objs, :subclasses, :runtime
+  def initialize(roxml_objs, subclasses, runtime)
+    self.roxml_objs = roxml_objs
+    self.subclasses = subclasses
+    self.runtime = runtime
+  end
+
+  def write_def_classes
+    arr = []
+    subclasses.each do |clazz|
+      defaults = clazz.defaults.map do |accessor, default|
+        [:call, nil, accessor, [:str, default]]
+      end
+      arr = [:iter,
+             [:call, nil, :define,
+              [:lit, clazz.class_name],
+              [:lit, clazz.superclass.class_name]
+             ], 0, [:block, *defaults]]
+    end
+
+    sexp = Sexp.from_array arr
+    processor = Ruby2Ruby.new
+    processor.process(sexp)
+  end
+
+  def create_sexp_for_roxml_obj(obj, root_method = nil)
+    is_subclass = obj.class.respond_to?(:defaults)
+    subclass_value = obj.class.respond_to?(:defaults) ? [:lit, obj.class.class_name] : nil
+    accessors = []
+    obj.attributes.each do |attr|
+      val = obj.send attr.accessor
+      if !val || (is_subclass && obj.class.defaults.keys.include?(attr.accessor))
+        next
+      end
+      if attr.sought_type.class == Symbol
+        accessors << [:call, nil, attr.accessor, [:str, val || '']]
+      elsif val.class == Array
+        val.each { |v| accessors << create_sexp_for_roxml_obj(v, attr.accessor) }
+      else
+        accessors << create_sexp_for_roxml_obj(val, attr.accessor) if val
+      end
+    end.compact
+    root_call = [:call, nil, root_method]
+    root_call << subclass_value if subclass_value
+    if root_method
+      [:iter, root_call,
+       0,
+       [:block, *accessors]
+      ]
+    else
+      [:block,
+       *accessors]
+    end
+
+
+  end
+
+  def write_roxml_obj(obj, root_method)
+    s = create_sexp_for_roxml_obj obj, root_method
+
+    sexp = Sexp.from_array s
+    processor = Ruby2Ruby.new
+    processor.process(sexp).gsub "\"", "'"
+  end
+
+  def write_roxml_objs(root_method = nil)
+    roxml_objs.inject('') do |out, obj|
+      out += write_roxml_obj obj, root_method
+      out += "\n\n"
+      out
+    end
+
+  end
+
+
+end

data/lib/roundtrip_xml/utils.rb

@@ -0,0 +1,53 @@
+require 'roxml'
+require 'roundtrip_xml/plain_accessors'
+require 'set'
+def name_to_sym_helper(name, lower_case = false)
+  new_name = name.split('-').collect(&:capitalize).join
+    new_name[0] = new_name[0].downcase! if lower_case
+    new_name.to_sym
+end
+module Utils
+
+  VAR_SUFIX = '_v'.freeze
+  def self.included(base)
+    unless base.const_defined?(:VAR_SUFIX)
+      base.const_set :VAR_SUFIX, Utils::VAR_SUFIX
+    end
+  end
+  def new_roxml_class(name, parent = Object, &block)
+    Class.new(parent) do
+      include ROXML
+      include PlainAccessors
+      xml_convention :dasherize
+      xml_name name
+      def attributes
+        self.class.roxml_attrs
+      end
+
+      def self.class_name
+        name_to_sym_helper self.tag_name
+      end
+
+      def to_hash
+        attributes.inject({}) do |hash, a|
+          value = a.to_ref(self).to_xml(self)
+          value = value.to_hash if value.respond_to? :to_hash
+
+          hash[a.accessor] = value
+          hash
+        end
+      end
+      def self.unique_parent_accessors
+        plain = Set.new(plain_accessors.map {|accessor| accessor.to_s.gsub(VAR_SUFIX, '').to_sym})
+        parent_accessors = Set.new(roxml_attrs.map { |attr| attr.accessor })
+        parent_accessors - plain
+      end
+      class_eval &block if block_given?
+    end
+
+  end
+
+  def name_to_sym(name, lower_case = false)
+    name_to_sym_helper(name, lower_case)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roundtrip_xml
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Chris Usick
@@ -77,10 +77,14 @@ files:
 - lib/roundtrip_xml/base_cleanroom.rb
 - lib/roundtrip_xml/dsl_builder.rb
 - lib/roundtrip_xml/dsl_runtime.rb
+- lib/roundtrip_xml/extractor.rb
 - lib/roundtrip_xml/plain_accessors.rb
 - lib/roundtrip_xml/root_cleanroom.rb
 - lib/roundtrip_xml/roxml_builder.rb
-homepage: https://github.com/chrisUsick/roundtrip-xml
+- lib/roundtrip_xml/roxml_subclass_helpers.rb
+- lib/roundtrip_xml/sexp_dsl_builder.rb
+- lib/roundtrip_xml/utils.rb
+homepage: https://github.com/chrisUsick/roundtrip_xml
 licenses:
 - MIT
 metadata: {}