diff_match_patch_native 1.0.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2011-10-19
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+ext/diff_match_patch/_dmp.cpp
+ext/diff_match_patch/_dmp.h
+ext/diff_match_patch/diff_match_patch.cpp
+ext/diff_match_patch/extconf.rb
+lib/diff_match_patch.rb
+lib/diff_match_patch/diff_match_patch.bundle
+src/include/diff_match_patch-stl/diff_match_patch.h
+test/test_diff_patch_match.rb

data/README.rdoc

@@ -0,0 +1,73 @@
+= diff_patch_match_native
+
+https://github.com/elliotlaster/Ruby-Diff-Match-Patch
+
+Ruby bindings for the C++ version of google-diff-match-patch:
+http://code.google.com/p/google-diff-match-patch/
+
+== DESCRIPTION:
+
+The Diff Match and Patch libraries offer robust algorithms to perform the operations required for synchronizing plain text.
+
+== SYNOPSIS:
+
+The API conforms to the standard at http://code.google.com/p/google-diff-match-patch/wiki/API
+
+  dmp = DiffMatchPatch.new
+
+  # Diff-ing
+  dmp.diff_main("Apples are a fruit.", "Bananas are also fruit.", false)
+  => [[-1, "Apple"], [1, "Banana"], [0, "s are a"], [1, "lso"], [0, " fruit."]]
+
+  # Match-ing (return the index of the first match)
+  dmp.match_main("abcdef", "de", 3)
+  => 3
+
+  # Patch-ing
+  text_1 = "The quick brown fox jumps over the lazy dog."
+  text_2 = "That quick brown fox jumped over a lazy dog."
+  
+  patches = dmp.patch_make(text_2, text_1)
+
+  dmp.patch_to_text(patches)
+  => "@@ -1,8 +1,7 @@\n Th\n-at\n+e\n  qui\n@@ -21,17 +21,18 @@\n jump\n-ed\n+s\n  over \n-a\n+the\n  laz\n"
+
+  dmp.patch_apply(patches, text_2)
+  => ["The quick brown fox jumps over the lazy dog.", [true, true]]
+
+== REQUIREMENTS:
+
+* Rake
+* Rice >= 1.4.2
+
+== INSTALL:
+
+gem install diff-match-patch
+
+== LICENSE:
+
+
+diff_match_patch-stl.h is Copyright 2008 Google Inc, and licensed under 
+the Apache license. See 
+src/include/diff_match_patch-stl/diff_match_patch.h
+
+Copyright (c) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+# -*- ruby -*-
+require 'rubygems'
+begin
+  require 'rake/dsl_definition'
+rescue LoadError 
+  nil
+end
+require 'hoe'
+require 'rake/extensiontask'
+
+Hoe.plugin :bundler, :rubygems, :doofus, :git
+
+Hoe.spec 'diff_match_patch_native' do
+  developer('Elliot Laster', 'elliotlaster@gmail.com')
+  self.version = '1.0.0'
+  self.readme_file   = 'README.rdoc'
+  self.history_file  = 'History.txt'
+  self.extra_deps << ['rice', '>= 1.4.2']
+  self.extra_dev_deps << ['rake-compiler', '>= 0']
+
+  self.spec_extras = { :extensions => ["ext/diff_match_patch/extconf.rb"] }
+
+  Rake::ExtensionTask.new('diff_match_patch', spec) do |ext|
+    ext.lib_dir = File.join('lib', 'diff_match_patch')
+  end
+end
+
+Rake::Task[:test].prerequisites << :compile

data/ext/diff_match_patch/_dmp.cpp

