roundtrip_xml 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1d89e8b67e0e4e6d17b36a6f7bd669f848978a0
+  data.tar.gz: 3c9dabb9fad98650def6f2befaab68adfd56fccf
+SHA512:
+  metadata.gz: 53589a94506c4e41bc5bcb8f478929c003aec8f92f4040c4f871524a5daeeaa6b702ffaa167041d8ea4cf42b057c07f355031e88ead55a63e203f71b9e9fa816
+  data.tar.gz: 80edb85109be632bd9d1ad6b3003ab7931c679b04f7b489518677d48228e91a39664e0aa3cafe3696c0f5e737d4871f031aa2e02603b893d8aa02a46486b95cf

data/lib/roundtrip/base_cleanroom.rb

@@ -0,0 +1,82 @@
+require 'cleanroom'
+# Generates cleanroom methods corresponding to all the xml_accessors and plain_accessors of @el
+class BaseCleanroom
+  include Cleanroom
+  def get_el
+    @el
+  end
+
+  def initialize(el, runtime)
+    @runtime = runtime
+    @el = el
+    get_el.attributes.each do |attr|
+      method_name = attr.accessor.to_sym
+      create_method(method_name) do |name = nil, &block|
+        if !block.nil?
+          clazz = name ? @runtime.fetch(name) : attr.sought_type
+          value = expand(clazz, &block)
+        elsif name
+          value = name
+        else
+          return get_el.send(attr.accessor.to_sym)
+        end
+
+        if attr.array?
+          array_attr = get_el.send(attr.accessor.to_sym)
+          array_attr ||= attr.default
+          array_attr << value
+          get_el.send(attr.setter.to_sym, array_attr)
+        else
+          get_el.send(attr.setter.to_sym, value) unless get_el.send(attr.accessor.to_sym)
+        end
+      end
+      self.class.send(:expose, method_name)
+    end
+
+    expose_attr_accessors
+  end
+
+  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
+      end
+      self.class.send(:expose, a)
+    end
+  end
+  def create_method(name, &block)
+    self.class.send(:define_method, name, &block)
+  end
+
+  def expand(clazz, &block)
+    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
+    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)
+    end
+  end
+end

data/lib/roundtrip/dsl_builder.rb

@@ -0,0 +1,38 @@
+require 'nokogiri'
+
+class DslBuilder
+  def initialize(xmlStr, runtime, root_class)
+    @doc = Nokogiri::XML(xmlStr)
+    @runtime = runtime
+    @root_class = root_class
+  end
+
+  def to_dsl
+    write_attrs @runtime.fetch(@root_class), @doc.root
+  end
+
+  def write_attrs(clazz, xml, inset='')
+    clazz.roxml_attrs.inject('') do |out, attr|
+      accessor = attr.accessor
+      selector = attr.name
+
+      if attr.sought_type == :text
+        out += inset + "#{accessor} '#{xml.xpath(selector)[0].content}'\n"
+      elsif attr.sought_type == :attr
+        out += inset + "#{accessor} '#{xml.xpath("@#{selector}")[0].content}'\n"
+      elsif !attr.array?
+        out += inset + "#{accessor} do\n#{write_attrs attr.sought_type, xml.xpath(selector)[0], inset + '  '}#{inset}end\n"
+
+      else
+        xml.xpath(selector).each do |node|
+          out += inset + "#{accessor} do\n#{write_attrs attr.sought_type, node, inset + '  '}#{inset}end\n"
+          if inset == ''
+            out += "\n"
+          end
+        end
+      end
+
+      out
+    end
+  end
+end

data/lib/roundtrip/dsl_runtime.rb

@@ -0,0 +1,53 @@
+require 'roxml'
+require 'nokogiri'
+require './lib/roundtrip/roxml_builder'
+require './lib/roundtrip/root_cleanroom'
+require './lib/roundtrip/base_cleanroom'
+# Class which evaluates DSL and read XML files to populate the namespace with classes
+class DslRuntime
+  def initialize()
+    @classes = {}
+  end
+  def populate(files)
+    files.each {|f| populate_from_file f }
+  end
+
+  def populate_from_file (file)
+    populate_raw File.read(file)
+
+  end
+
+  def populate_raw (raw)
+    builder = RoxmlBuilder.new (Nokogiri::XML(raw).root), @classes
+    new_classes = builder.build_classes
+    @classes.merge! new_classes
+  end
+
+
+  def fetch(class_name)
+    @classes[class_name]
+  end
+
+  def add_class(name, clazz)
+    @classes[name] = clazz
+  end
+
+  def evaluate_file(path, root_class)
+    cleanroom = RootCleanroom.new(fetch(root_class).new, self)
+    cleanroom.evaluate_file path
+
+  end
+
+  def evaluate_raw(dsl, root_class)
+    cleanroom = RootCleanroom.new(fetch(root_class).new, self)
+    cleanroom.evaluate dsl
+
+  end
+
+  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
+end

data/lib/roundtrip/plain_accessors.rb

