daff 1.1.19 → 1.2.1

data/lib/lib/_list/list_iterator.rb

@@ -1,31 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module X_List
-  class ListIterator 
-    
-    def initialize(head)
-      @head = head
-      @val = nil
-    end
-    
-    # protected - in ruby this doesn't play well with static/inline methods
-    
-    attr_accessor :head
-    attr_accessor :val
-    
-    public
-    
-    def has_next 
-      return @head != nil
-    end
-    
-    def _next 
-      @val = @head[0]
-      @head = @head[1]
-      return @val
-    end
-    
-  end
-
-end

data/lib/lib/coopy/bag.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Coopy
-  class Bag 
-    def get_size() puts "Abstract Bag.get_size called" end
-    def getItem(x) puts "Abstract Bag.getItem called" end
-    def getItemView() puts "Abstract Bag.getItemView called" end
-  haxe_me
-  end
-
-end

data/lib/lib/coopy/change.rb

@@ -1,49 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Coopy
-  class Change 
-    
-    def initialize(txt = nil)
-      if txt != nil 
-        @mode = ::Coopy::ChangeType.note_change
-        @change = txt
-      else 
-        @mode = ::Coopy::ChangeType.no_change
-      end
-    end
-    
-    attr_accessor :change
-    attr_accessor :parent
-    attr_accessor :local
-    attr_accessor :remote
-    attr_accessor :mode
-    
-    def get_mode 
-      return "" + _hx_str(@mode.to_s)
-    end
-    
-    def to_s 
-      begin
-        _g = @mode
-        case(_g.index)
-        when 0
-          return "no change"
-        when 2
-          return "local change: " + _hx_str(@remote.to_s) + " -> " + _hx_str(@local.to_s)
-        when 1
-          return "remote change: " + _hx_str(@local.to_s) + " -> " + _hx_str(@remote.to_s)
-        when 3
-          return "conflicting change: " + _hx_str(@parent.to_s) + " -> " + _hx_str(@local.to_s) + " / " + _hx_str(@remote.to_s)
-        when 4
-          return "same change: " + _hx_str(@parent.to_s) + " -> " + _hx_str(@local.to_s) + " / " + _hx_str(@remote.to_s)
-        when 5
-          return @change
-        end
-      end
-    end
-    
-  haxe_me
-  end
-
-end

data/lib/lib/coopy/change_type.rb

@@ -1,21 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Coopy
-  class ChangeType
-    ISENUM__ = true
-    attr_accessor :tag
-    attr_accessor :index
-    attr_accessor :params
-    def initialize(t,index,p = nil ) @tag = t; @index = index; @params = p; end
-    
-    def ChangeType.both_change() ChangeType.new("BOTH_CHANGE",3) end
-    def ChangeType.local_change() ChangeType.new("LOCAL_CHANGE",2) end
-    def ChangeType.note_change() ChangeType.new("NOTE_CHANGE",5) end
-    def ChangeType.no_change() ChangeType.new("NO_CHANGE",0) end
-    def ChangeType.remote_change() ChangeType.new("REMOTE_CHANGE",1) end
-    def ChangeType.same_change() ChangeType.new("SAME_CHANGE",4) end
-    CONSTRUCTS__ = ["NO_CHANGE","REMOTE_CHANGE","LOCAL_CHANGE","BOTH_CHANGE","SAME_CHANGE","NOTE_CHANGE"]
-  end
-
-end

data/lib/lib/coopy/compare.rb

@@ -1,99 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Coopy
-  class Compare 
-    
-    def initialize
-    end
-    
-    def compare(parent,local,remote,report)
-      ws = ::Coopy::Workspace.new
-      ws.parent = parent
-      ws.local = local
-      ws.remote = remote
-      ws.report = report
-      report.clear
-      if parent == nil || local == nil || remote == nil 
-        report.changes.push(::Coopy::Change.new("only 3-way comparison allowed right now"))
-        return false
-      end
-      return self.compare_structured(ws) if parent.has_structure || local.has_structure || remote.has_structure
-      return self.compare_primitive(ws)
-    end
-    
-    protected
-    
-    def compare_structured(ws)
-      ws.tparent = ws.parent.get_table
-      ws.tlocal = ws.local.get_table
-      ws.tremote = ws.remote.get_table
-      if ws.tparent == nil || ws.tlocal == nil || ws.tremote == nil 
-        ws.report.changes.push(::Coopy::Change.new("structured comparisons that include non-tables are not available yet"))
-        return false
-      end
-      return self.compare_table(ws)
-    end
-    
-    def compare_table(ws)
-      ws.p2l = ::Coopy::TableComparisonState.new
-      ws.p2r = ::Coopy::TableComparisonState.new
-      ws.p2l.a = ws.tparent
-      ws.p2l.b = ws.tlocal
-      ws.p2r.a = ws.tparent
-      ws.p2r.b = ws.tremote
-      cmp = ::Coopy::CompareTable.new
-      cmp.attach(ws.p2l)
-      cmp.attach(ws.p2r)
-      c = ::Coopy::Change.new
-      c.parent = ws.parent
-      c.local = ws.local
-      c.remote = ws.remote
-      if ws.p2l.is_equal && !ws.p2r.is_equal 
-        c.mode = ::Coopy::ChangeType.remote_change
-      elsif !ws.p2l.is_equal && ws.p2r.is_equal 
-        c.mode = ::Coopy::ChangeType.local_change
-      elsif !ws.p2l.is_equal && !ws.p2r.is_equal 
-        ws.l2r = ::Coopy::TableComparisonState.new
-        ws.l2r.a = ws.tlocal
-        ws.l2r.b = ws.tremote
-        cmp.attach(ws.l2r)
-        if ws.l2r.is_equal 
-          c.mode = ::Coopy::ChangeType.same_change
-        else 
-          c.mode = ::Coopy::ChangeType.both_change
-        end
-      else 
-        c.mode = ::Coopy::ChangeType.no_change
-      end
-      ws.report.changes.push(c) if c.mode != ::Coopy::ChangeType.no_change
-      return true
-    end
-    
-    def compare_primitive(ws)
-      sparent = ws.parent.to_s
-      slocal = ws.local.to_s
-      sremote = ws.remote.to_s
-      c = ::Coopy::Change.new
-      c.parent = ws.parent
-      c.local = ws.local
-      c.remote = ws.remote
-      if sparent == slocal && sparent != sremote 
-        c.mode = ::Coopy::ChangeType.remote_change
-      elsif sparent == sremote && sparent != slocal 
-        c.mode = ::Coopy::ChangeType.local_change
-      elsif slocal == sremote && sparent != slocal 
-        c.mode = ::Coopy::ChangeType.same_change
-      elsif sparent != slocal && sparent != sremote 
-        c.mode = ::Coopy::ChangeType.both_change
-      else 
-        c.mode = ::Coopy::ChangeType.no_change
-      end
-      ws.report.changes.push(c) if c.mode != ::Coopy::ChangeType.no_change
-      return true
-    end
-    
-  haxe_me
-  end
-
-end