@@ -0,0 +1,287 @@
+#include "_dmp.h"
+
+#define dmp diff_match_patch<std::string>
+
+
+/*
+* A lightweight wrapper around Patch, so Rice can get at it. Delegates 
+* to the patch as necissary
+*/
+class rb_patch_wrapper{
+  
+  public:
+
+    dmp::Patch patch;
+
+    rb_patch_wrapper(dmp::Patch &the_patch) : patch(the_patch) {}
+
+    int start1(){
+      return patch.start1;
+    }
+
+    int start2(){
+      return patch.start2;
+    }
+
+    int length1(){
+      return patch.length1;
+    }
+
+    int length2(){
+      return patch.length2;
+    }
+
+    std::string toString(){
+      return patch.toString();
+    }
+
+    bool isNull(){
+      return patch.isNull();
+    }
+
+};
+
+
+/*
+* A subclass of diff_match_patch<std::string>, adding methods for
+* translating between C++ and Ruby.
+*/
+class rb_diff_match_patch : dmp {
+
+protected:
+
+  Diffs diffsFromRubyArray(Rice::Array &array, bool clearArray=false){
+    Diffs diffs;
+    size_t arraySize = array.size();
+    for (size_t i = 0; i < arraySize; ++i){
+      Rice::Array rb_diff;
+      if (clearArray) {
+        rb_diff = from_ruby<Rice::Array>(array.shift());
+      } else {
+        rb_diff = from_ruby<Rice::Array>(array[i]);
+      }
+
+      Operation op;
+      switch (from_ruby<int>(rb_diff[0])) {
+        case 1:
+          op = INSERT;
+          break;
+        case 0:
+          op = EQUAL;
+          break;
+        case -1:
+          op = DELETE;
+          break;
+      }
+      diffs.push_back(dmp::Diff(op, from_ruby<std::string>(rb_diff[1])));
+
+    }
+    return diffs;
+  }
+
+  Rice::Array rubyArrayFromDiffsWithArray(dmp::Diffs diffs, Rice::Array &out){
+    Diffs::iterator current_diff;
+    for (current_diff = diffs.begin(); current_diff != diffs.end(); ++current_diff) {
+      Rice::Array rb_diff;
+      switch (current_diff->operation){
+        case INSERT:
+          rb_diff.push(1);
+          break;
+        case DELETE:
+          rb_diff.push(-1);
+          break;
+        case EQUAL:
+          rb_diff.push(0);
+          break;
+      }
+      rb_diff.push(current_diff->text);
+      out.push(rb_diff);
+    }
+      
+    return out;
+  }
+
+  Rice::Array rubyArrayFromDiffs(const dmp::Diffs &diffs){
+    Rice::Array out;
+    return rubyArrayFromDiffsWithArray(diffs, out);
+  }
+
+  Rice::Array rubyArrayFromPatches(Patches &patches){
+    Rice::Array out;
+    Patches::iterator current_patch = patches.begin();
+    for (current_patch = patches.begin(); current_patch != patches.end(); ++current_patch){
+      rb_patch_wrapper patch = rb_patch_wrapper(*current_patch);
+      out.push(patch);
+    }
+    return out;
+  }
+
+  Patches patchesFromRubyArray(Rice::Array &array){
+    Patches patches;
+    for (size_t i = 0; i < array.size(); ++i) {
+      rb_patch_wrapper wrapper = from_ruby<rb_patch_wrapper>(array[i]);
+      patches.push_back(wrapper.patch);
+    }
+    return patches;
+  }
+
+public:
+
+  rb_diff_match_patch(){}
+  
+  Rice::Object rb_diff_main(const std::string &text1, const std::string &text2, bool checklines=false){
+    Diffs diffs = diff_main(text1, text2, checklines);
+    return rubyArrayFromDiffs(diffs);
+  }
+
+  float GetDiff_Timeout(){
+    return Diff_Timeout;
+  }
+
+  void SetDiff_Timeout(float value){
+    Diff_Timeout = value;
+  }
+
+  float GetDiff_EditCost(){
+    return Diff_EditCost;
+  }
+
+  void SetDiff_EditCost(float value){
+    Diff_EditCost = value;
+  }
+
+  Rice::Array rb_diff_cleanupSemantic(Rice::Array array){
+    Diffs diffs = diffsFromRubyArray(array, true);
+    diff_cleanupSemantic(diffs);
+    return rubyArrayFromDiffsWithArray(diffs, array);
+  }
+
+  Rice::Array rb_diff_cleanupEfficiency(Rice::Array array){
+    Diffs diffs = diffsFromRubyArray(array, true);
+    diff_cleanupEfficiency(diffs);
+    return rubyArrayFromDiffsWithArray(diffs, array);
+  }
+
+  int rb_diff_levenshtein(Rice::Array array){
+    Diffs diffs = diffsFromRubyArray(array);
+    return diff_levenshtein(diffs);
+  }
+
+  std::string rb_diff_prettyHtml(Rice::Array array){
+    Diffs diffs = diffsFromRubyArray(array);
+    return diff_prettyHtml(diffs);
+  }
+
+  int rb_match_main(const string_t &text, const string_t &pattern, int loc) const {
+    return match_main(text, pattern, loc);
+  }
+
+  float GetMatch_Threshold(){
+    return Match_Threshold;
+  }
+
+  void SetMatch_Threshold(float value){
+    Match_Threshold = value;
+  }
+
+  int GetMatch_Distance(){
+    return Match_Distance;
+  }
+
+  void SetMatch_Distance(int value){
+    Match_Distance = value;
+  }
+
+  float GetPatch_DeleteThreshold(){
+    return Patch_DeleteThreshold;
+  }
+
+  void SetPatch_DeleteThreshold(float value){
+    Patch_DeleteThreshold = value;
+  }
+
+  Rice::Array rb_patch_fromText(const std::string &str){
+    Patches patches = patch_fromText(str);
+    return rubyArrayFromPatches(patches);
+  }
+
+  std::string rb_patch_toText(Rice::Array array){
+    Patches patches = patchesFromRubyArray(array);
+    return patch_toText(patches);
+  }
+
+  Rice::Array rb_patch_make_from_texts(std::string text1, std::string text2){
+    Patches patches = patch_make(text1, text2);
+    return rubyArrayFromPatches(patches);
+  }
+
+  Rice::Array rb_patch_make_from_diffs(Rice::Array array){
+    Diffs diffs = diffsFromRubyArray(array);
+    Patches patches = patch_make(diffs);
+    return rubyArrayFromPatches(patches);
+  }
+
+  Rice::Array rb_patch_make_from_text_and_diff(std::string text1, Rice::Array array){
+    Diffs diffs = diffsFromRubyArray(array);
+    Patches patches = patch_make(text1, diffs);
+    return rubyArrayFromPatches(patches);
+  }
+
+  Rice::Array rb_patch_apply(Rice::Array patch_array, std::string text_1){
+    Patches patches = patchesFromRubyArray(patch_array);
+    std::pair<std::string, std::vector<bool> > results = patch_apply(patches,text_1);
+    Rice::Array out;
+    out.push(results.first);
+    
+    Rice::Array bool_array;
+    for (size_t i = 0; i < results.second.size(); ++i){
+      bool_array.push(results.second[i] ? true : false);
+    }
+    out.push(bool_array);
+    
+    return out;
+  }
+
+};
+
+void register_dmp(){
+
+  Rice::Data_Type< rb_diff_match_patch > rb_cDMP = Rice::define_class< rb_diff_match_patch >("DiffMatchPatch");
+  rb_cDMP.define_constructor(Rice::Constructor<rb_diff_match_patch>());
+
+  rb_cDMP.define_method("diff_main", &rb_diff_match_patch::rb_diff_main);
+  rb_cDMP.define_method("diff_timeout", &rb_diff_match_patch::GetDiff_Timeout);
+  rb_cDMP.define_method("diff_timeout=", &rb_diff_match_patch::SetDiff_Timeout);
+  rb_cDMP.define_method("diff_edit_cost", &rb_diff_match_patch::GetDiff_EditCost);
+  rb_cDMP.define_method("diff_edit_cost=", &rb_diff_match_patch::SetDiff_EditCost);
+  rb_cDMP.define_method("diff_cleanup_semantic!", &rb_diff_match_patch::rb_diff_cleanupSemantic);
+  rb_cDMP.define_method("diff_cleanup_efficiency!", &rb_diff_match_patch::rb_diff_cleanupEfficiency);
+  rb_cDMP.define_method("diff_levenshtein", &rb_diff_match_patch::rb_diff_levenshtein);
+  rb_cDMP.define_method("diff_pretty_html", &rb_diff_match_patch::rb_diff_prettyHtml);
+
+  rb_cDMP.define_method("match_main", &rb_diff_match_patch::rb_match_main);
+  rb_cDMP.define_method("match_threshold", &rb_diff_match_patch::GetMatch_Threshold);
+  rb_cDMP.define_method("match_threshold=", &rb_diff_match_patch::SetMatch_Threshold);
+  rb_cDMP.define_method("match_distance", &rb_diff_match_patch::GetMatch_Distance);
+  rb_cDMP.define_method("match_distance=", &rb_diff_match_patch::SetMatch_Distance);
+
+  rb_cDMP.define_method("patch_delete_threshold", &rb_diff_match_patch::GetPatch_DeleteThreshold);
+  rb_cDMP.define_method("patch_delete_threshold=", &rb_diff_match_patch::SetPatch_DeleteThreshold);
+  rb_cDMP.define_method("patch_from_text", &rb_diff_match_patch::rb_patch_fromText);
+  rb_cDMP.define_method("patch_to_text", &rb_diff_match_patch::rb_patch_toText);
+  rb_cDMP.define_method("__patch_make_from_texts__", &rb_diff_match_patch::rb_patch_make_from_texts);
+  rb_cDMP.define_method("__patch_make_from_diffs__", &rb_diff_match_patch::rb_patch_make_from_diffs);
+  rb_cDMP.define_method("__patch_make_from_text_and_diff__", &rb_diff_match_patch::rb_patch_make_from_text_and_diff);
+  rb_cDMP.define_method("patch_apply", &rb_diff_match_patch::rb_patch_apply);
+
+  Rice::Data_Type< rb_patch_wrapper > rb_cPatch = Rice::define_class< rb_patch_wrapper >("Patch");
+  rb_cPatch.define_method("to_string", &rb_patch_wrapper::toString);
+  rb_cPatch.define_method("is_null?", &rb_patch_wrapper::isNull);
+  rb_cPatch.define_method("start_1", &rb_patch_wrapper::start1);
+  rb_cPatch.define_method("start_2", &rb_patch_wrapper::start2);
+  rb_cPatch.define_method("length_1", &rb_patch_wrapper::length1);
+  rb_cPatch.define_method("length_2", &rb_patch_wrapper::length2);
+
+}
+
+#undef dmp

