roundtrip_xml 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f0012fb7fe73d2b380d6ccb789ce81e220a5cb5
-  data.tar.gz: b851118b3e91dd5644c77f95545621e65a98caf7
+  metadata.gz: 8be8e12666739bebd81cc31be68c2707004172cb
+  data.tar.gz: 89c888102932ba9719a7b57a89ba58ca5c736c1d
 SHA512:
-  metadata.gz: d70527738c6a247d6769eca5e1b9135310b3eb1228dca18753a8d7cd9ffb51d2be3801a124431e4bd907699cd8532eb44997094d92f98c2209782fb73a211210
-  data.tar.gz: 77733f8c0ca731e0d1350f78fc12ca3244ae01910e63260a4a07b1fa546cc02ccbf3e72136023c6c6348f5fd4cc3cf513b5bd848151b92ad79229089ebf8e97e
+  metadata.gz: a95e401af921c46d3d7a36d8248a776230729a6b81630890c6496062e1d05431f916d89f9895e017f3abf0adb9db1496daf814c99ac919403468ab167d6afb71
+  data.tar.gz: fd001af3052e83f90617fee528178bd6065f1b43cbafbf9716fc24e6cf3eb358c5ae57f368a249dc94b968a18ffdbd338cfeb7decb9697454110379e158d4843

data/lib/roundtrip_xml/base_cleanroom.rb

@@ -1,4 +1,5 @@
 require 'cleanroom'
+require 'roundtrip_xml/utils'
 # Generates cleanroom methods corresponding to all the xml_accessors and plain_accessors of @el
 class BaseCleanroom
   include Cleanroom
@@ -6,7 +7,9 @@ class BaseCleanroom
     @el
   end
 
-  def initialize(el, runtime)
+  attr_reader :show_undefined_params
+  def initialize(el, runtime, show_undefined_params = false)
+    @show_undefined_params = show_undefined_params
     @runtime = runtime
     @el = el
     get_el.attributes.each do |attr|
@@ -39,8 +42,13 @@ class BaseCleanroom
   def expose_attr_accessors()
     get_el.class.plain_accessors.each do |a|
       create_method(a) do |value = nil|
-        return get_el.send(a) unless value
-        get_el.send("#{a}=".to_sym, value) if value
+        if value
+          get_el.send("#{a}=".to_sym, value) if value
+        elsif !value && show_undefined_params
+          return get_el.send(a) || Utils::UndefinedParam.new(a)
+        else
+          return get_el.send(a)
+        end
       end
       self.class.send(:expose, a)
     end
@@ -51,10 +59,9 @@ class BaseCleanroom
 
   def expand(clazz, &block)
     plain_accessors = @el.class.plain_accessors
-    hash = {}
     @value_holder ||= {}
-    hash = plain_accessors.inject({}) {|h, a| h[a] = @el.send(a); h}
-    child = @runtime.create_cleanroom(clazz)
+    hash = plain_accessors.inject({}) {|h, a| h[a] = @el.send(a) || Utils::UndefinedParam.new(a); h}
+    child = @runtime.create_cleanroom(clazz, @show_undefined_params)
     child.inherit_properties hash.merge(@value_holder)
 
     child.evaluate &block

data/lib/roundtrip_xml/dsl_runtime.rb

@@ -15,34 +15,54 @@ class DslRuntime
     @classes = {}
     @root_classes = Set.new
   end
-  def populate(files, root_method=nil)
-    files.map {|f| populate_from_file f, root_method }
+  def populate(files)
+    files.map {|f| populate_from_file f }
   end
 
-  def populate_from_file (file, root_method=nil)
-    populate_raw File.read(file), root_method
+  def populate_from_file (file)
+    populate_raw File.read(file)
 
   end
 
   ##
   # @param root_method Symbol   The method of the ROXML object to access its children
-  def populate_raw (raw, root_method = nil)
+  def populate_raw (raw)
     builder = RoxmlBuilder.new (Nokogiri::XML(raw).root), @classes
     new_classes = builder.build_classes
     @root_classes << builder.root_class_name
     @classes.merge! new_classes
