con_duxml 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cfaa8124d43f54f14711ce08f3cd180b60a68c5
-  data.tar.gz: 1c7dd21f47d6d784b85bffeb58ec8b4b21091806
+  metadata.gz: 50d364878f6e1e1d40c244c26848840a951bc674
+  data.tar.gz: 558e088bdd171e165b8b27c1147637a9300a6c0a
 SHA512:
-  metadata.gz: f1d9a27f1d8ac62261fc07d1ac9548f06ce284b32f223b7e02c2e508f064995dbe069cc65d09ea119a1ab8f47a93d382de6ac9a1da39ad9728a939c819fd6806
-  data.tar.gz: 7de90be2f489b27320235aab59523019d0b7a1b0344eeb811e23f0cfa5ee0a3a29de377461cbadc71cd8107e5349c5ec38f4308e4bf5b91fd42d2b1bfba36769
+  metadata.gz: 20f7fd97f29bb18c682bc9c41a0908a589c192faab5ef9135bbc7c36ba33d8756855f0ef6675cac6506f2be80567fc0dbe896585f5a27146254ac7114b590d64
+  data.tar.gz: 23ad78e7719b3144043756404afb8b7f062acab8e23fd4b39f7abea80bd10f869303c93eda27646a19d958768cfc4a5211d169cdbc4c8496efb4fc2dc20b0ff3

data/lib/{con_dux/design → con_duxml}/array.rb

@@ -10,27 +10,21 @@ module ConDuxml
     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)
+    # @param block [block] each duplicated node is yielded to block if given
+    # @return [Array[Element]] flattened array of all duplicated Elements
+    def instantiate(&block)
       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
+        size_expr.times do |index|
+          nodes.each do |node|
+            new_child = block_given? ? yield(node.dclone, index) : node.dclone
+            new_children << new_child
+          end
         end
         new_children
       else
-        []
+        [self]
       end
     end # def instantiate
 

data/lib/{duxml_ext → con_duxml/duxml_ext}/element.rb

@@ -1,18 +1,20 @@
 require 'duxml'
-require_relative '../con_dux/tabulable'
+require_relative 'linkable'
 
-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
+module Duxml
+  module ElementGuts
+    include Linkable
 
     # @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|
+      new_nodes = chunks.collect do |type, nodes|
         self.class.new(name, nodes)
       end
+
+      report :Split, new_nodes
+      new_nodes
     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
@@ -34,10 +36,13 @@ module ConDuxml
           self_clone << chunk
         end
       end # chunks.each do |type, nodes|
+
+      report :Merge, self_clone
+
       self_clone
     end # def merge(pattern, &block)
 
-  private
+    private
     def diff_attrs(chunk, pattern)
       homogeneous = true
       merged_args = {}

data/lib/con_duxml/duxml_ext/linkable.rb

@@ -0,0 +1,9 @@
+module Linkable
+  def linked_by
+    @observer_peers.select do |obs|
+      %w(grammar history).none? do |type|
+        obs.name == type
+      end
+    end
+  end
+end

data/lib/{con_dux/design → con_duxml}/instance.rb

@@ -1,11 +1,12 @@
 # Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative 'duxml_ext/element'
 
 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)
+      raise Exception unless target.respond_to?(:nodes) or File.exists?(target)
       @ref = target
     end
 
@@ -20,7 +21,7 @@ module ConDuxml
       if target.nil?
         new_kids = nodes
       else
-        new_kids << target.clone
+        new_kids << target.dclone
       end
       new_kids
     end # def instantiate

data/lib/con_duxml/link.rb

@@ -0,0 +1,52 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/instance')
+
+module ConDuxml
+  # links are effectively aliases for an XML node that can exist anywhere outside of that node
+  # they confer referencing scope, namespace, and notifications of content changes
+  # anything contained by a link element is then dynamically linked to the target
+  # this is useful for designs where one element's state depends on another's or where it's important to track a target
+  # that may not be in a fixed location
+  module Link
+    include Instance
+
+    # strict links will immediately throw an exception if the target becomes invalid for any reason
+    # otherwise, errors are simply reported to history
+    @strict_or_false
+
+    def valid?
+      !resolve_ref.nil?
+    end
+
+    def ref=(target)
+      target.extend Linkable
+      @ref = target
+    end
+
+    # @param block [block] each child node is yielded to block if given
+    # @return [Array] nodes to replace this link - children by default
+    def instantiate(&block)
+      resolve_ref.add_observer(self)
+      block_given? ? yield(nodes.each) : nodes
+    end
+
+    # @param bool [true, false, nil] if true or false, sets @strict_or_false to this value
+    # @return [true, false] returns current value (true by default)
+    def strict?(bool=nil)
+      bool.nil? ? @strict_or_false ||= true : @strict_or_false = bool
+    end
+
+    # TODO rewrite this!!! at most primitive, updates need to happen when link targets split/merge or are removed
+    # @param type [Symbol] category i.e. class symbol of changes/errors reported
+    # @param *args [*several_variants] information needed to accurately log the event; varies by change/error class
+    def update(type, *args)
+      change_class = Duxml::const_get "#{type.to_s}Class".to_sym
+      change_comp = change_class.new *args
+      @nodes.unshift change_comp
+      changed
+      notify_observers(change_comp) unless change_comp.respond_to?(:error?)
+      raise(Exception, change_comp.description) if strict? && type == :QualifyError
+    end
+  end
+end # module Dux

data/lib/con_duxml/transform.rb

