mmullis-flay 1.4.2

data/History.txt

@@ -0,0 +1,80 @@
+=== 1.4.2 / 2011-02-18
+
+* 2 bug fixes:
+
+  * Added flay require in flay_task
+  * Switched to minitest. (doh)
+
+=== 1.4.1 / 2010-09-01
+
+* 2 minor enhancements:
+
+  * Added extra error handling for ERB flay to deal with tons of bad ERB
+  * Skip plugin if another version already loaded (eg local vs gem).
+
+* 1 bug fix:
+
+  * Fixed all tests that were having problems on 1.9 due to unstable hashes
+
+=== 1.4.0 / 2009-08-14
+
+* 4 minor enhancements:
+
+  * Pushed Sexp#mass up to sexp_processor.
+  * Removed #similarity #compare_to, #intersection, #triangle, and other cruft.
+  * Renamed all_subhashes to all_structural_subhashes.
+  * Renamed fuzzy_hash to structural_hash.
+
+=== 1.3.0 / 2009-06-23
+
+* 5 minor enhancements:
+
+  * Added --summary to display flay scores per file.
+  * Added --verbose to display processing progress.
+  * Protect against syntax errors in bad code and continue flaying.
+  * Removed fuzzy matching. Never got it to feel right. Slow. Broken on 1.9
+  * Renamed --verbose to --diff.
+
+=== 1.2.1 / 2009-03-16
+
+* 3 minor enhancements:
+
+  * Added gauntlet_flay.rb
+  * Cached value of plugins loaded.
+  * Refactored and separated analysis phase from process phase
+
+* 1 bug fix:
+
+  * Added bin dir to default dirs list in FlayTask
+
+=== 1.2.0 / 2009-03-09
+
+* 2 major enhancements:
+
+  * Added flay_task.rb
+  * Added plugin system (any flay_(c,java,js,etc).rb files).
+
+* 4 minor enhancements:
+
+  * Added expand_dirs_to_files and made dirs valid arguments.
+  * Added flay_erb.rb plugin.
+  * Added optparse option processing.
+  * Refactored to make using w/in rake and other CI systems clean and easy.
+
+=== 1.1.0 / 2009-01-20
+
+* 7 minor enhancement:
+
+  * Added -v verbose mode to print out N-way diff of the detected code.
+  * Added identical node scoring and reporting.
+  * Added the start of copy/paste+edit detection, not even close yet.
+  * Added more tests.
+  * Added rcov tasks
+  * Clarified output a bit
+  * Refactored process_sexps to make doing other languages/systems easier.
+
+=== 1.0.0 / 2008-11-06
+
+* 1 major enhancement
+
+  * Birthday!

data/Manifest.txt

@@ -0,0 +1,10 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/flay
+lib/flay.rb
+lib/flay_erb.rb
+lib/flay_task.rb
+lib/gauntlet_flay.rb
+test/test_flay.rb

data/README.txt