data/ext/diff_match_patch/_dmp.h

@@ -0,0 +1,16 @@
+#ifndef ruby_DMP_HPP
+#define ruby_DMP_HPP
+
+#include <rice/Object.hpp>
+#include <rice/Data_Type.hpp>
+#include <rice/Array.hpp> 
+#include "diff_match_patch-stl/diff_match_patch.h"
+#include <string>
+#include <rice/Constructor.hpp>
+
+#define dmp diff_match_patch<std::string>
+
+
+void register_dmp();
+
+#endif

data/ext/diff_match_patch/diff_match_patch.cpp

@@ -0,0 +1,10 @@
+#include <rice/Module.hpp>
+#include "_dmp.h"
+
+extern "C"
+
+void Init_diff_match_patch() {
+  RUBY_TRY {
+    register_dmp();
+  } RUBY_CATCH
+}

data/ext/diff_match_patch/extconf.rb

@@ -0,0 +1,8 @@
+# Compile with Rice rather than straight mkmf
+require 'rubygems'
+require 'mkmf-rice'
+
+dmp_stl_path = File.join(File.dirname(File.expand_path(__FILE__)), '..', '..', 'src', 'include')
+$INCFLAGS << " " << "-I#{dmp_stl_path}".quote
+
+create_makefile("diff_match_patch/diff_match_patch")

data/lib/diff_match_patch.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'diff_match_patch', 'diff_match_patch')
+class DiffMatchPatch
+  VERSION = '1.0.0'
+
+  def patch_make(*args)
+    case 
+    when args[0].kind_of?(String) && args[1].kind_of?(String)
+      __patch_make_from_texts__(args[0], args[1])
+    when args[0].kind_of?(String) && args[1].kind_of?(Array)
+      __patch_make_from_text_and_diff__(args[0], args[1])
+    when args[0].kind_of?(Array) && args[1].nil?
+      __patch_make_from_diffs__(args[0])
+    else
+      raise ArgumentError.new "patch_make accepts two strings, a string and a diff, or a set of diffs only"
+    end
+  end
+
+end