con_duxml 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9cfaa8124d43f54f14711ce08f3cd180b60a68c5
+  data.tar.gz: 1c7dd21f47d6d784b85bffeb58ec8b4b21091806
+SHA512:
+  metadata.gz: f1d9a27f1d8ac62261fc07d1ac9548f06ce284b32f223b7e02c2e508f064995dbe069cc65d09ea119a1ab8f47a93d382de6ac9a1da39ad9728a939c819fd6806
+  data.tar.gz: 7de90be2f489b27320235aab59523019d0b7a1b0344eeb811e23f0cfa5ee0a3a29de377461cbadc71cd8107e5349c5ec38f4308e4bf5b91fd42d2b1bfba36769

data/lib/con_dux/describable.rb

@@ -0,0 +1,14 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+module ConDuxml
+  module Describable
+    # TODO make this safer!!! fails too easily
+    def set_docs(args={})
+      args = self if args.empty?
+      @brief_descr = args.is_a?(Hash) ? args[:brief_descr] : (args.brief_description.text || args.brief_descr.text)
+      @long_descr = args.is_a?(Hash) ? args[:long_descr] : ( args.long_description.nodes || args.long_descr)
+    end
+
+    attr_reader :brief_descr, :long_descr
+  end
+end

data/lib/con_dux/design/array.rb

@@ -0,0 +1,48 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/instance')
+
+module ConDuxml
+  # XML object array
+  # represents a pattern of copies of a this object's children or referents
+  # differentiates between copies using iterator Parameter
+  module Array
+    include Instance
+    include Enumerable
+
+    # reifies pattern by actually copying children and assigning each unique properties derived from iterator value
+    # TODO do we need argument?
+    def instantiate(meta=nil)
+      size_expr = size.respond_to?(:to_i) ? size.to_i : size.to_s
+      if size_expr.is_a? Fixnum
+        iterator_index = 0
+        new_children = []
+        kids = []
+        children.each do |kid| kids << kid.detached_subtree_copy end
+        remove_all!
+        size_expr.times do
+          i = Instance.new
+          i << Parameters.new(nil, iterator: iterator_index)
+          kids.each do |kid| i << kid.detached_subtree_copy end
+          i.rename name+iterator_index.to_s
+          new_children << i
+          iterator_index += 1
+        end
+        new_children
+      else
+        []
+      end
+    end # def instantiate
+
+    # size can be Fixnum or a Parameter expression
+    def size
+      self[:size]
+    end
+
+    # overriding #each to only traverse children and return self on completion, not Enumerator
+    def each &block
+      @children.each &block
+      self
+    end
+  end # class Array
+end # module Dux

data/lib/con_dux/design/instance.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+module ConDuxml
+  # Instances are copies of another XML element with a distinct set of parameter values
+  # like Objects in relation to a Class
+  module Instance
+    def ref=(target)
+      raise Exception unless target.respond_to?(:nodes)
+      @ref = target
+    end
+
+    def resolve_ref(attr=nil)
+      @ref ||= self[attr || :ref]
+    end
+
+    # creates copy of referent (found from context given by 'meta') at this element's location
+    def instantiate
+      new_kids = []
+      target = resolve_ref
+      if target.nil?
+        new_kids = nodes
+      else
+        new_kids << target.clone
+      end
+      new_kids
+    end # def instantiate
+  end # module Instance
+
+  class InstanceClass
+    include Instance
+  end
+end # module Dux

data/lib/con_dux/design/link.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/instance')
+
+module ConDuxml
+  # links allow parameters to be bound to attribute values or element content in the design objects wrapped by the link
+  module Link
+    include Instance
+
+    def valid?
+      !resolve_ref.nil?
+    end
+
+    def ref=(target)
+      target.add_observer(self, :ref=)
+      super target
+    end
+
+    def instantiate
+      [resolve_ref]
+    end
+  end
+
+  module Linkable
+    include Reportable
+
+    def linked_by
+      @observer_peers.select do |obs|
+        %w(grammar history).none? do |type| obs.name == type end
+      end
+    end
+  end
+end # module Dux

data/lib/con_dux/designable.rb

@@ -0,0 +1,13 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require_relative 'describable'
+require_relative 'tabulable'
+require_relative 'mappable'
+
+module ConDuxml
+  module Designable
+    include Describable
+    include Tabulable
+    include Mappable
+  end
+end

data/lib/con_dux/instanciable.rb

@@ -0,0 +1,11 @@
+require_relative 'designable'
+
+module ConDuxml
+  module Instanciable
+    include Designable
+
+    def instantiate
+      sleep 0
+    end
+  end
+end