@@ -0,0 +1,102 @@
+= flay
+
+* http://ruby.sadi.st/
+* http://rubyforge.org/projects/seattlerb
+
+== DESCRIPTION:
+
+Flay analyzes code for structural similarities. Differences in literal
+values, variable, class, method names, whitespace, programming style,
+braces vs do/end, etc are all ignored. Making this totally rad.
+
+== FEATURES/PROBLEMS:
+
+* Plugin system allows other languages to be flayed.
+  * Ships with .rb and .erb. javascript and others will be available separately.
+* Includes FlayTask for Rakefiles.
+* Differences in literal values, variable, class, and method names are ignored.
+* Differences in whitespace, programming style, braces vs do/end, etc are ignored.
+* Works across files.
+* Reports differences at any level of code.
+* Totally rad.
+* Adds a score multiplier to identical nodes.
+* Run verbose to see an N-way diff of the code.
+
+== TODO:
+
+* Editor integration (emacs, textmate, other contributions welcome).
+* Score sequence fragments (a;b;c;d;e) vs (b;c;d) etc.
+
+== SYNOPSIS:
+
+  % flay -v ~/Work/svn/ruby/ruby_1_8/lib/cgi.rb
+  Processing /Users/ryan/Work/svn/ruby/ruby_1_8/lib/cgi.rb...
+  
+  Matches found in :defn (mass = 184)
+    A: /Users/ryan/Work/svn/ruby/ruby_1_8/lib/cgi.rb:1470
+    B: /Users/ryan/Work/svn/ruby/ruby_1_8/lib/cgi.rb:1925
+  
+  A: def checkbox_group(name = "", *values)
+  B: def radio_group(name = "", *values)
+       if name.kind_of?(Hash) then
+         values = name["VALUES"]
+         name = name["NAME"]
+       end
+       values.collect do |value|
+         if value.kind_of?(String) then
+  A:       (checkbox(name, value) + value)
+  B:       (radio_button(name, value) + value)
+         else
+           if (value[(value.size - 1)] == true) then
+  A:         (checkbox(name, value[0], true) + value[(value.size - 2)])
+  B:         (radio_button(name, value[0], true) + value[(value.size - 2)])
+           else
+  A:         (checkbox(name, value[0]) + value[(value.size - 1)])
+  B:         (radio_button(name, value[0]) + value[(value.size - 1)])
+           end
+         end
+       end.to_s
+     end
+  
+  IDENTICAL Matches found in :for (mass*2 = 144)
+    A: /Users/ryan/Work/svn/ruby/ruby_1_8/lib/cgi.rb:2160
+    B: /Users/ryan/Work/svn/ruby/ruby_1_8/lib/cgi.rb:2217
+  
+     for element in ["HTML", "BODY", "P", "DT", "DD", "LI", "OPTION", "THEAD", "TFOOT", "TBODY", "COLGROUP", "TR", "TH", "TD", "HEAD"] do
+       methods = (methods + (("          def #{element.downcase}(attributes = {})\n" + nO_element_def(element)) + "          end\n"))
+     end
+  ...
+
+== REQUIREMENTS:
+
+* ruby_parser
+* sexp_processor
+
+== INSTALL:
+
+* sudo gem install flay
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008-2009 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,22 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe::add_include_dirs(".",
+                      "../../sexp_processor/dev/lib",
+                      "../../ruby_parser/dev/lib")
+
+Hoe.plugin :seattlerb
+
+Hoe.spec 'flay' do
+  developer 'Ryan Davis', 'ryand-ruby@zenspider.com'
+
+  self.rubyforge_name = 'seattlerb'
+  self.flay_threshold = 250
+
+  extra_deps << ['sexp_processor', '~> 3.0']
+  extra_deps << ['ruby_parser',    '~> 2.0']
+end
+
+# vim: syntax=ruby

data/VERSION

@@ -0,0 +1 @@
+1.4.2

data/bin/flay

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby
+
+require 'flay'
+
+flay = Flay.new Flay.parse_options
+
+ARGV << '.' if ARGV.empty?
+files = Flay.expand_dirs_to_files(*ARGV)
+
+flay.process(*files)
+flay.report

data/lib/flay.rb