@@ -0,0 +1,74 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+# helper methods for converting transform elements into code
+module Transform
+  @xform
+  @source
+
+  attr_reader :xform, :source
+
+  # @param xform [Element] transform element
+  # @param _source [Element] XML xform containing content to be transformed
+  # @return [Array[Element]] transformed content; always an array of nodes, even if just one
+  def activate(xform, _source)
+    @source = _source
+    get_sources(xform).collect do |subj|
+      args = get_args(xform, subj)
+      get_method(xform).call(*args)
+    end
+  end
+
+  # @param xform [Element] transform element
+  # @return [Array] array of elements that match @target, which must be a '/'-separated string
+  #   if transform element has any children that may need the same source target, target_stack.last remains
+  #   if transform is a leaf, target_stack is popped
+  def get_sources(xform)
+    if xform[:source]
+      source.locate add_name_space_prefix xform[:source]
+    else
+      [source]
+    end
+  end
+
+  # @param xform [Element] transform element
+  # @return [Method] resolves reference to actual transform method
+  def get_method(xform)
+    words = xform.name.split(':').reverse
+    method_name = words[0].to_sym
+    maudule = Module
+    maudule = Module.const_get(words[1].constantize) if words[1] and Module.const_defined?(words[1].constantize)
+    maudule.method(method_name)
+  end
+
+  # @param xform [Element] transform element
+  # @param subj [Element] source XML Element
+  # @return [Array[String, Element]] string returned by self[:args] is separated by ';' into correctly formatted argument values for transform method
+  def get_args(xform, subj)
+    args = xform.attributes.keys.sort.collect do |attr|
+      if attr.to_s.match(/arg[0-9]/)
+        if xform[attr].include?(',')
+          xform[attr].split(',').collect do |s|
+            if s.match(/'[\s\w]+'/)
+              $MATCH.strip[1..-2]
+            else
+              subj.locate(add_name_space_prefix s.strip).first
+            end
+          end
+        else
+          subj.locate(add_name_space_prefix xform[attr]).first
+        end
+      end
+    end.compact
+    children = xform.nodes.collect do |child|
+      activate(child, subj)
+    end
+    args << children.flatten if children.any?
+    args
+  end
+
+  def add_name_space_prefix(str)
+    str.split('/').collect do |w|
+      w.match(/\w+/) ? "#{src_ns ? src_ns+':' : ''}#{w}" : w
+    end.join('/')
+  end
+end

data/lib/con_duxml.rb

@@ -0,0 +1,57 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+%w(transform array instance link).each do |f| require_relative "con_duxml/#{f}" end
+
+module ConDuxml
+  include Duxml
+  include Transform
+
+  # hash where each key is concatenation of each instantiation of @doc and values are the Doc instance permutations returned by #instantiate
+  @instances
+  # double-key hash containing every result of #transform; keys concatenation of source doc's #object_id and transform doc's #object_id
+  @transformations
+  # namespace prefix for source file
+  @src_ns
+
+  attr_reader :src_ns
+
+  # @param transforms [String, Doc] transforms file or path to one
+  # @param doc_or_path [String, Doc] XML document or path to one that will provide content to be transformed; source file can
+  #   also contain directives or links to them
+  # @return [Doc] result of transform; automatically hashed into @transforms
+  def transform(transforms, doc_or_path=nil)
+    output = Doc.new
+    transforms = case transforms
+                   when Doc then transforms.root
+                   when Element then transforms
+                   when String then sax(transforms).root
+                   else
+                 end
+    @doc = case doc_or_path
+             when Doc then doc_or_path
+             when String then sax doc_or_path
+             else doc
+           end
+    @src_ns = transforms[:src_ns]
+    source = doc.locate(add_name_space_prefix(transforms[:source])).first
+    output.grammar = transforms[:grammar] if transforms[:grammar]
+    a = activate(transforms.first, source).first
+    output << a
+    @transformations ||= {}
+    @transformations[doc.object_id+transforms.object_id] = output
+  end
+
+  # instantiation takes a static design file and constructs a dynamic model by identifying certain keyword elements,
+  # executing their method on child nodes, then removing the interpolating keyword element. these are:
+  #
+  # <array> - is replaced by multiple copies of its direct child or referenced XML nodes, allowing for user-defined variations between each copy
+  # <instance> - when it contains design elements, it is removed but its reference ID is given to all children creating an XML-invisible arbitrary grouping
+  #   when it references an XML file, ID or path to an XML element, the target is copied and inserted in place of this element
+  # <link> - referenced XML file or nodes provides namespace, contents, and notification of changes to any direct children of this node @see ConDuxml::Link
+  #
+  # @param source [String, Doc] XML document or path to one that will provide design content
+  # @return [Doc] resulting XML document
+  def instantiate(source)
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: con_duxml
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Peter Kong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-15 00:00:00.000000000 Z
+date: 2016-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: duxml
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: ruby-dita
+  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: 
 email:
 - peter.kong@nxp.com
@@ -31,17 +45,14 @@ 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
+- lib/con_duxml/array.rb
+- lib/con_duxml/duxml_ext/element.rb
+- lib/con_duxml/duxml_ext/linkable.rb
+- lib/con_duxml/instance.rb
+- lib/con_duxml/link.rb
+- lib/con_duxml/transform.rb
+- lib/con_duxml.rb
+homepage: http://www.github.com/Ludocracy/con_duxml
 licenses:
 - MIT
 metadata: {}

data/lib/con_dux/describable.rb

@@ -1,14 +0,0 @@
-# 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/link.rb

@@ -1,33 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

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

data/lib/con_dux/mappable.rb

@@ -1,30 +0,0 @@
-# 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

@@ -1,114 +0,0 @@
-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

@@ -1,40 +0,0 @@
-# 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