-    if root_method
-      roxml_root = fetch(builder.root_class_name).from_xml raw
+  end
 
-      extractor = Extractor.new roxml_root.send(root_method), self
+  # @param block Proc This proc is passed each health rule and must return a string value which specifies the partition for it
+  def write_dsl(xml, root_class_name, root_method, helpers = '', &block)
+    roxml_root = fetch(root_class_name).from_xml xml
 
-      new_objs = extractor.convert_roxml_objs
-      subclasses = extractor.subclasses
-      roxml_root.send("#{root_method}=", new_objs)
-      builder = SexpDslBuilder.new [roxml_root], subclasses, self
+    extractor = Extractor.new roxml_root.send(root_method), self, root_class_name, helpers
 
-      builder.write_full_dsl
+    new_objs = extractor.convert_roxml_objs
+    if block_given?
+      partitions = {}
+      new_objs.each do |obj|
+        partition = yield obj
+        partitions[partition] ||= []
+        partitions[partition] << obj
+      end
+      partitions
+      partitions.inject({}) do |out, (partition, objs)|
+        out[partition] = write_dsl_helper roxml_root, root_method, objs
+        out
+      end
+    else
+      write_dsl_helper roxml_root, root_method, new_objs
     end
+
+  end
+
+  def write_dsl_helper(root, root_method, objs)
+    root.send("#{root_method}=", objs)
+    builder = SexpDslBuilder.new root, self
+
+    builder.write_full_dsl root_method
   end
 
   def fetch(class_name)
@@ -73,8 +93,8 @@ class DslRuntime
     BaseCleanroom.new(fetch(root_class).new, self)
   end
 
-  def create_cleanroom(root_class)
-    BaseCleanroom.new(root_class.new, self)
+  def create_cleanroom(root_class, show_undefined_params = false)
+    BaseCleanroom.new(root_class.new, self, show_undefined_params)
   end
 
   def marshal_dump

data/lib/roundtrip_xml/extractor.rb

@@ -8,80 +8,121 @@ require 'multiset'
 require 'roundtrip_xml/roxml_subclass_helpers.rb'
 
 class Extractor
-  include Utils
-  attr_reader :subclasses
-  def initialize(roxml_objs, runtime)
+
+  def initialize(roxml_objs, runtime, root_class, definitions = nil, &block)
     @roxml_objs = roxml_objs
-    @hashes = @roxml_objs.map { |obj| obj.to_hash }
     @runtime = runtime
-    @subclass_names = Multiset.new
-    @subclasses = []
+    @root_class = root_class
+    if block_given?
+      @definitions = eval_definitions root_class, &block
+    else
+      @definitions = eval_definitions root_class, definitions
+    end
   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]}
+  def eval_definitions(root_class, str = nil, &block)
+    old_names = @runtime.instance_variable_get(:@classes).keys
+    if block_given?
+      @runtime.evaluate_raw '', root_class, &block
+    else
+      @runtime.evaluate_raw str, root_class
+    end
+    new_names = @runtime.instance_variable_get(:@classes).keys
+    def_names = new_names - old_names
+    def_names.inject({}) do |out, name|
+      clazz = @runtime.fetch(name)
+      parent = get_root_class clazz
+      obj = clazz.new
+      cleanroom = @runtime.create_cleanroom clazz, true
+      cleanroom.get_el.process.each { |p| cleanroom.evaluate &p }
+      out[parent] ||= []
+      out[parent] << cleanroom.get_el
+      out
+    end
   end
 
-  def similar_fields
-    keys = Set.new @hashes[0].keys
-    diff_keys = Set.new
-    compared = {}
-    @hashes.each do |hash_1|
-      @hashes.each do |hash_2|
-        compared[hash_2] ||= Set.new
-        next if hash_1 == hash_2 || compared[hash_1].include?(hash_2)
-        compared[hash_2].add hash_1
-
-        diffs = HashDiff.diff(hash_1, hash_2).map do |diff|
-          diff[1].match(/(\w+)\.?/)[1]
-        end
+  def get_root_class(clazz)
+    super_clazz = @runtime.fetch clazz.superclass.class_name
+    if super_clazz.subclass?
+      get_root_class super_clazz
+    else
+      super_clazz.class_name
+    end
+  end
 