@@ -0,0 +1,326 @@
+#!/usr/bin/env ruby -w
+
+$: << "../../ruby_parser/dev/lib"
+$: << "../../ruby2ruby/dev/lib"
+
+require 'optparse'
+require 'rubygems'
+require 'sexp_processor'
+require 'ruby_parser'
+
+class Flay
+  VERSION = '1.4.2'
+
+  def self.default_options
+    {
+      :diff    => false,
+      :mass    => 16,
+      :summary => false,
+      :verbose => false,
+    }
+  end
+
+  def self.parse_options
+    options = self.default_options
+
+    OptionParser.new do |opts|
+      opts.banner  = 'flay [options] files_or_dirs'
+      opts.version = Flay::VERSION
+
+      opts.separator ""
+      opts.separator "Specific options:"
+      opts.separator ""
+
+      opts.on('-h', '--help', 'Display this help.') do
+        puts opts
+        exit
+      end
+
+      opts.on('-f', '--fuzzy', "DEAD: fuzzy similarities.") do
+        abort "--fuzzy is no longer supported. Sorry. It sucked."
+      end
+
+      opts.on('-m', '--mass MASS', Integer, "Sets mass threshold") do |m|
+        options[:mass] = m.to_i
+      end
+
+      opts.on('-v', '--verbose', "Verbose. Show progress processing files.") do
+        options[:verbose] = true
+      end
+
+      opts.on('-d', '--diff', "Diff Mode. Display N-Way diff for ruby.") do
+        options[:diff] = true
+      end
+
+      opts.on('-s', '--summary', "Summarize. Show flay score per file only.") do
+        options[:summary] = true
+      end
+
+      extensions = ['rb'] + Flay.load_plugins
+
+      opts.separator ""
+      opts.separator "Known extensions: #{extensions.join(', ')}"
+
+      begin
+        opts.parse!
+      rescue => e
+        abort "#{e}\n\n#{opts}"
+      end
+    end
+
+    options
+  end
+
+  def self.expand_dirs_to_files *dirs
+    extensions = ['rb'] + Flay.load_plugins
+
+    dirs.flatten.map { |p|
+      if File.directory? p then
+        Dir[File.join(p, '**', "*.{#{extensions.join(',')}}")]
+      else
+        p
+      end
+    }.flatten
+  end
+
+  def self.load_plugins
+    unless defined? @@plugins then
+      @@plugins = []
+
+      plugins = Gem.find_files("flay_*.rb").reject { |p| p =~ /flay_task/ }
+
+      plugins.each do |plugin|
+        plugin_name = File.basename(plugin, '.rb').sub(/^flay_/, '')
+        next if @@plugins.include? plugin_name
+        begin
+          load plugin
+          @@plugins << plugin_name
+        rescue LoadError => e
+          warn "error loading #{plugin.inspect}: #{e.message}. skipping..."
+        end
+      end
+    end
+    @@plugins
+  rescue
+    # ignore
+  end
+
+  attr_accessor :mass_threshold, :total, :identical, :masses
+  attr_reader :hashes, :option
+
+  def initialize option = nil
+    @option = option || Flay.default_options
+    @hashes = Hash.new { |h,k| h[k] = [] }
+
+    self.identical      = {}
+    self.masses         = {}
+    self.total          = 0
+    self.mass_threshold = @option[:mass]
+
+    require 'ruby2ruby' if @option[:diff]
+  end
+
+  def process(*files) # TODO: rename from process - should act as SexpProcessor
+    files.each do |file|
+      warn "Processing #{file}" if option[:verbose]
+
+      ext = File.extname(file).sub(/^\./, '')
+      ext = "rb" if ext.nil? || ext.empty?
+      msg = "process_#{ext}"
+
+      unless respond_to? msg then
+        warn "  Unknown file type: #{ext}, defaulting to ruby"
+        msg = "process_rb"
+      end
+
+      begin
+        sexp = begin
+                 send msg, file
+               rescue => e
+                 warn "  #{e.message.strip}"
+                 warn "  skipping #{file}"
+                 nil
+               end
+
+        next unless sexp
+
+        process_sexp sexp
+      rescue SyntaxError => e
+        warn "  skipping #{file}: #{e.message}"
+      end
+    end
+
+    analyze
+  end
+
+  def analyze
+    self.prune
+
+    self.hashes.each do |hash,nodes|
+      identical[hash] = nodes[1..-1].all? { |n| n == nodes.first }
+      masses[hash] = nodes.first.mass * nodes.size
+      masses[hash] *= (nodes.size) if identical[hash]
+      self.total += masses[hash]
+    end
+  end
+
+  def process_rb file
+    RubyParser.new.process(File.read(file), file)
+  end
+
+  def process_sexp pt
+    pt.deep_each do |node|
+      next unless node.any? { |sub| Sexp === sub }
+      next if node.mass < self.mass_threshold
+
+      self.hashes[node.structural_hash] << node
+    end
+  end
+
+  def prune
+    # prune trees that aren't duped at all, or are too small
+    self.hashes.delete_if { |_,nodes| nodes.size == 1 }
+
+    # extract all subtree hashes from all nodes
+    all_hashes = {}
+    self.hashes.values.each do |nodes|
+      nodes.each do |node|
+        node.all_structural_subhashes.each do |h|
+          all_hashes[h] = true
+        end
+      end
+    end
+
+    # nuke subtrees so we show the biggest matching tree possible
+    self.hashes.delete_if { |h,_| all_hashes[h] }
+  end
+
+  def n_way_diff *data
+    data.each_with_index do |s, i|
+      c = (?A.ord + i).chr
+      s.group = c
+    end
+
+    max = data.map { |s| s.scan(/^.*/).size }.max
+
+    data.map! { |s| # FIX: this is tarded, but I'm out of brain
+      c = s.group
+      s = s.scan(/^.*/)
+      s.push(*([""] * (max - s.size))) # pad
+      s.each do |o|
+        o.group = c
+      end
+      s
+    }
+
+    groups = data[0].zip(*data[1..-1])
+    groups.map! { |lines|
+      collapsed = lines.uniq
+      if collapsed.size == 1 then
+        "   #{lines.first}"
+      else
+        # TODO: make r2r have a canonical mode (doesn't make 1-liners)
+        lines.reject { |l| l.empty? }.map { |l| "#{l.group}: #{l}" }
+      end
+    }
+    groups.flatten.join("\n")
+  end
+
+  def summary
+    score = Hash.new 0
+
+    masses.each do |hash, mass|
+      sexps = hashes[hash]
+      mass_per_file = mass.to_f / sexps.size
+      sexps.each do |sexp|
+        score[sexp.file] += mass_per_file
+      end
+    end
+
+    score
+  end
+
+  def report prune = nil
+    puts "Total score (lower is better) = #{self.total}"
+    puts
+
+    if option[:summary] then
+
+      self.summary.sort_by { |_,v| -v }.each do |file, score|
+        puts "%8.2f: %s" % [score, file]
+      end
+
+      return
+    end
+
+    count = 0
+    masses.sort_by { |h,m| [-m, hashes[h].first.file] }.each do |hash, mass|
+      nodes = hashes[hash]
+      next unless nodes.first.first == prune if prune
+      puts
+
+      same = identical[hash]
+      node = nodes.first
+      n = nodes.size
+      match, bonus = if same then
+                       ["IDENTICAL", "*#{n}"]
+                     else
+                       ["Similar",   ""]
+                     end
+
+      count += 1
+      puts "%d) %s code found in %p (mass%s = %d)" %
+        [count, match, node.first, bonus, mass]
+
+      nodes.each_with_index do |x, i|
+        if option[:diff] then
+          c = (?A.ord + i).chr
+          puts "  #{c}: #{x.file}:#{x.line}"
+        else
+          puts "  #{x.file}:#{x.line}"
+        end
+      end
+
+      if option[:diff] then
+        puts
+        r2r = Ruby2Ruby.new
+        puts n_way_diff(*nodes.map { |s| r2r.process(s.deep_clone) })
+      end
+    end
+  end
+end
+
+class String
+  attr_accessor :group
+end
+
+class Sexp
+  def structural_hash
+    @structural_hash ||= self.structure.hash
+  end
+
+  def all_structural_subhashes
+    hashes = []
+    self.deep_each do |node|
+      hashes << node.structural_hash
+    end
+    hashes
+  end
+
+  # REFACTOR: move to sexp.rb
+  def deep_each(&block)
+    self.each_sexp do |sexp|
+      block[sexp]
+      sexp.deep_each(&block)
+    end
+  end
+
+  # REFACTOR: move to sexp.rb
+  def each_sexp
+    self.each do |sexp|
+      next unless Sexp === sexp
+
+      yield sexp
+    end
+  end
+end