data/lib/lib/coopy/report.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Coopy
-  class Report 
-    
-    def initialize
-      @changes = Array.new
-    end
-    
-    attr_accessor :changes
-    
-    def to_s 
-      return @changes.to_s
-    end
-    
-    def clear 
-      @changes = Array.new
-    end
-    
-  haxe_me
-  end
-
-end

data/lib/lib/coopy/simple_cell.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Coopy
-  class SimpleCell 
-    
-    def initialize(x)
-      @datum = x
-    end
-    
-    protected
-    
-    attr_accessor :datum
-    
-    public
-    
-    def to_s 
-      return @datum
-    end
-    
-  haxe_me
-  end
-
-end

data/lib/lib/coopy/viewed_datum.rb

@@ -1,38 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Coopy
-  class ViewedDatum 
-    
-    def initialize(datum,view)
-      @datum = datum
-      @view = view
-    end
-    
-    attr_accessor :datum
-    attr_accessor :view
-    
-    def to_s 
-      return @view.to_s(@datum)
-    end
-    
-    def get_bag 
-      return @view.get_bag(@datum)
-    end
-    
-    def get_table 
-      return @view.get_table(@datum)
-    end
-    
-    def has_structure 
-      return @view.has_structure(@datum)
-    end
-    
-    def ViewedDatum.get_simple_view(datum)
-      return ::Coopy::ViewedDatum.new(datum,::Coopy::SimpleView.new)
-    end
-    
-  haxe_me
-  end
-
-end

data/lib/lib/coopy/workspace.rb

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Coopy
-  class Workspace 
-    
-    def initialize
-    end
-    
-    attr_accessor :parent
-    attr_accessor :local
-    attr_accessor :remote
-    attr_accessor :report
-    attr_accessor :tparent
-    attr_accessor :tlocal
-    attr_accessor :tremote
-    attr_accessor :p2l
-    attr_accessor :p2r
-    attr_accessor :l2r
-  haxe_me
-  end
-
-end

data/lib/lib/haxe/log.rb

@@ -1,16 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Haxe
-  class Log 
-    
-    class << self
-    attr_accessor :_trace
-    end
-    @_trace = lambda {|v,infos = nil|
-      ::Rb::Boot.__trace(v,infos)
-    }
-    
-  end
-
-end

data/lib/lib/sys.rb

@@ -1,65 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-  class HxSys 
-    
-    def HxSys.args 
-      return ARGV
-    end
-    
-    # protected - in ruby this doesn't play well with static/inline methods
-    
-    def HxSys.escape_argument(arg)
-      ok = true
-      begin
-        _g1 = 0
-        _g = arg.length
-        while(_g1 < _g) 
-          i = _g1
-          _g1+=1
-          _g2 = (arg[i].ord rescue nil)
-          case(_g2)
-          when 32,34
-            ok = false
-          when 0,13,10
-            arg = arg[0,i]
-          end if _g2 != nil
-        end
-      end
-      return arg if ok
-      return "\"" + _hx_str(arg.split("\"").join("\\\"")) + "\""
-    end
-    
-    public
-    
-    def HxSys.command(cmd,args = nil)
-      if args != nil 
-        cmd = HxSys.escape_argument(cmd)
-        begin
-          _g = 0
-          while(_g < args.length) 
-            a = args[_g]
-            _g+=1
-            cmd += " " + _hx_str(HxSys.escape_argument(a))
-          end
-        end
-      end
-      result = nil
-      if system(cmd) 
-        result = 0
-      else 
-        result = 1
-      end
-      return result
-    end
-    
-    def HxSys.stdout 
-      return ::Sys::Io::FileOutput.new(STDOUT)
-    end
-    
-    def HxSys.stderr 
-      return ::Sys::Io::FileOutput.new(STDERR)
-    end
-    
-  end
-

data/lib/lib/sys/io/file.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-module Sys
-module Io
-  class HxFile 
-    
-    def HxFile.get_content(path)
-      return IO.read(path)
-    end
-    
-    def HxFile.save_content(path,content)
-      IO.write(path,content)
-    end
-    
-  end
-
-end
-end