data/lib/con_dux/mappable.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require 'ruby-dita'
+
+module ConDuxml
+  module Mappable
+    include Dita
+
+    def to_map(targets)
+      # count levels
+      # assign to targets
+      # if targets.size < levels,
+      # if targets.size > levels, match top
+    end
+
+    # TODO currently returns topic, need to make it return map later!
+    def dita_map(*targets)
+      t = Element.new('topic')
+      t << Element.new('title')
+      t.title << targets.first if targets.any?
+      t << Element.new('body')
+      t[:id] = "topic#{t.object_id.to_s}"
+      targets[1..-1].compact.each do |x| t.body << x end
+      t
+    end
+
+    def depth
+      0 # TODO - make this dynamic! Duxml needs to implement tree depth method
+    end
+  end
+end

data/lib/con_dux/tabulable.rb

@@ -0,0 +1,114 @@
+module ConDuxml
+  module Tabulable
+    include Enumerable
+    include ConDuxml
+
+    class << self
+      def initialize(nodes)
+        @nodes = nodes
+      end
+    end
+
+    extend self
+
+    def each(&block)
+      yield nodes.each
+    end
+
+    # @param pattern [Hash, String, Symbol, Array] pattern used to filter attributes to output
+    # @return [Array] array of values of attributes that pass filter
+    def to_row(pattern=nil)
+      entries = []
+      nodes.each do |n|
+        if n.nodes.size == 1 && nodes.first.is_a?(String) && !matches?(n.name, pattern)
+          entries << n.nodes.first
+        end
+      end
+      if instance_variable_defined?(:@attributes)
+        attributes.each do |k, v| entries << v unless matches?(k, pattern) end
+      else
+        instance_variables.each do |var|
+          entries << instance_variable_get(var) unless matches?(var, pattern)
+        end
+      end
+      entries
+    end
+
+    # @param pattern [Hash, String, Symbol, Array] @see #to_row @param
+    # @return [Array] array of names of attributes that pass filter
+    def to_header(pattern=nil)
+      headings = []
+      nodes.each do |n|
+        if n.nodes.size == 1 && n.nodes.first.is_a?(String) && !matches?(n.name, pattern)
+          headings << n.name
+        end
+      end
+      if instance_variable_defined?(:@attributes)
+        attributes.each do |k, v| headings << k unless matches?(k, pattern) end
+      else
+        instance_variables.each do |var|
+          headings << var.to_s[1..-1] unless matches?(var, pattern)
+        end
+      end
+      headings
+    end
+
+    # @param pattern [Hash, String, Symbol, Array] @see #to_row @param
+    # @return [Array] 2D array where columns match #to_header and rows are #to_row output of constituent elements
+    def to_table(pattern=nil)
+      similar_nodes = nodes.group_by do |n|
+        n.name
+      end.find do |type, grp|
+        grp.size > 1
+      end.last
+      table_nodes = similar_nodes.collect do |r|
+        r.to_row(pattern.is_a?(Array) ? pattern.last : pattern)
+      end
+      header = similar_nodes.first.to_header(pattern.is_a?(Array) ? pattern.first : pattern)
+      raise Exception, "number of header columns (#{header.size}) does not match number of data columns (#{table_nodes.first.size})!" if header.size != table_nodes.first.size
+      [header, *table_nodes]
+    end
+
+    # @param *cols [*[]] column information bound to key, each of which must match a header item
+    def dita_table(pattern=nil, *cols)
+      src_tbl = to_table(pattern)
+      t = Element.new('table')
+      cols.each do |c|
+        t << Element.new('colspec')
+        t.nodes.last[:colname] = c.name
+        # TODO pull other colspec attrs; look them up!!
+      end
+      tgroup = Element.new('tgroup')
+      tgroup << Element.new('thead')
+      tgroup.thead << Element.new('row')
+
+      src_tbl.first.each do |h|
+        entry = Element.new('entry')
+        entry << h
+        tgroup.thead.row << entry
+      end
+
+      tgroup[:cols] = src_tbl.first.size.to_s
+
+      tgroup << Element.new('tbody')
+      src_tbl[1..-1].each do |row|
+        tgroup.tbody << Element.new('row')
+        row.each do |e|
+          entry = Element.new('entry')
+          entry << e.to_s
+          tgroup.tbody.nodes.last << entry
+        end
+      end
+      t << tgroup
+    end # def to_dita(pattern=[], *cols)
+
+    private
+
+    def matches?(attr, pattern)
+      return false if pattern.nil? or pattern.empty?
+      var = attr.to_s[0] == '@' ? attr.to_s[1..-1] : attr.to_s
+      pattern = pattern.keys.collect do |k| k.to_s end if pattern.is_a?(Hash)
+      var=='nodes' || pattern && var.match(pattern.to_s).to_s == var
+    end
+  end # module Tabulable
+end