data/lib/flay_erb.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'flay'
+require 'erb'
+
+class Flay
+  def process_erb file
+    erb = File.read file
+
+    ruby = ERB.new(erb).src
+    begin
+      RubyParser.new.process(ruby, file)
+    rescue => e
+      warn ruby if option[:verbose]
+      raise e
+    end
+  end
+end

data/lib/flay_task.rb

@@ -0,0 +1,33 @@
+class FlayTask < Rake::TaskLib
+  attr_accessor :name
+  attr_accessor :dirs
+  attr_accessor :threshold
+  attr_accessor :verbose
+
+  def initialize name = :flay, threshold = 200, dirs = nil
+    @name      = name
+    @dirs      = dirs || %w(app bin lib spec test)
+    @threshold = threshold
+    @verbose   = Rake.application.options.trace
+
+    yield self if block_given?
+
+    @dirs.reject! { |f| ! File.directory? f }
+
+    define
+  end
+
+  def define
+    desc "Analyze for code duplication in: #{dirs.join(', ')}"
+    task name do
+      require "flay"
+      flay = Flay.new
+      flay.process(*Flay.expand_dirs_to_files(dirs))
+      flay.report if verbose
+
+      raise "Flay total too high! #{flay.total} > #{threshold}" if
+        flay.total > threshold
+    end
+    self
+  end
+end