-        diff_keys.merge diffs
-      end
+  def diff_definition(defin, obj)
+    def_hash = defin.to_hash
+    obj_hash = obj.to_hash
+    [def_hash, obj_hash].each do |h|
+      h.delete '__class'
     end
-    keys = keys - diff_keys
-    key_hash = keys.inject({}) do |hash, key|
-      hash[key] = @hashes[0][key]
-      hash
+    diffs = HashDiff.diff(obj_hash, def_hash).map do |diff|
+      ROXMLDiff.new diff[1], from_hash(diff[2]), diff[3]
     end
-    [key_hash, diff_keys]
+
+    diffs
   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
+  def from_hash(hash)
+    return hash unless hash.is_a? Hash
+    @runtime.fetch(hash['__class']).from_hash @runtime, hash
+
   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)
+  def convert_roxml_objs
+    def_names = @definitions.keys
+    @roxml_objs.map do |obj|
+      convert_roxml_obj obj
     end
+  end
+
+  def convert_roxml_obj (obj)
+    name = obj.class.class_name
+    defs = @definitions[name]
+
+    defs.each do |defin|
+      diffs = diff_definition(defin, obj)
+      if diffs.all? {|diff| diff.template_val.is_a?(Utils::UndefinedParam) || diff.template_val == nil }
+        new_obj = defin.class.new
+        param_values = diffs.inject({}) do |values, diff|
+          name = diff.template_val ? diff.template_val.name : diff.key
+          values[name] = diff.obj_val
+          values
+        end
+        set_attributes new_obj, param_values
+        # return convert_roxml_obj new_obj
+        obj = new_obj
+      end
+    end if defs
 
-    keys.each do |accessor|
-      new.send "#{accessor}=", obj.send(accessor)
+    obj.class.roxml_attrs.each do |a|
+      if a.array?
+        elements = obj.send(a.accessor).map {|el| convert_roxml_obj el}
+        obj.send a.setter.to_sym, elements
+      elsif a.sought_type.class == Class
+        current_value = obj.send(a.accessor)
+        obj.send a.setter.to_sym, convert_roxml_obj(current_value) if current_value
+      end
     end
-    new
+    obj
   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
+  def set_attributes(obj, params)
+    params.each do |param, val|
+      methods = param.to_s.split '.'
+      # set_deep_attribute obj, methods, val
+      obj.send "#{param}=", val
     end
+
+  end
+
+end
+
+class ROXMLDiff
+  attr_reader :key, :obj_val, :template_val
+  def initialize(key, obj_val, template_val)
+    @key = key.to_sym
+    @obj_val = obj_val
+    @template_val = template_val
   end
 end

data/lib/roundtrip_xml/extractor2.rb

@@ -0,0 +1,88 @@
+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'
+
+# extracts duplicate attributes from ROXML objects
+class Extractor2
+  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
+    compared = {}
+    @hashes.each do |hash_1|
+      @hashes.each do |hash_2|
+        compared[hash_2] ||= Set.new
+        next if hash_1 == hash_2 || compared[hash_1].include?(hash_2)
+        compared[hash_2].add hash_1
+
+        diffs = HashDiff.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

@@ -1,3 +1,4 @@
+require 'roundtrip_xml/utils'
 module PlainAccessors
   def self.included(base)
     base.extend ClassMethods
@@ -9,7 +10,10 @@ module PlainAccessors
       @plain_accessors[name] = default
       attr_writer name
       define_method(name) do
-        instance_variable_get "@#{name}" || @plain_accessors[name]
+        val = instance_variable_get "@#{name}"
+        val
+        # @plain_accessors is actually nil here
+        # val.nil? ? @plain_accessors[name] : val
       end
     end
 

data/lib/roundtrip_xml/root_cleanroom.rb

