flay-persistence 1.0.0

data.tar.gz.sig

@@ -0,0 +1,3 @@
+r���W�U�<�4����a��'6��%�c J/J=�/'u��ȡZI�V���yDQ_��L���ۇ�-L��:v��?�a�H�҄��
+��鷩�`�BOS���7Vxr�@5y�0������3��j'�`j�k��i�d�1�`Y^lF^���v�����Y&Z$&���qz�ߟ�
+O�m_���*V'�څ�	��

data/.autotest

@@ -0,0 +1,26 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = "minitest/autorun"
+  at.add_exception "tmp"
+
+  # at.extra_files << "../some/external/dependency.rb"
+  #
+  # at.libs << ":../some/external"
+  #
+  # at.add_exception "vendor"
+  #
+  # at.add_mapping(/dependency.rb/) do |f, _|
+  #   at.files_matching(/test_.*rb$/)
+  # end
+  #
+  # %w(TestA TestB).each do |klass|
+  #   at.extra_class_map[klass] = "test/test_misc.rb"
+  # end
+end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2013-02-13
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/flay_persistence.rb
+lib/stable_hash.rb
+test/flay/test_persistence.rb

data/README.txt

@@ -0,0 +1,56 @@
+= flay-persistence
+
+home :: https://github.com/seattlerb/flay-persistence
+rdoc :: http://docs.seattlerb.org/flay-persistence
+
+== DESCRIPTION:
+
+Did you ever want to make your flay results persistent?!? Me neither,
+but now you can! This flay plugin allows you to run flay across
+multiple runs combining and persisting the results. This allows you to
+detect plagiarism or good gem candidates across multiple projects.
+
+== FEATURES/PROBLEMS:
+
+* Adds -p flag to persist data on a file-by-file basis.
+* Adds -r flag to re-run against already scanned files.
+* Currently uses Marshal to persist... This begs for maglev.
+
+== SYNOPSIS:
+
+  % flay -p some_project
+  % flay -p -r other_project # redo already scanned files with -r
+  % flay -p                  # just show the persisted data
+
+== REQUIREMENTS:
+
+* flay 2.1+
+
+== INSTALL:
+
+* sudo gem install flay-persistence
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) Ryan Davis, seattle.rb
+
+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,19 @@
+# -*- ruby -*-
+
+require "rubygems"
+require "hoe"
+
+Hoe.add_include_dirs "../../flay/dev/lib"
+
+Hoe.plugin :isolate
+Hoe.plugin :seattlerb
+
+Hoe.spec "flay-persistence" do
+  developer "Ryan Davis", "ryand-ruby@zenspider.com"
+  license "MIT"
+
+  dependency "flay", "~> 2.0" # HACK: should be 2.1
+  dependency "RubyInline", "~> 3.12"
+end
+
+# vim: syntax=ruby

data/lib/flay_persistence.rb

@@ -0,0 +1,87 @@
+require "rubygems"
+require "flay"
+
+##
+# A simple plugin that adds persistence to flay
+
+class Flay::Persistence
+  # duh
+  VERSION = "1.0.0"
+end
+
+class Flay # :nodoc:
+  def self.options_persistence op, options # :nodoc:
+    op.separator nil
+    op.separator "Persistence options:"
+    op.separator nil
+
+    options[:redo] = false
+
+    op.on("-r", "--redo", "Rerun a file already in the persistent db") do
+      options[:redo] = true
+    end
+
+    op.on("-p", "--persistent", "Use a stable hash and persist flay data.") do
+      require "stable_hash"
+
+      Sexp.send :alias_method, :old_structural_hash, :structural_hash
+      Sexp.send :alias_method, :structural_hash,     :stable_hash
+      Flay.send :alias_method, :persist_process,     :process
+      Flay.send :alias_method, :process,             :persist_hashes
+
+      options[:persistent] = true
+    end
+  end
+
+  def merge_hash h # :nodoc:
+    h.each do |code, ary|
+      self.hashes[code].concat ary
+    end
+  end
+
+  ##
+  # Overrides +process+ when the -p command-line option is used. This
+  # loads up the persisted data, runs specified files individually,
+  # merges those options with the main flay dataset, and then
+  # saves the data back out.
+  #
+  # NOTE: Currently this is using Marshal because it is cheap and
+  # easy. I don't plan for it to stay that way because it will bog
+  # down. I'm hoping to get maglev sorted out so this can run on
+  # maglev and take advantage of the transparent multi-process
+  # persistence.
+
+  def persist_hashes(*args)
+    db_path = "flay.db"
+    files = {}
+
+    if File.exist? db_path then
+      File.open db_path, "rb" do |f|
+        files = Marshal.load f
+      end
+    end
+
+    args.each do |path|
+      next if files[path] unless option[:redo]
+
+      initialize self.option
+      persist_process path
+
+      files[path] = self.hashes
+    end
+
+    initialize self.option
+
+    files.each do |_, subhashes|
+      merge_hash subhashes
+    end
+  ensure
+    files.each do |code, hash| # strip default procs for marshal... ugh
+      files[code] = {}.merge(hash)
+    end
+
+    File.open db_path, "wb" do |f|
+      Marshal.dump files, f
+    end
+  end
+end

data/lib/stable_hash.rb

@@ -0,0 +1,107 @@
+$: << "../../RubyInline/dev/lib"
+require "rubygems"
+require "inline"
+require "sexp"
+
+class Sexp # :nodoc:
+  begin
+    names = %w(alias and arglist args array attrasgn attrset back_ref
+               begin block block_pass break call case cdecl class colon2
+               colon3 const cvar cvasgn cvdecl defined defn defs dot2
+               dot3 dregx dregx_once dstr dsym dxstr ensure evstr false
+               flip2 flip3 for gasgn gvar hash iasgn if iter ivar lasgn
+               lit lvar masgn match match2 match3 module next nil not
+               nth_ref op_asgn op_asgn1 op_asgn2 op_asgn_and op_asgn_or or
+               postexe redo resbody rescue retry return sclass self
+               splat str super svalue to_ary true undef until valias
+               when while xstr yield zsuper)
+
+    ##
+    # All ruby_parser nodes in an index hash. Used by jenkins algorithm.
+
+    NODE_NAMES = Hash[names.each_with_index.map {|n, i| [n.to_sym, i] }]
+
+    ##
+    # Calculate the jenkins hash and memoize it.
+
+    def stable_hash
+      @stable_hash ||= self._stable_hash
+    end
+
+    inline :C do |b|
+      raise CompilationError if ENV["PURE_RUBY"]
+
+      b.alias_type_converter "unsigned int", "uint32_t"
+      b.map_ruby_const "Sexp", "NODE_NAMES"
+      b.add_id :grep
+
+      b.prefix <<-C
+        static uint32_t jenkins(VALUE sexp) {
+          // http://www.burtleburtle.net/bob/hash/doobs.html
+          // http://en.wikipedia.org/wiki/Jenkins_hash_function
+
+          uint32_t hash = 0;
+          VALUE n;
+          size_t max, i;
+
+          n = rb_hash_lookup(cNODE_NAMES, rb_ary_entry(sexp, 0));
+
+          if (! RTEST(n)) {
+            rb_p(sexp);
+            rb_raise(rb_eStandardError, "bad lookup");
+          }
+
+          hash += FI\X2INT(n);
+          hash += hash << 10;
+          hash ^= hash >>  6;
+
+          for (i = 0; i < RARRAY_LEN(sexp); i++) {
+            VALUE obj = RARRAY_PTR(sexp)[i];
+            if (CLASS_OF(obj) == cSexp) {
+              hash += jenkins(obj);
+              hash += hash << 10;
+              hash ^= hash >>  6;
+            }
+          }
+
+          hash += hash << 3;
+          hash ^= hash >> 11;
+          hash += hash << 15;
+
+          return hash;
+        }
+      C
+
+      b.c <<-C
+        uint32_t _stable_hash() {
+          return jenkins(self);
+        }
+      C
+    end
+  rescue CompilationError
+    MAX_INT32 = 2 ** 32 - 1 # :nodoc:
+
+    def _stable_hash # :nodoc: see above
+      hash = 0
+
+      n = NODE_NAMES.fetch first
+
+      hash += n          & MAX_INT32
+      hash += hash << 10 & MAX_INT32
+      hash ^= hash >>  6 & MAX_INT32
+
+      each do |o|
+        next unless Sexp === o
+        hash = hash + o.stable_hash  & MAX_INT32
+        hash = (hash + (hash << 10)) & MAX_INT32
+        hash = (hash ^ (hash >>  6)) & MAX_INT32
+      end
+
+      hash = (hash + (hash <<  3)) & MAX_INT32
+      hash = (hash ^ (hash >> 11)) & MAX_INT32
+      hash = (hash + (hash << 15)) & MAX_INT32
+
+      hash
+    end
+  end
+end

data/test/flay/test_persistence.rb

@@ -0,0 +1,52 @@
+require "minitest/autorun"
+require "flay"
+# require "flay_persistence" -- loaded by plugin system
+
+module TestFlay; end
+
+class TestFlay::TestPersistence < MiniTest::Unit::TestCase
+  def test_ARGH
+    persist = ENV["P"]
+
+    skip "Array#hash is buggy on 1.8" if RUBY_VERSION < "1.9" and not persist
+
+    opts = persist ? %w[-p] : []
+    opts = Flay.parse_options opts
+    flay = Flay.new opts
+
+    # from array_bare_hash_labels and proc_args_0 in pt_testcase.rb:
+
+    sexp = s(:block,
+             s(:hash,
+               s(:str),
+               s(:str),
+               s(:str),
+               s(:call,
+                 s(:lit),
+                 s(:call, s(:lit), s(:lit)),
+                 s(:call,
+                   s(:lit),
+                   s(:call, s(:lit), s(:lit)),
+                   s(:call, s(:lit), s(:lit))))),
+             s(:hash,
+               s(:str),
+               s(:str),
+               s(:str),
+               s(:call,
+                 s(:lit),
+                 s(:call, s(:lit), s(:nil), s(:lit)),
+                 s(:lit),
+                 s(:call,
+                   s(:lit),
+                   s(:call, s(:lit), s(:nil), s(:lit)),
+                   s(:lit),
+                   s(:call, s(:lit), s(:lit))))))
+
+    flay.process_sexp sexp
+
+    expect = [[:call], [:hash], [:hash]]
+    actual = flay.hashes.values.map { |ss| ss.map(&:first) }
+
+    assert_equal expect, actual.sort_by { |a| a.first.to_s }
+  end
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification 
+name: flay-persistence
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Ryan Davis
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDPjCCAiagAwIBAgIBADANBgkqhkiG9w0BAQUFADBFMRMwEQYDVQQDDApyeWFu
+  ZC1ydWJ5MRkwFwYKCZImiZPyLGQBGRYJemVuc3BpZGVyMRMwEQYKCZImiZPyLGQB
+  GRYDY29tMB4XDTA5MDMwNjE4NTMxNVoXDTEwMDMwNjE4NTMxNVowRTETMBEGA1UE
+  AwwKcnlhbmQtcnVieTEZMBcGCgmSJomT8ixkARkWCXplbnNwaWRlcjETMBEGCgmS
+  JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALda
+  b9DCgK+627gPJkB6XfjZ1itoOQvpqH1EXScSaba9/S2VF22VYQbXU1xQXL/WzCkx
+  taCPaLmfYIaFcHHCSY4hYDJijRQkLxPeB3xbOfzfLoBDbjvx5JxgJxUjmGa7xhcT
+  oOvjtt5P8+GSK9zLzxQP0gVLS/D0FmoE44XuDr3iQkVS2ujU5zZL84mMNqNB1znh
+  GiadM9GHRaDiaxuX0cIUBj19T01mVE2iymf9I6bEsiayK/n6QujtyCbTWsAS9Rqt
+  qhtV7HJxNKuPj/JFH0D2cswvzznE/a5FOYO68g+YCuFi5L8wZuuM8zzdwjrWHqSV
+  gBEfoTEGr7Zii72cx+sCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+  HQYDVR0OBBYEFEfFe9md/r/tj/Wmwpy+MI8d9k/hMA0GCSqGSIb3DQEBBQUAA4IB
+  AQAY59gYvDxqSqgC92nAP9P8dnGgfZgLxP237xS6XxFGJSghdz/nI6pusfCWKM8m
+  vzjjH2wUMSSf3tNudQ3rCGLf2epkcU13/rguI88wO6MrE0wi4ZqLQX+eZQFskJb/
+  w6x9W1ur8eR01s397LSMexySDBrJOh34cm2AlfKr/jokKCTwcM0OvVZnAutaovC0
+  l1SVZ0ecg88bsWHA0Yhh7NFxK1utWoIhtB6AFC/+trM0FQEB/jZkIS8SaNzn96Rl
+  n0sZEf77FLf5peR8TP/PtmIg7Cyqz23sLM4mCOoTGIy5OcZ8TdyiyINUHtb5ej/T
+  FBHgymkyj/AOSqKRIpXPhjC6
+  -----END CERTIFICATE-----
+
+date: 2013-02-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: flay
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 3
+        - 12
+        version: "3.12"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 4
+        - 6
+        version: "4.6"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 3
+        - 10
+        version: "3.10"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 3
+        - 5
+        version: "3.5"
+  type: :development
+  version_requirements: *id005
+description: |-
+  Did you ever want to make your flay results persistent?!? Me neither,
+  but now you can! This flay plugin allows you to run flay across
+  multiple runs combining and persisting the results. This allows you to
+  detect plagiarism or good gem candidates across multiple projects.
+email: 
+- ryand-ruby@zenspider.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/flay_persistence.rb
+- lib/stable_hash.rb
+- test/flay/test_persistence.rb
+- .gemtest
+homepage: https://github.com/seattlerb/flay-persistence
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: flay-persistence
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Did you ever want to make your flay results persistent?!? Me neither, but now you can! This flay plugin allows you to run flay across multiple runs combining and persisting the results
+test_files: 
+- test/flay/test_persistence.rb