data/lib/gauntlet_flay.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/ruby -ws
+
+$: << 'lib' << '../../ParseTree/dev/lib' << '../../flay/dev/lib'
+
+$v ||= false # HACK
+
+require 'rubygems'
+require 'flay'
+
+require 'gauntlet'
+require 'pp'
+
+class FlayGauntlet < Gauntlet
+  $owners       = {}
+  $score_file   = 'flay-scores.yml'
+  $misc_error   = {:total => -1, :average => -1, :methods => {}}
+  $syntax_error = {:total => -2, :average => -2, :methods => {}}
+  $no_gem       = {:total => -4, :average => -4, :methods => {}}
+
+  # copied straight from hoedown.rb 
+  my_projects = %w[InlineFortran ParseTree RubyInline RubyToC
+                   ZenHacks ZenTest bfts box_layout
+                   change_class flay flog gauntlet heckle
+                   hoe image_science miniunit minitest
+                   minitest_tu_shim png ruby2ruby ruby_parser
+                   rubyforge test-unit un vlad zenprofile
+                   zentest]
+
+  MY_PROJECTS = Regexp.union(*my_projects)
+
+  def run name
+    warn name
+    self.data[name] = score_for '.'
+    self.dirty = true
+  end
+
+  def display_report max
+    good_data  = {}
+    bad_count  = 0
+    zero_count = 0
+
+    @data.each do |name, flay|
+      case
+      when flay < 0 then
+        bad_count += 1
+      when flay == 0 then
+        zero_count += 1
+      else
+        good_data[name] = flay
+      end
+    end
+
+    scores = good_data.values
+
+    # SWEET JESUS:
+    #
+    # without zeros:
+    #   average flay: 1487.23 +/- 7800.16
+    # with zeros:
+    #   average flay:  988.69 +/- 6398.45
+
+    puts "broken projects : %d" % bad_count
+    puts "great projects  : %d" % zero_count
+    puts "bad projects    : %d" % good_data.size
+    puts "average flay    : %.2f +/- %.2f" % [scores.average, scores.stddev]
+
+    top = good_data.sort_by { |name,flay| -flay }.first max
+
+    puts
+    top.each_with_index do |(name, flay), i|
+      puts "%3d: %10.2f: %s" % [ i, flay, name ]
+    end
+  end
+
+  ############################################################
+  # OTHER
+  ############################################################
+
+  def score_for dir
+    # files = `find #{dir} -name \\*.rb | grep -v gen.*templ`.split(/\n/)
+    flayer = Flay.new
+
+    dirs = %w(app lib test spec).reject { |f| ! File.directory? f }
+
+    flay = Flay.new
+    flay.process(*Flay.expand_dirs_to_files(dirs))
+    flay.total
+  rescue Interrupt
+    # let us break out
+  rescue Exception
+    -1
+  end
+end
+
+max    = (ARGV.shift || 10).to_i
+filter = ARGV.shift
+filter = Regexp.new filter if filter
+flayer = FlayGauntlet.new
+flayer.run_the_gauntlet filter
+flayer.display_report max

