Update flay and remove code pushed upstream.

This code also adds a bunch of node names to Sexp::NODE_NAMES for JS
and PHP. It is probably not exhaustive.

Author: zenspider

Gemfile

@@ -2,7 +2,7 @@
 source "https://rubygems.org"
 
 gem "concurrent-ruby", "~> 1.0.0"
-gem "flay"
+gem "flay", "~> 2.9"
 gem "json"
 
 group :test do

Gemfile.lock

@@ -5,7 +5,7 @@ GEM
     concurrent-ruby (1.0.0)
     diff-lcs (1.2.5)
     erubis (2.7.0)
-    flay (2.8.1)
+    flay (2.9.0)
       erubis (~> 2.7.0)
       path_expander (~> 1.0)
       ruby_parser (~> 3.0)
@@ -31,17 +31,17 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.3.0)
     rspec-support (3.3.0)
-    ruby_parser (3.8.4)
+    ruby_parser (3.9.0)
       sexp_processor (~> 4.1)
-    sexp_processor (4.8.0)
+    sexp_processor (4.9.0)
     slop (3.6.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   concurrent-ruby (~> 1.0.0)
-  flay
+  flay (~> 2.9)
   json
   pry
   rake

lib/ccflay.rb

@@ -18,71 +18,54 @@ def initialize(option = nil)
     self.identical = Concurrent::Hash.new
     self.masses = Concurrent::Hash.new
   end
-
-  ##
-  # Calculate the structural hash for this sexp. Cached, so don't
-  # modify the sexp afterwards and expect it to be correct.
-
-  if ENV["PURE_HASH"]
-    def structural_hash
-      @structural_hash ||= pure_ruby_hash
-    end
-  else
-    def structural_hash
-      @structural_hash ||= Digest::MD5.hexdigest(structure.to_s)
-    end
-  end
 end
 
-# TODO: move this to flay proper... it's benchmarking faster
-class Sexp # straight from flay-persistent
-  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 kwarg kwsplat safe_call]
-
-  ##
-  # 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] }]
-
-  NODE_NAMES.default_proc = lambda { |h, k|
-    $stderr.puts "ERROR: couldn't find node type #{k} in Sexp::NODE_NAMES."
-    h[k] = NODE_NAMES.size
-  }
-
-  MAX_INT32 = 2**32 - 1 # :nodoc:
-
-  def pure_ruby_hash # :nodoc: see above
-    hash = 0
-
-    n = NODE_NAMES.fetch first
-
-    raise "Bad lookup: #{first} in #{sexp.inspect}" unless n
-
-    hash += n & MAX_INT32
-    hash += hash << 10 & MAX_INT32
-    hash ^= hash >> 6 & MAX_INT32
-
-    each do |o|
-      next unless o.is_a? Sexp
-      hash = hash + o.pure_ruby_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
+new_nodes = [
+             :And, :ArrayExpression, :ArrowFunctionExpression,
+             :Assign, :AssignmentExpression, :AssignmentPattern,
+             :Attribute, :BinaryExpression, :BlockStatement, :BoolOp,
+             :BooleanLiteral, :Break, :BreakStatement, :Call,
+             :CallExpression, :CatchClause, :ClassBody,
+             :ClassDeclaration, :ClassMethod, :Compare,
+             :ConditionalExpression, :Continue, :ContinueStatement,
+             :Dict, :Directive, :DirectiveLiteral, :DirectiveLiteral,
+             :DoWhileStatement, :EmptyStatement, :Eq, :ExceptHandler,
+             :ExportDefaultDeclaration, :ExportNamedDeclaration,
+             :ExportSpecifier, :Expr, :ExpressionStatement, :For,
+             :ForInStatement, :ForStatement, :FunctionDeclaration,
+             :FunctionDef, :FunctionExpression, :Gt, :Identifier, :If,
+             :IfExp, :IfStatement, :Import, :ImportDeclaration,
+             :ImportDefaultSpecifier, :ImportFrom, :ImportSpecifier,
+             :Index, :LabeledStatement, :LogicalExpression, :LtE,
+             :MemberExpression, :Name, :NewExpression, :NotIn,
+             :NullLiteral, :Num, :NumericLiteral, :ObjectExpression,
+             :ObjectMethod, :ObjectPattern, :ObjectProperty, :Or,
+             :Print, :RegExpLiteral, :ReturnStatement,
+             :SequenceExpression, :Slice, :Str, :StringLiteral,
+             :Subscript, :Super, :SwitchCase, :SwitchStatement,
+             :TaggedTemplateExpression, :TemplateElement,
+             :TemplateLiteral, :ThisExpression, :ThrowStatement,
+             :TryExcept, :TryStatement, :Tuple, :UnaryExpression,
+             :UpdateExpression, :VariableDeclaration,
+             :VariableDeclarator, :WhileStatement, :Yield, :alternate,
+             :argument, :arguments, :array_dim_fetch, :assign,
+             :assign_op_minus, :binary_op_bitwise_and,
+             :binary_op_bitwise_or, :binary_op_concat,
+             :binary_op_shift_right, :binary_op_smaller_or_equal,
+             :body, :callee, :cases, :comparators, :consequent,
+             :declaration, :declarations, :directives, :elements,
+             :elts, :exp, :expression, :expressions, :extra,
+             :finalizer, :foreach, :func_call, :function, :id, :init,
+             :init, :key, :keyword, :left, :list, :lnumber, :name,
+             :object, :param, :params, :properties, :property,
+             :quasis, :right, :specifiers, :string, :superClass,
+             :target, :test, :update, :value, :values,
+             :variable
+            ]
+
+# Add known javascript and php nodes to the hash registry.
+new_nodes.each do |name|
+  Sexp::NODE_NAMES[name] = Sexp::NODE_NAMES.size
 end
 
 class Sexp
@@ -108,17 +91,3 @@ def flatter
     end
   end
 end
-
-class Sexp # TODO: push this back to flay
-  alias old_mass mass
-
-  def mass
-    @mass ||= inject(1) do |t, s|
-      if s.is_a?(Sexp)
-        t + s.mass
-      else
-        t
-      end
-    end
-  end
-end