data/lib/con_dux.rb

@@ -0,0 +1,40 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require_relative 'con_dux/designable'
+
+module ConDuxml
+  include Duxml
+
+  @kanseis
+
+  attr_reader :kanseis
+
+  # @param parent [Doc, Element] XML parent of this node
+  # @return [Doc, Element] instantiated XML copy of this node
+  def instantiate!
+    kansei!
+
+    parent = doc
+    doc.traverse do |n|
+      next if n.is_a?(String)
+      parent.replace(n, n.instantiate) if n.respond_to?(:instantiate)
+      parent = n unless parent === n or parent.nodes.any? do |m| m === n end
+    end
+    doc
+  end
+
+  def template
+    @kanseis.last
+  end
+
+  private
+
+  def kansei!
+    new_root = doc.clone
+    @kanseis ||= []
+    save(file) # TODO make this optional!? probably?
+    @kanseis << doc
+    @meta = MetaClass.new
+    @doc = new_root
+  end
+end

data/lib/duxml_ext/element.rb

@@ -0,0 +1,76 @@
+require 'duxml'
+require_relative '../con_dux/tabulable'
+
+module ConDuxml
+  # ConDuxml defines a new Element class by subclassing Duxml's Element and adding #split and #merge transform methods
+  class Element < ::Duxml::Element
+    include Tabulable
+
+    # @param &block [Block] calls Enumerable#chunk on this element's nodes to group them by result of &block
+    # @return [Element] a duplicate element of this node initialized with each subset's nodes
+    def split(&block)
+      chunks = nodes.chunk(&block)
+      chunks.collect do |type, nodes|
+        self.class.new(name, nodes)
+      end
+    end
+
+    # @param pattern [several_variants] if String/Symbol or array of such, differences between merged entities' instance vars matching pattern are masked; if pattern is a hash, the key is the instance var, and the value becomes the new value for the merged entity
+    # @param &block [block] groups nodes by &block then merges each group into a single row @see #chunk
+    def merge(pattern=nil, &block)
+      self_clone = self.clone
+      self_clone.nodes = []
+      chunks = block_given? ? nodes.chunk(&block) : [nil, nodes.dup]
+      chunks.each do |type, chunk|
+        if chunk.size == 1
+          self_clone.nodes << chunk.first
+          next
+        end
+
+        merged_args, homogeneous = diff_attrs(chunk, pattern)
+        if homogeneous
+          self_clone.nodes << chunk.first.class.new(chunk.first.name, merged_args)
+        else
+          self_clone << chunk
+        end
+      end # chunks.each do |type, nodes|
+      self_clone
+    end # def merge(pattern, &block)
+
+  private
+    def diff_attrs(chunk, pattern)
+      homogeneous = true
+      merged_args = {}
+      chunk.each do |node|
+        node.attributes.each do |attr, val|
+          case
+            when pattern && pattern.is_a?(Hash)
+              pattern.each do |k,v|
+                if attr.match(k.to_s).to_s == attr
+                  merged_args[k] = v
+                else
+                  merged_args[attr] ||= val
+                end
+              end
+            when pattern && pattern.is_a?(Array)
+              pattern.each do |p|
+                merged_args.merge! diff_attrs(chunk, p) if matches?(attr, p)
+              end
+            when pattern && matches?(attr, pattern)   then merged_args[attr] ||= val
+            when pattern && !matches?(attr, pattern)  then merged_args[attr] ||= val
+            when chunk.any? do |n| val != n[attr] end then homogeneous = false; next
+            else
+          end
+        end
+      end
+      return merged_args, homogeneous
+    end
+
+    # TODO add !pattern or at least rewrite to work with XML
+    def matches?(attr, pattern)
+      var = attr.to_s[0] == '@' ? attr.to_s[1..-1] : attr.to_s
+      pattern = pattern.keys.collect do |k| k.to_s end if pattern.is_a?(Hash)
+      var=='nodes' || pattern && var.match(pattern.to_s).to_s == var
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: con_duxml
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Kong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: duxml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: 
+email:
+- peter.kong@nxp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/con_dux/describable.rb
+- lib/con_dux/design/array.rb
+- lib/con_dux/design/instance.rb
+- lib/con_dux/design/link.rb
+- lib/con_dux/designable.rb
+- lib/con_dux/instanciable.rb
+- lib/con_dux/mappable.rb
+- lib/con_dux/tabulable.rb
+- lib/con_dux.rb
+- lib/duxml_ext/element.rb
+homepage: http://www.github.com/con_duxml
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.11
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: Construct Universal XML
+test_files: []