data/test/test_flay.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/ruby -w
+
+require 'minitest/autorun'
+require 'flay'
+
+$: << "../../sexp_processor/dev/lib"
+
+class TestSexp < MiniTest::Unit::TestCase
+  def setup
+    # a(1) { |c| d }
+    @s = s(:iter,
+           s(:call, nil, :a, s(:arglist, s(:lit, 1))),
+           s(:lasgn, :c),
+           s(:call, nil, :d, s(:arglist)))
+  end
+
+  def test_structural_hash
+    hash = s(:iter,
+             s(:call, s(:arglist, s(:lit))),
+             s(:lasgn),
+             s(:call, s(:arglist))).hash
+
+    assert_equal hash, @s.structural_hash
+    assert_equal hash, @s.deep_clone.structural_hash
+  end
+
+  def test_all_structural_subhashes
+    s = s(:iter,
+          s(:call, s(:arglist, s(:lit))),
+          s(:lasgn),
+          s(:call, s(:arglist)))
+
+    expected = [
+                s[1]      .hash,
+                s[1][1]   .hash,
+                s[1][1][1].hash,
+                s[2]      .hash,
+                s[3]      .hash,
+                s[3][1]   .hash,
+               ].sort
+
+    assert_equal expected, @s.all_structural_subhashes.sort.uniq
+
+    x = []
+
+    @s.deep_each do |o|
+      x << o.structural_hash
+    end
+
+    assert_equal expected, x.sort.uniq
+  end
+
+  def test_process_sexp
+    flay = Flay.new
+
+    s = RubyParser.new.process <<-RUBY
+      def x(n)
+        if n % 2 == 0
+          return n
+        else
+          return n + 1
+        end
+      end
+    RUBY
+
+    expected = [[:block],
+                # HACK [:defn],
+                [:scope]] # only ones big enough
+
+    flay.process_sexp s
+
+    actual = flay.hashes.values.map { |sexps| sexps.map { |sexp| sexp.first } }
+
+    assert_equal expected, actual.sort_by { |a| a.first.to_s }
+  end
+
+  def test_process_sexp_full
+    flay = Flay.new(:mass => 1)
+
+    s = RubyParser.new.process <<-RUBY
+      def x(n)
+        if n % 2 == 0
+          return n
+        else
+          return n + 1
+        end
+      end
+    RUBY
+
+    expected = [[:arglist, :arglist, :arglist],
+                [:block],
+                [:call, :call],
+                [:call],
+                [:if],
+                [:return],
+                [:return],
+                [:scope]]
+
+    flay.process_sexp s
+
+    actual = flay.hashes.values.map { |sexps| sexps.map { |sexp| sexp.first } }
+
+    assert_equal expected, actual.sort_by { |a| a.inspect }
+  end
+
+  def test_process_sexp_no_structure
+    flay = Flay.new(:mass => 1)
+    flay.process_sexp s(:lit, 1)
+
+    assert flay.hashes.empty?
+  end
+
+  def test_report
+    # make sure we run through options parser
+    $*.clear
+    $* << "-d"
+    $* << "--mass=1"
+    $* << "-v"
+
+    flay = Flay.new Flay.parse_options
+
+    s = RubyParser.new.process <<-RUBY
+      class Dog
+        def x
+          return "Hello"
+        end
+      end
+      class Cat
+        def y
+          return "Hello"
+        end
+      end
+    RUBY
+
+    flay.process_sexp s
+    flay.analyze
+    flay.report
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: mmullis-flay
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.4.2
+platform: ruby
+authors: 
+- Ryan Davis
+- Seattle.rb
+- Michael Mullis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-04 00:00:00 -05:00
+default_executable: flay
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sexp_processor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby_parser
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id002
+description: Flay fork with modifications to run on 1.9.2
+email: michael@mullistechnologies.com
+executables: 
+- flay
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- VERSION
+- bin/flay
+- lib/flay.rb
+- lib/flay_erb.rb
+- lib/flay_task.rb
+- lib/gauntlet_flay.rb
+- test/test_flay.rb
+has_rdoc: true
+homepage: http://github.com/mmullis/flay
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Flay fork with 1.9.2 Repairs
+test_files: 
+- test/test_flay.rb