@@ -0,0 +1,17 @@
+module PlainAccessors
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def plain_accessor(name)
+      @plain_accessors ||= []
+      @plain_accessors << name
+      attr_accessor name
+    end
+
+    def plain_accessors
+      @plain_accessors || []
+    end
+  end
+end

data/lib/roundtrip/root_cleanroom.rb

@@ -0,0 +1,25 @@
+require './lib/roundtrip/base_cleanroom'
+# addes the `define` and `use_file` method to a cleanroom. Only used when evaluating a root file
+class RootCleanroom < BaseCleanroom
+
+  def define(name, parent, *params, &block)
+    new_class = Class.new(@runtime.fetch parent) do
+      # simply using @@params is referring to `AContainer`
+      self.class_variable_set(:@@block, block)
+      params.each do |param|
+        plain_accessor param
+      end
+
+      def process
+        self.class.class_variable_get(:@@block)
+      end
+    end
+    @runtime.add_class name, new_class
+  end
+  expose(:define)
+
+  def use_file(path)
+    self.evaluate_file(path)
+  end
+  expose(:use_file)
+end

data/lib/roundtrip/roxml_builder.rb

@@ -0,0 +1,88 @@
+# require 'roxml'
+require 'nokogiri'
+require './lib/roundtrip/plain_accessors'
+# Builds dynamic classes based on an XML file.
+# Classes that already exist in the DslRuntime instance are modified if necessary, not overridden.
+class RoxmlBuilder
+  def initialize (root, current_classes = {})
+    # @type Nokogiri::Element
+    @root = root
+
+    # @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
+
+    @generated_classes[ name_to_sym(@root.name)] = @root_class
+  end
+  def build_classes
+    # @root_class.xml_name (@root.name)
+    @root.xpath("//#{@root.name}/*|//#{@root.name}/@*").each do |child|
+      default_opts = {from:child.name}
+      if is_leaf_element?(child)
+        add_accessor name_to_sym(child.name, true), default_opts, @root
+      elsif child.type == Nokogiri::XML::Node::ATTRIBUTE_NODE
+        add_accessor name_to_sym(child.name, true), {from: "@#{child.name}"}, @root
+      else
+        builder = RoxmlBuilder.new child, @generated_classes
+        new_classes = builder.build_classes
+        child_name = name_to_sym(child.name, true)
+        child_class_name = name_to_sym child.name
+        add_accessor child_name, default_opts.merge({as: new_classes[child_class_name]}), @root
+        @generated_classes.merge!(new_classes)
+      end
+    end
+
+    @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 = nil)
+    attrs = @root_class.roxml_attrs
+    attr = attrs.find do |a|
+      a.accessor.to_sym == name
+    end
+    # if class already has xml attribute, delete the old version and add the new version
+
+    if attr && node
+      if node.xpath("./#{attr.name}").size > 1
+        @root_class.instance_variable_set(:@roxml_attrs, attrs.select {|i| i != attr })
+        new_attr_type = opts[:as]
+        # add a new attribute with the array type.
+        @root_class.xml_accessor name, opts.merge({as: [new_attr_type]})
+      end
+      # attr_type = attr.sought_type
+      # new_attr_type = opts[:as]
+      # if new_attr_type && attr_type != :text && new_attr_type.tag_name == attr_type.tag_name
+      #   # remove `attr` from the class's attributes
+      #   @root_class.instance_variable_set(:@roxml_attrs, attrs.select {|i| i != attr })
+      #   # add a new attribute with the array type.
+      #   @root_class.xml_accessor name, opts.merge({as: [new_attr_type]})
+      # end
+    else
+      @root_class.xml_accessor name, opts
+    end
+  end
+
+  # element is a leaf it has text content and no attributes
+  def is_leaf_element?(element)
+    element.type == Nokogiri::XML::Node::ELEMENT_NODE &&
+      element.attributes.size == 0 &&
+      element.children.select {|c| c.type == Nokogiri::XML::Node::ELEMENT_NODE}.empty?
+  end
+end

data/lib/roundtrip_xml.rb

@@ -0,0 +1,7 @@
+require './lib/roundtrip/dsl_runtime'
+require './lib/roundtrip/dsl_builder'
+require './lib/roundtrip/base_cleanroom'
+require './lib/roundtrip/root_cleanroom'
+require './lib/roundtrip/roxml_builder'
+require './lib/roundtrip/plain_accessors'
+puts DslRuntime.new

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: roundtrip_xml
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Chris Usick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: roxml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: cleanroom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri-diff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: A DSL that reads existing XML, generating an internal schema and using
+  it to create a (somewhat) type safe DSL
+email: chris.usick@northfieldit.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/roundtrip/base_cleanroom.rb
+- lib/roundtrip/dsl_builder.rb
+- lib/roundtrip/dsl_runtime.rb
+- lib/roundtrip/plain_accessors.rb
+- lib/roundtrip/root_cleanroom.rb
+- lib/roundtrip/roxml_builder.rb
+- lib/roundtrip_xml.rb
+homepage: https://github.com/chrisUsick/roundtrip-xml
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: DSL which learns from XML
+test_files: []