everypolitician-daff 1.3.26

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a11fc20d411b513efdaba697341732ec8c959fab
+  data.tar.gz: a75fc65eec245636dbc871738e095dfb377131ce
+SHA512:
+  metadata.gz: d4ac298ae1a62e410888ec924c776d65cf3d2dbd2432c03941bcaec938f86ddda1f055c60653eb4bcc23a3f81cdd35c8f41149d9e12e3793aaf30a53c4c422cc
+  data.tar.gz: 2d2787dde77d711ae818defcf35fcd2285f23a3ffda84ce4a907531c6bbb7f8027f58a06fc694745a34c973332b50c37d2b4891efb6924bc3dd869b7de2d26f5

data/README.md

@@ -0,0 +1,252 @@
+[![Build Status](https://travis-ci.org/paulfitz/daff.svg?branch=master)](https://travis-ci.org/paulfitz/daff)
+[![NPM version](https://badge.fury.io/js/daff.svg)](http://badge.fury.io/js/daff)
+[![Gem Version](https://badge.fury.io/rb/daff.svg)](http://badge.fury.io/rb/daff)
+[![PyPI version](https://badge.fury.io/py/daff.svg)](http://badge.fury.io/py/daff)
+[![PHP version](https://badge.fury.io/ph/paulfitz%2Fdaff-php.svg)](http://badge.fury.io/ph/paulfitz%2Fdaff-php)
+[![Bower version](https://badge.fury.io/bo/daff.svg)](http://badge.fury.io/bo/daff)
+![Badge count](http://img.shields.io/:badges-7/7-33aa33.svg)
+
+daff: data diff
+===============
+
+This is a library for comparing tables, producing a summary of their
+differences, and using such a summary as a patch file.  It is
+optimized for comparing tables that share a common origin, in other
+words multiple versions of the "same" table.
+
+For a live demo, see:
+> http://paulfitz.github.com/daff/
+
+Install the library for your favorite language:
+````sh
+npm install daff -g  # node/javascript
+pip install daff     # python
+gem install daff     # ruby
+composer require paulfitz/daff-php  # php
+install.packages('daff') # R wrapper by Edwin de Jonge
+bower install daff   # web/javascript
+````
+
+Other translations are available here:
+> https://github.com/paulfitz/daff/releases
+
+Or use the library to view csv diffs on github via a chrome extension:
+> https://github.com/theodi/csvhub
+
+The diff format used by `daff` is specified here:
+> http://dataprotocols.org/tabular-diff-format/
+
+This library is a stripped down version of the coopy toolbox (see
+http://share.find.coop).  To compare tables from different origins, 
+or with automatically generated IDs, or other complications, check out
+the coopy toolbox.
+
+The program
+-----------
+
+You can run `daff`/`daff.py`/`daff.rb` as a utility program:
+````
+$ daff
+daff can produce and apply tabular diffs.
+Call as:
+  daff [--output OUTPUT.csv] a.csv b.csv
+  daff [--output OUTPUT.csv] parent.csv a.csv b.csv
+  daff [--output OUTPUT.ndjson] a.ndjson b.ndjson
+  daff patch [--inplace] [--output OUTPUT.csv] a.csv patch.csv
+  daff merge [--inplace] [--output OUTPUT.csv] parent.csv a.csv b.csv
+  daff trim [--output OUTPUT.csv] source.csv
+  daff render [--output OUTPUT.html] diff.csv
+  daff git
+  daff version
+
+The --inplace option to patch and merge will result in modification of a.csv.
+
+If you need more control, here is the full list of flags:
+  daff diff [--output OUTPUT.csv] [--context NUM] [--all] [--act ACT] a.csv b.csv
+     --context NUM: show NUM rows of context
+     --all:         do not prune unchanged rows
+     --act ACT:     show only a certain kind of change (update, insert, delete)
+
+  daff diff --git path old-file old-hex old-mode new-file new-hex new-mode
+     --git:         process arguments provided by git to diff drivers
+
+  daff render [--output OUTPUT.html] [--css CSS.css] [--fragment] [--plain] diff.csv
+     --css CSS.css: generate a suitable css file to go with the html
+     --fragment:    generate just a html fragment rather than a page
+     --plain:       do not use fancy utf8 characters to make arrows prettier
+````
+
+Formats supported are CSV, TSV, and [ndjson](http://dataprotocols.org/ndjson/).
+
+Using with git
+--------------
+
+Run `daff git csv` to install daff as a diff and merge handler
+for `*.csv` files in your repository.  Run `daff git` for instructions
+on doing this manually. Your CSV diffs and merges will get smarter,
+since git will suddenly understand about rows and columns, not just lines:
+
+![Example CSV diff](http://paulfitz.github.io/daff-doc/images/daff_vs_diff.png)
+
+The library
+-----------
+
+You can use `daff` as a library from any supported language.  We take 
+here the example of Javascript.  To use `daff` on a webpage,
+first include `daff.js`:
+```html
+<script src="daff.js"></script>
+```
+Or if using node outside the browser:
+```js
+var daff = require('daff');
+```
+
+For concreteness, assume we have two versions of a table,
+`data1` and `data2`:
+```js
+var data1 = [
+    ['Country','Capital'],
+    ['Ireland','Dublin'],
+    ['France','Paris'],
+    ['Spain','Barcelona']
+];
+var data2 = [
+    ['Country','Code','Capital'],
+    ['Ireland','ie','Dublin'],
+    ['France','fr','Paris'],
+    ['Spain','es','Madrid'],
+    ['Germany','de','Berlin']
+];
+```
+
+To make those tables accessible to the library, we wrap them
+in `daff.TableView`:
+```js
+var table1 = new daff.TableView(data1);
+var table2 = new daff.TableView(data2);
+```
+
+We can now compute the alignment between the rows and columns
+in the two tables:
+```js
+var alignment = daff.compareTables(table1,table2).align();
+```
+
+To produce a diff from the alignment, we first need a table
+for the output:
+```js
+var data_diff = [];
+var table_diff = new daff.TableView(data_diff);
+```
+
+Using default options for the diff:
+```js
+var flags = new daff.CompareFlags();
+var highlighter = new daff.TableDiff(alignment,flags);
+highlighter.hilite(table_diff);
+```
+
+The diff is now in `data_diff` in highlighter format, see
+specification here:
+> http://share.find.coop/doc/spec_hilite.html
+
+```js
+[ [ '!', '', '+++', '' ],
+  [ '@@', 'Country', 'Code', 'Capital' ],
+  [ '+', 'Ireland', 'ie', 'Dublin' ],
+  [ '+', 'France', 'fr', 'Paris' ],
+  [ '->', 'Spain', 'es', 'Barcelona->Madrid' ],
+  [ '+++', 'Germany', 'de', 'Berlin' ] ]
+```
+
+For visualization, you may want to convert this to a HTML table
+with appropriate classes on cells so you can color-code inserts,
+deletes, updates, etc.  You can do this with:
+```js
+var diff2html = new daff.DiffRender();
+diff2html.render(table_diff);
+var table_diff_html = diff2html.html();
+```
+
+For 3-way differences (that is, comparing two tables given knowledge
+of a common ancestor) use `daff.compareTables3` (give ancestor
+table as the first argument).
+
+Here is how to apply that difference as a patch:
+```js
+var patcher = new daff.HighlightPatch(table1,table_diff);
+patcher.apply();
+// table1 should now equal table2
+```
+
+For other languages, you should find sample code in 
+the packages on the [Releases](https://github.com/paulfitz/daff/releases) page.
+
+Supported languages
+-------------------
+
+The `daff` library is written in [Haxe](http://haxe.org/), which
+can be translated reasonably well into at least the following languages:
+
+ * Javascript
+ * Python
+ * Java
+ * C#
+ * C++
+ * Ruby (using an [unofficial haxe target](https://github.com/paulfitz/haxe) developed for `daff`) 
+ * PHP
+
+Some translations are done for you on the
+[Releases](https://github.com/paulfitz/daff/releases) page.
+To make another translation, or to compile from source
+first follow the [Haxe getting started tutorial](http://haxe.org/doc/start) for the
+language you care about.  At the time of writing, if you are on OSX, you should
+install haxe using `brew install haxe --HEAD`.  Then do one of:
+
+```
+make js
+make php
+make py
+make java
+make cs
+make cpp
+```
+
+For each language, the `daff` library expects to be handed an interface to tables you create, rather than creating them
+itself.  This is to avoid inefficient copies from one format to another.  You'll find a `SimpleTable` class you can use if
+you find this awkward.
+
+Other possibilities:
+
+ * There's a daff wrapper for R written by [Edwin de Jonge](https://github.com/edwindj), see https://github.com/edwindj/daff and http://cran.r-project.org/web/packages/daff
+ * There's a hand-written ruby port by [James Smith](https://github.com/Floppy), see https://github.com/theodi/coopy-ruby
+
+API documentation
+-----------------
+
+ * You can browse the `daff` classes at http://paulfitz.github.io/daff-doc/
+
+Sponsors
+--------
+
+<img src="http://datacommons.coop/images/the_zen_of_venn.png" alt="the zen of venn" height="100">
+The [Data Commons Co-op](http://datacommons.coop),  "perhaps the geekiest of all cooperative organizations on the planet," has given great moral support during the development of `daff`.
+Donate a multiple of `42.42` in your currency to let them know you care: [http://datacommons.coop/donate/](http://datacommons.coop/donate/)
+
+Reading material
+----------------
+
+ * http://dataprotocols.org/tabular-diff-format/ : a specification of the diff format we use.
+ * http://theodi.org/blog/csvhub-github-diffs-for-csv-files : using this library with github.
+ * https://github.com/ropensci/unconf/issues/19 : a thread about diffing data in which daff shows up in at least four guises (see if you can spot them all).
+ * http://theodi.org/blog/adapting-git-simple-data : using this library with gitlab.
+ * http://okfnlabs.org/blog/2013/08/08/diffing-and-patching-data.html : a summary of where the library came from.
+ * http://blog.okfn.org/2013/07/02/git-and-github-for-data/ : a post about storing small data in git/github.
+ * http://blog.ouseful.info/2013/08/27/diff-or-chop-github-csv-data-files-and-openrefine/ : counterpoint - a post discussing tracked-changes rather than diffs.
+ * http://blog.byronjsmith.com/makefile-shortcuts.html : a tutorial on using `make` for data, with daff in the mix. "Since git considers changes on a per-line basis,
+   looking at diffs of comma-delimited and tab-delimited files can get obnoxious. The program daff fixes this problem."
+
+## License
+
+daff is distributed under the MIT License.

data/bin/daff.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'daff'
+Daff::Coopy.main

data/lib/daff.rb

@@ -0,0 +1,150 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# Translation requires Ruby >= 1.9.3
+ruby_major, ruby_minor, ruby_patch = RUBY_VERSION.split('.').map{|x| x.to_i}
+if ruby_major<1 || (ruby_major==1 && (ruby_minor<9 || (ruby_minor==9 && ruby_patch<3)))
+  $stderr.puts "Your current Ruby version is: #{RUBY_VERSION}. Haxe/Ruby generates code for version 1.9.3 or later."
+  Kernel.exit 1
+end
+def haxe_me(source_name)
+  $hx_types ||= {}
+  $hx_types[source_name.join('.')] = self
+  _haxe_vars_ = {}
+  instance_methods(false).grep(/=$/).grep(/^[^\[=]/).each do |v|
+    _haxe_vars_[v.to_s[0..-2].to_sym] = ('@'+v.to_s[0..-2]).to_sym
+  end
+  old_get = instance_method(:[]) rescue nil
+  define_method(:[]) do |x|
+    return old_get.bind(self).(x) if x.is_a?(Fixnum)
+    tag = _haxe_vars_[x]
+    return instance_variable_get(tag) if tag
+    method x
+  end
+  old_set = instance_method(:[]=) rescue nil
+  define_method(:[]=) do |x,y|
+    return old_set.bind(self).(x,y) if x.is_a?(Fixnum)
+    instance_variable_set(_haxe_vars_[x],y)
+  end
+  define_method(:haxe_name) do
+    source_name.join('.')
+  end
+  class << self
+    define_method(:[]) do |x|
+      method x
+    end
+  end
+end
+
+require 'date'
+require_relative 'lib/hx_overrides'
+require_relative 'lib/lambda'
+require_relative 'lib/list'
+require_relative 'lib/x_list/list_iterator'
+require_relative 'lib/reflect'
+require_relative 'lib/std'
+require_relative 'lib/string_buf'
+require_relative 'lib/hx_sys'
+require_relative 'lib/value_type'
+require_relative 'lib/type'
+require_relative 'lib/coopy/alignment'
+require_relative 'lib/coopy/cell_builder'
+require_relative 'lib/coopy/cell_info'
+require_relative 'lib/coopy/column_change'
+require_relative 'lib/coopy/table'
+require_relative 'lib/coopy/combined_table'
+require_relative 'lib/coopy/combined_table_body'
+require_relative 'lib/coopy/combined_table_head'
+require_relative 'lib/coopy/compare_flags'
+require_relative 'lib/coopy/compare_table'
+require_relative 'lib/coopy/conflict_info'
+require_relative 'lib/coopy/coopy'
+require_relative 'lib/coopy/cross_match'
+require_relative 'lib/coopy/csv'
+require_relative 'lib/coopy/diff_render'
+require_relative 'lib/coopy/diff_summary'
+require_relative 'lib/coopy/flat_cell_builder'
+require_relative 'lib/coopy/row'
+require_relative 'lib/coopy/highlight_patch'
+require_relative 'lib/coopy/highlight_patch_unit'
+require_relative 'lib/coopy/index'
+require_relative 'lib/coopy/index_item'
+require_relative 'lib/coopy/index_pair'
+require_relative 'lib/coopy/meta'
+require_relative 'lib/coopy/json_table'
+require_relative 'lib/coopy/json_tables'
+require_relative 'lib/coopy/merger'
+require_relative 'lib/coopy/mover'
+require_relative 'lib/coopy/ndjson'
+require_relative 'lib/coopy/nested_cell_builder'
+require_relative 'lib/coopy/ordering'
+require_relative 'lib/coopy/property_change'
+require_relative 'lib/coopy/row_change'
+require_relative 'lib/coopy/row_stream'
+require_relative 'lib/coopy/simple_meta'
+require_relative 'lib/coopy/simple_table'
+require_relative 'lib/coopy/view'
+require_relative 'lib/coopy/simple_view'
+require_relative 'lib/coopy/sparse_sheet'
+require_relative 'lib/coopy/sql_column'
+require_relative 'lib/coopy/sql_compare'
+require_relative 'lib/coopy/sql_database'
+require_relative 'lib/coopy/sql_helper'
+require_relative 'lib/coopy/sql_table'
+require_relative 'lib/coopy/sql_table_name'
+require_relative 'lib/coopy/sql_tables'
+require_relative 'lib/coopy/sqlite_helper'
+require_relative 'lib/coopy/table_comparison_state'
+require_relative 'lib/coopy/table_diff'
+require_relative 'lib/coopy/table_io'
+require_relative 'lib/coopy/table_modifier'
+require_relative 'lib/coopy/table_stream'
+require_relative 'lib/coopy/tables'
+require_relative 'lib/coopy/terminal_diff_render'
+require_relative 'lib/coopy/unit'
+require_relative 'lib/coopy/viterbi'
+require_relative 'lib/haxe/imap'
+require_relative 'lib/haxe/ds/int_map'
+require_relative 'lib/haxe/ds/string_map'
+require_relative 'lib/haxe/format/json_parser'
+require_relative 'lib/haxe/format/json_printer'
+require_relative 'lib/haxe/io/bytes'
+require_relative 'lib/haxe/io/output'
+require_relative 'lib/haxe/io/eof'
+require_relative 'lib/haxe/io/error'
+require_relative 'lib/rb/boot'
+require_relative 'lib/rb/ruby_iterator'
+require_relative 'lib/sys/io/file_handle'
+require_relative 'lib/sys/io/hx_file'
+require_relative 'lib/sys/io/file_output'
+
+
+def _hx_ushr(x,ct) (((x<0) ? (x + 0x100000000) : x) >> ct) end
+def _hx_str(x) (x.nil? ? 'null' : x.to_s) end
+def _hx_add(x,y) (((x.is_a? String)||(y.is_a? String)) ? (_hx_str(x)+_hx_str(y)) : (x+y)) end
+def _hx_ord(s) return 0 if s.nil?; s.ord end
+$hx_exception_classes = {}
+def hx_exception_class(c)
+  $hx_exception_classes[c.name] ||= Class.new(RuntimeError) do
+    Object.const_set((c.name.split(/::/)[-1]||'') + 'HaxeException',self)
+    attr_accessor :hx_exception_target
+    def initialize(target) @hx_exception_target = target; end
+  end
+end
+def hx_raise(x)
+  hx_exception_class(x.class).new(x)
+end
+def hx_rescue(x)
+  hx_exception_class(x.class)
+end
+def hx_rescued(x)
+  return x.hx_exception_target if x.respond_to? :hx_exception_target
+  x
+end
+
+
+require_relative 'lib/coopy/table_view'
+Daff = Coopy
+if __FILE__ == $0
+	Coopy::Coopy.main
+end

data/lib/lib/coopy/alignment.rb

@@ -0,0 +1,307 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Alignment 
+    
+    def initialize
+      @map_a2b = {}
+      @map_b2a = {}
+      @ha = @hb = 0
+      @map_count = 0
+      @reference = nil
+      @meta = nil
+      @comp = nil
+      @order_cache_has_reference = false
+      @ia = -1
+      @ib = -1
+      @marked_as_identical = false
+    end
+    
+    protected
+    
+    attr_accessor :map_a2b
+    attr_accessor :map_b2a
+    attr_accessor :ha
+    attr_accessor :hb
+    attr_accessor :ta
+    attr_accessor :tb
+    attr_accessor :ia
+    attr_accessor :ib
+    attr_accessor :map_count
+    attr_accessor :order_cache
+    attr_accessor :order_cache_has_reference
+    attr_accessor :index_columns
+    attr_accessor :marked_as_identical
+    
+    public
+    
+    attr_accessor :reference
+    attr_accessor :meta
+    attr_accessor :comp
+    attr_accessor :has_addition
+    attr_accessor :has_removal
+    
+    def range(ha,hb)
+      @ha = ha
+      @hb = hb
+    end
+    
+    def tables(ta,tb)
+      @ta = ta
+      @tb = tb
+    end
+    
+    def headers(ia,ib)
+      @ia = ia
+      @ib = ib
+    end
+    
+    def set_rowlike(flag)
+    end
+    
+    def link(a,b)
+      if a != -1 
+        @map_a2b[a] = b
+      else 
+        @has_addition = true
+      end
+      if b != -1 
+        @map_b2a[b] = a
+      else 
+        @has_removal = true
+      end
+      @map_count+=1
+    end
+    
+    def add_index_columns(unit)
+      @index_columns = Array.new if @index_columns == nil
+      @index_columns.push(unit)
+    end
+    
+    def get_index_columns 
+      @index_columns
+    end
+    
+    def a2b(a)
+      @map_a2b[a]
+    end
+    
+    def b2a(b)
+      @map_b2a[b]
+    end
+    
+    def count 
+      @map_count
+    end
+    
+    def to_s 
+      result = "" + "not implemented yet" + " // " + "not implemented yet"
+      result += " (" + _hx_str(@reference.to_s) + ")" if @reference != nil
+      result
+    end
+    
+    def to_order 
+      if @order_cache != nil 
+        if @reference != nil 
+          @order_cache = nil if !@order_cache_has_reference
+        end
+      end
+      @order_cache = self.to_order3 if @order_cache == nil
+      @order_cache_has_reference = true if @reference != nil
+      @order_cache
+    end
+    
+    def add_to_order(l,r,p = -2)
+      @order_cache = ::Coopy::Ordering.new if @order_cache == nil
+      @order_cache.add(l,r,p)
+      @order_cache_has_reference = p != -2
+    end
+    
+    def get_source 
+      @ta
+    end
+    
+    def get_target 
+      @tb
+    end
+    
+    def get_source_header 
+      @ia
+    end
+    
+    def get_target_header 
+      @ib
+    end
+    
+    protected
+    
+    def to_order3 
+      order = Array.new
+      if @reference == nil 
+        _it = ::Rb::RubyIterator.new(@map_a2b.keys)
+        while(_it.has_next) do
+          k = _it._next
+          unit = ::Coopy::Unit.new
+          unit.l = k
+          unit.r = self.a2b(k)
+          order.push(unit)
+        end
+        _it2 = ::Rb::RubyIterator.new(@map_b2a.keys)
+        while(_it2.has_next) do
+          k1 = _it2._next
+          if self.b2a(k1) == -1 
+            unit1 = ::Coopy::Unit.new
+            unit1.l = -1
+            unit1.r = k1
+            order.push(unit1)
+          end
+        end
+      else 
+        _it3 = ::Rb::RubyIterator.new(@map_a2b.keys)
+        while(_it3.has_next) do
+          k2 = _it3._next
+          unit2 = ::Coopy::Unit.new
+          unit2.p = k2
+          unit2.l = @reference.a2b(k2)
+          unit2.r = self.a2b(k2)
+          order.push(unit2)
+        end
+        _it4 = ::Rb::RubyIterator.new(@reference.map_b2a.keys)
+        while(_it4.has_next) do
+          k3 = _it4._next
+          if @reference.b2a(k3) == -1 
+            unit3 = ::Coopy::Unit.new
+            unit3.p = -1
+            unit3.l = k3
+            unit3.r = -1
+            order.push(unit3)
+          end
+        end
+        _it5 = ::Rb::RubyIterator.new(@map_b2a.keys)
+        while(_it5.has_next) do
+          k4 = _it5._next
+          if self.b2a(k4) == -1 
+            unit4 = ::Coopy::Unit.new
+            unit4.p = -1
+            unit4.l = -1
+            unit4.r = k4
+            order.push(unit4)
+          end
+        end
+      end
+      top = order.length
+      remotes = Array.new
+      locals = Array.new
+      begin
+        _g = 0
+        while(_g < top) 
+          o = _g
+          _g+=1
+          if order[o].r >= 0 
+            remotes.push(o)
+          else 
+            locals.push(o)
+          end
+        end
+      end
+      remote_sort = lambda {|a,b|
+        order[a].r - order[b].r
+      }
+      local_sort = lambda {|a1,b1|
+        return 0 if a1 == b1
+        return order[a1].l - order[b1].l if order[a1].l >= 0 && order[b1].l >= 0
+        return 1 if order[a1].l >= 0
+        return -1 if order[b1].l >= 0
+        a1 - b1
+      }
+      if @reference != nil 
+        remote_sort = lambda {|a2,b2|
+          return 0 if a2 == b2
+          o1 = order[a2].r - order[b2].r
+          if order[a2].p >= 0 && order[b2].p >= 0 
+            o2 = order[a2].p - order[b2].p
+            return o1 if o1 * o2 < 0
+            o3 = order[a2].l - order[b2].l
+            return o3
+          end
+          o1
+        }
+        local_sort = lambda {|a3,b3|
+          return 0 if a3 == b3
+          if order[a3].l >= 0 && order[b3].l >= 0 
+            o11 = order[a3].l - order[b3].l
+            if order[a3].p >= 0 && order[b3].p >= 0 
+              o21 = order[a3].p - order[b3].p
+              return o11 if o11 * o21 < 0
+              return o21
+            end
+          end
+          return 1 if order[a3].l >= 0
+          return -1 if order[b3].l >= 0
+          a3 - b3
+        }
+      end
+      remotes.sort!{|a,b| remote_sort.call(a,b)}
+      locals.sort!{|a,b| local_sort.call(a,b)}
+      revised_order = Array.new
+      at_r = 0
+      at_l = 0
+      begin
+        _g1 = 0
+        while(_g1 < top) 
+          o4 = _g1
+          _g1+=1
+          if at_r < remotes.length && at_l < locals.length 
+            ur = order[remotes[at_r]]
+            ul = order[locals[at_l]]
+            if ul.l == -1 && ul.p >= 0 && ur.p >= 0 
+              if ur.p > ul.p 
+                revised_order.push(ul)
+                at_l+=1
+                next
+              end
+            elsif ur.l > ul.l 
+              revised_order.push(ul)
+              at_l+=1
+              next
+            end
+            revised_order.push(ur)
+            at_r+=1
+            next
+          end
+          if at_r < remotes.length 
+            ur1 = order[remotes[at_r]]
+            revised_order.push(ur1)
+            at_r+=1
+            next
+          end
+          if at_l < locals.length 
+            ul1 = order[locals[at_l]]
+            revised_order.push(ul1)
+            at_l+=1
+            next
+          end
+        end
+      end
+      order = revised_order
+      result = ::Coopy::Ordering.new
+      result.set_list(order)
+      result.ignore_parent if @reference == nil
+      result
+    end
+    
+    public
+    
+    def mark_identical 
+      @marked_as_identical = true
+    end
+    
+    def is_marked_as_identical 
+      @marked_as_identical
+    end
+    
+  haxe_me ["coopy", "Alignment"]
+  end
+
+end