@@ -10,6 +10,7 @@ class RootCleanroom < BaseCleanroom
       # simply using @@params is referring to `AContainer`
       # hash = self.class_variable_defined?(:@@block) ? self.class_variable_get(:@@block) : {}
       # hash[name] = block
+      self.instance_variable_set :@is_subclass, true
       self.instance_variable_set(:@block, block)
       params.each do |param|
         plain_accessor param
@@ -34,8 +35,8 @@ class RootCleanroom < BaseCleanroom
         else
           [proc]
         end
-
       end
+
     end
     @runtime.add_class name, new_class
   end

data/lib/roundtrip_xml/sexp_dsl_builder.rb

@@ -30,48 +30,36 @@ EOF
     s
   end
 
-  attr_accessor :roxml_objs, :subclasses, :runtime
-  def initialize(roxml_objs, subclasses, runtime)
-    self.roxml_objs = roxml_objs
-    self.subclasses = subclasses
+  attr_accessor :roxml_objs, :runtime
+  def initialize(roxml_obj, runtime)
+    @roxml_obj = roxml_obj
     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
+    is_subclass = obj.class.subclass?
+    subclass_value = is_subclass ? [: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
+      next unless val
+      # 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 || '']]
+        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
+    # plain accessors
+    obj.class.plain_accessors.each do |a|
+      val = obj.send a
+      next unless val
+      accessors << [:call, nil, a, [:str, val]]
+    end
     root_call = [:call, nil, root_method]
     root_call << subclass_value if subclass_value
     if root_method
@@ -83,28 +71,18 @@ EOF
       [:block,
        *accessors]
     end
-
-
   end
 
-  def write_roxml_obj(obj, root_method)
-    s = create_sexp_for_roxml_obj obj, root_method
+  def write_roxml_obj(obj)
+    s = create_sexp_for_roxml_obj obj
 
     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
+    processor.process(sexp).gsub("\"", "'").gsub(/[\(\)]/, ' ')
   end
 
-  def write_full_dsl()
-    write_def_classes + "\n\n" + write_roxml_objs
+  def write_full_dsl(root_method)
+    write_roxml_obj @roxml_obj
   end
 
 end

data/lib/roundtrip_xml/utils.rb

@@ -7,6 +7,13 @@ def name_to_sym_helper(name, lower_case = false)
     new_name.to_sym
 end
 module Utils
+  # UNDEFINED_PARAM = 'UNDEFINED_PARAM_VALUE'
+  class UndefinedParam
+    attr_reader :name
+    def initialize(name)
+      @name = name
+    end
+  end
 
   VAR_SUFIX = '_v'.freeze
   def self.included(base)
@@ -20,12 +27,17 @@ module Utils
       include PlainAccessors
       xml_convention :dasherize
       xml_name name
+
+      # by default a ROXML class isn't a sub class
+      def self.subclass?
+        @is_subclass || false
+      end
       def attributes
         self.class.roxml_attrs
       end
 
       def self.class_name
-        name_to_sym_helper self.tag_name
+        self.tag_name.is_a?(Symbol) ? self.tag_name : name_to_sym_helper(self.tag_name)
       end
 
       def to_hash
@@ -34,9 +46,22 @@ module Utils
           value = value.to_hash if value.respond_to? :to_hash
 
           hash[a.accessor] = value
+          hash['__class'] = self.class.class_name
           hash
         end
       end
+
+      def self.from_hash(runtime, hash)
+        hash.delete '__class'
+        obj = self.new
+        hash.each do |k, val|
+          if val.is_a? Hash
+            val = runtime.fetch(val['__class']).from_hash(runtime, val)
+          end
+          obj.send "#{k}=", val
+        end
+        obj
+      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 })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roundtrip_xml
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Usick
@@ -148,6 +148,7 @@ files:
 - lib/roundtrip_xml/dsl_builder.rb
 - lib/roundtrip_xml/dsl_runtime.rb
 - lib/roundtrip_xml/extractor.rb
+- lib/roundtrip_xml/extractor2.rb
 - lib/roundtrip_xml/plain_accessors.rb
 - lib/roundtrip_xml/root_cleanroom.rb
 - lib/roundtrip_xml/roxml_builder.rb