fluoride-analyzer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29f99f8f8b407486d27622bb63af1b8bd604d87f
+  data.tar.gz: b29dacf810a25eb37374ac88532f2c09217cdd65
+SHA512:
+  metadata.gz: f6c30d82f0adbc6051ee083d9062233bd8a632832b343647acad1c97cd7a82fbb1308a11a4959be511ba29d648c859f84dd2964ffa05c8992d34bdabd8b14c93
+  data.tar.gz: 7c618c9bf042e2319e0ccb95a0fb00338a82a0daa4088827b0573df89748f0b7f0340f2cba3bf44051158a0ea1dbcc7bbf67869bf469ea428121b50b58a2430f

data/lib/fluoride-analyzer.rb

@@ -0,0 +1,14 @@
+module Fluoride
+  module Analyzer
+    class ConfigurationError < ::StandardError
+    end
+  end
+end
+
+require 'fluoride-analyzer/config'
+require 'fluoride-analyzer/request'
+require 'fluoride-analyzer/request-processor'
+require 'fluoride-analyzer/exchange-result'
+require 'fluoride-analyzer/exception-result'
+require 'fluoride-analyzer/result-collection'
+require 'fluoride-analyzer/rails' if defined?(Rails)

data/lib/fluoride-analyzer/config.rb

@@ -0,0 +1,43 @@
+module Fluoride::Analyzer
+  class Config
+    require 'yaml'
+
+    DEFAULT_CONFIG_PATH = '.fluoride.yml'
+    DEFAULT_EXCLUDE_PATHS      = [ %r[^/images], %r[^/stylesheets], %r[^/javascripts], %r[^/system],  ]
+    DEFAULT_EXCLUDE_MIME_TYPES =   [ %r[image], %r[text/css], %r[javascript], %r[shockwave] ]
+
+    attr_accessor :exclude_path_patterns,
+                  :exclude_mime_types,
+                  :match_on_required_params,
+                  :exclude_match_params,
+                  :limit_count
+
+
+    def self.load(config_path = DEFAULT_CONFIG_PATH)
+      yaml_config = YAML::load(File.open(config_path))
+      config = self.new(yaml_config)
+    end
+
+    def initialize(yaml_config)
+      self.exclude_path_patterns = DEFAULT_EXCLUDE_PATHS
+                                   + yaml_config['exclude_path_patterns']
+                                   - yaml_config['include_path_patterns']
+
+      self.exclude_mime_types    = DEFAULT_EXCLUDE_MIME_TYPES
+                                   + yaml_config['exclude_mime_types']
+                                   - yaml_config['include_mime_types']
+
+
+      if yaml_config.has_key?('match_on_required_params')
+        self.match_on_required_params = yaml_config['match_on_required_params']
+      else
+        self.match_on_required_params = false
+      end
+
+      self.exclude_match_params = yaml_config['exclude_match_params'] || []
+      self.include_match_params = yaml_config['include_match_params'] || []
+      self.limit_count          = yaml_config['limit_count']
+    end
+  end
+end
+

data/lib/fluoride-analyzer/exception-result.rb

@@ -0,0 +1,5 @@
+require 'fluoride-analyzer'
+module Fluoride::Analyzer
+  class ExceptionResult
+  end
+end

data/lib/fluoride-analyzer/exchange-result.rb

@@ -0,0 +1,5 @@
+require 'fluoride-analyzer'
+module Fluoride::Analyzer
+  class ExchangeResult
+  end
+end

data/lib/fluoride-analyzer/group-collapser.rb

@@ -0,0 +1,51 @@
+require 'fluoride-analyzer/group-context'
+
+module Fluoride::Analyzer
+  class GroupCollapser
+    def initialize(pattern, letname_map, method, status, requests_list)
+      @pattern = pattern
+      @letname_map = letname_map
+      @request_list = requests_list
+      @method, @status = method, status
+    end
+    attr_reader :method, :status, :letname_map
+
+    def stet_list
+      []
+    end
+
+    def requests
+      @request_list
+    end
+
+    def reduce_path(path, request)
+      path = @pattern.dup
+      request['path_params'].each_pair do |name, value|
+        next if stet_list.include?(name)
+        target_name = letname_map.fetch(name, name)
+        path.sub!(/:#{name}/,"\#{#{target_name}}")
+      end
+      path
+    end
+
+    def reduce_query(query, request)
+      ""
+      #none captured (yet?)
+    end
+
+    def each_group_context
+      path_tuples = requests.map do |request|
+        [request['path'], request['query_params'], request]
+      end
+
+      reduced_hash = Hash.new{|h,k| h[k] = []}
+      path_tuples.each do |path, query, request|
+        reduced_hash[ [ reduce_path(path, request), reduce_query(query, request) ] ] << request
+      end
+
+      reduced_hash.each do |(path, query_params), requests|
+      yield GroupContext.new(method, status, requests, path, query_params)
+      end
+    end
+  end
+end

data/lib/fluoride-analyzer/group-context.rb

@@ -0,0 +1,86 @@
+require 'fluoride-analyzer'
+
+module Fluoride::Analyzer
+  class GroupContext
+    def initialize(method, status, requests, path, query_params)
+      @method, @status_code, @requests, @path, @query_params = method, status, requests, path, query_params
+    end
+    attr_reader :method, :status_code
+
+    def test_method
+      @method.downcase
+    end
+
+    def status_description
+      case @status_code.to_i
+      when 300..399
+        "Redirect"
+      else
+        "OK"
+      end
+    end
+
+    def request_count
+      @requests.inject(0) do |sum, request|
+        sum + request['sources'].keys.length
+      end
+    end
+
+    def example_source
+      request['sources'].keys.first
+    end
+
+    def example_path
+      request['path']
+    end
+
+    def request_spec_description
+      "#@method #{spec_request_path}"
+    end
+
+    def should_what
+      case @status_code.to_i
+      when 300..399
+        "redirect"
+      else
+        "succeed"
+      end
+    end
+
+    def redirect_path
+      request['redirect_location'].sub(%r[^https?://#{request['host']}], '')
+    end
+
+    def test_result
+      case @status_code.to_i
+      when 300..399
+        ["response.should redirect_to(\"#{redirect_path}\")"]
+      else
+        ["response.should be_success", "response.status.should == 200"]
+      end
+    end
+
+    def test_request(indent)
+      indent = " " * indent
+      test_request = "#{test_method} \"#{spec_request_path}\""
+      if request.has_key? 'post_params'
+        params = request['post_params'].pretty_inspect.split("\n")
+        params = ([params[0]] + params[1..-1].map do |line|
+          indent + line
+        end).join("\n")
+        test_request += ", #{params}"
+      end
+      test_request
+    end
+
+    def spec_request_path
+      "#{@path}#{@query_params}"
+    end
+
+    private
+
+    def request
+      @requests.first
+    end
+  end
+end

data/lib/fluoride-analyzer/parser.rb

@@ -0,0 +1,261 @@
+require 'fluoride-analyzer'
+require 'rack'
+require 'yaml'
+#Also: Rails and ActionDispatch::Request
+
+module Fluoride::Analyzer
+  class Parser
+    attr_accessor :files, :limit, :target_path
+    attr_reader :exceptions, :results, :counts
+
+    def initialize
+      @exceptions = []
+      @counts = {
+        :excluded => 0,
+        :unrecognized => 0,
+        :no_matching_route => 0,
+        :exceptions => 0
+      }
+      @results = Hash.new do|results, pattern| #PATH PATTERN
+        results[pattern] = Hash.new do |by_method, method| #METHOD
+          by_method[method] = Hash.new do |records, status| #STATUS CODE
+          records[status] = Hash.new do |record, key| #formatted record
+              record[key] = []
+            end
+          end
+        end
+      end
+      @limit = -1
+    end
+
+    def excluded_content_types
+      [ %r[image], %r[text/css], %r[javascript], %r[shockwave] ]
+    end
+
+    def excluded_paths
+      [ %r[^/images], %r[\.ttf\z], %r[\.woff\z] ]
+    end
+
+    def exclude?(record)
+      return true if record['type'] == 'exception_raised'
+
+      if excluded_content_types.any?{ |reg| reg =~ record['response']['headers']['Content-Type'] }
+        return true
+      end
+      if excluded_paths.any?{|req| req =~ record['request']['path']}
+        return true
+      end
+      return false
+    rescue
+      warn "Exception raised while filtering record: #{record.inspect}"
+      raise
+    end
+
+    def format_record(record, path_params)
+      {
+        'path' => record['request']['path'],
+        'query_params' => record['request']['query_params'],
+        'content-type' => record['request']['content_type'],
+        'path_params' => path_params,
+        'redirect_location' => record['response']['headers']['Location'],
+        'host' => record['request']['host']
+        #'accept' => record['request']['accept']
+      }
+    end
+
+    def formatted_results
+      formatted = {}
+      results.each do |pattern, methods|
+        frmt_methods = formatted[pattern] = {}
+        methods.each do |method, status|
+          frmt_statuses = frmt_methods[method] = {}
+          status.each do |code, requests|
+            frmt_statuses[code] = requests.keys.map do |req_hash|
+              hash = req_hash.dup
+              hash['sources'] = Hash[requests[req_hash]]
+              hash
+            end
+          end
+        end
+      end
+      formatted
+    end
+
+    def post_params(record)
+      return {} unless %w{POST PUT}.include?(record['request']['method'])
+      unless record['request']['content_type'].nil? or
+        %r[^application/x-www-form-urlencoded.*] =~ record['request']['content_type']
+        return {}
+      end
+
+      form_hash = Rack::Utils.parse_nested_query(record['request']['body'])
+
+      { 'post_params' => form_hash }
+    end
+
+    RoutePattern = Struct.new(:route, :matches, :params, :path_spec, :segment_keys)
+
+    class Patterner
+      def self.for(rails_routes)
+        if rails_routes.respond_to? :recognize_path
+          Rails4.new(rails_routes)
+        else
+          Rails3.new(rails_routes)
+        end
+      end
+
+      def base_env
+        @base_env ||= {
+          "HTTP_REFERER" => '',
+          "HTTP_COOKIE" => '',
+          "HTTP_AUTHORIZATION" => '',
+          "REQUEST_METHOD" => "GET",
+          'HTTP_HOST' => '',
+          'SERVER_NAME' => '',
+          'SERVER_ADDR' => '',
+          'SERVER_PORT' => '80',
+          "SCRIPT_NAME" => '',
+          "QUERY_STRING" => '',
+          'rack.input' => '' #body
+        }
+      end
+
+      def initialize(rails_routes)
+        @rails_routes = rails_routes
+      end
+      attr_reader :rails_routes
+
+      def build_request(result_env)
+        ActionDispatch::Request.new(base_env.merge(request_env))
+      end
+
+      def route_map
+        @route_map ||=
+          begin
+            ad_routes_array   = rails_routes.routes
+            rack_routes_array = rails_routes.set.instance_eval{ @routes }
+            Hash[ rack_routes_array.zip(ad_routes_array) ]
+          end
+      end
+
+      def route_set
+        @route_set ||=
+          begin
+            set = rails_routes.set
+            set
+          end
+      end
+
+      class Rails3 < Patterner
+        def build(env)
+          req = build_request(env)
+          route, matches, params = route_set.recognize(req)
+
+          path_spec = :unrecognized
+          segment_keys = {}
+
+          if route_map.has_key?(route)
+            rails_route = route_map[route]
+            path_spec = rails_route.path
+            segment_keys = rails_route.segment_keys
+          end
+
+          RoutePattern.new(route, matches, params, path_spec, segment_keys)
+        end
+      end
+
+      class Rails4 < Patterner
+        def route_set
+          @route_set ||=
+            begin
+              set = Rails.application.routes.router
+              set
+            end
+        end
+
+        def build_request(request_env)
+          ActionDispatch::Request.new(base_env.merge(request_env))
+        end
+
+        def build(env)
+          req = build_request(env)
+          pattern = nil
+          route_set.recognize(req) do |route, matches, params|
+            rails_route = route_map[route]
+
+            path_spec = :unrecognized
+            segment_keys = {}
+
+            if route_map.has_key?(route)
+              rails_route = route_map[route]
+              path_spec = rails_route.path.spec.to_s
+              segment_keys = rails_route.segment_keys
+            end
+
+            pattern = RoutePattern.new(route, matches, params, path_spec, segment_keys)
+          end
+          if pattern.nil?
+            pattern = RoutePattern.new(nil,nil,nil,nil,nil)
+          end
+          pattern
+        end
+      end
+    end
+
+    def patterner
+      @patterner ||= Patterner.for(Rails.application.routes)
+    end
+
+    def collect_record(file, record, index)
+      if exclude?(record)
+        @counts[:excluded] += 1
+        return
+      end
+
+      request_env = {
+        "REQUEST_METHOD" => record['request']['method'].to_s.upcase,
+        "PATH_INFO"  => record['request']['path'],
+      }
+      unless request_env['REQUEST_METHOD'] == "GET"
+        request_env['rack.input'] = StringIO.new(record['request']['body'])
+      end
+
+      pattern = patterner.build(request_env)
+
+      route = pattern.route
+
+      if route.nil?
+        @counts[:unrecognized] += 1
+        return
+      end
+
+      if pattern.path_spec == :unrecognized
+        @counts[:no_matching_route] += 1
+        warn "Unrecognized route: #{record['request']['path'].inspect}"
+      else
+        route_path = pattern.path_spec
+        path_params = Hash[pattern.segment_keys.map do |key|
+          [key, params[key]]
+        end]
+      end
+
+      formatted_record = format_record(record, path_params).merge(post_params(record))
+
+      self.results[route_path][record['request']['method']][record['response']['status']][formatted_record] << [file, index]
+    end
+
+    def parse_stream(file, string)
+      stream = YAML.load_stream(string)
+      stream = stream.documents if stream.respond_to? :documents
+
+      stream.each_with_index do |record, index|
+        collect_record(file, record, index)
+      end
+    rescue ArgumentError => ex
+      @exceptions << [ex, file]
+    rescue Exception => ex
+      @exceptions << [ex, file]
+      raise
+    end
+  end
+end

data/lib/fluoride-analyzer/pattern-collapser.rb

@@ -0,0 +1,30 @@
+module Fluoride::Analyzer
+  class PatternCollapser
+    def initialize(pattern, methods_hash)
+      @pattern = pattern
+      @methods_hash = methods_hash
+    end
+
+    def erase_list
+      %w{ format }
+    end
+
+    def pattern
+      erase_list.inject(@pattern) do |pattern, erase|
+        pattern.sub(/\(.:#{erase}\)/,'')
+      end
+    end
+
+    def param_letname_map
+      { :id => :model_id }
+    end
+
+    def params_fields
+      @methods_hash.values.first.values.first.first['path_params'].keys.reject do |key|
+        key == :format
+      end.map do |name|
+        param_letname_map.fetch(name, name)
+      end
+    end
+  end
+end

data/lib/fluoride-analyzer/pattern-context.rb

@@ -0,0 +1,34 @@
+require 'fluoride-analyzer/group-collapser'
+require 'fluoride-analyzer/pattern-collapser'
+
+module Fluoride::Analyzer
+  class PatternContext
+    def initialize(pattern, methods_hash)
+      @pattern, @methods_hash = pattern, methods_hash
+      @collapser = PatternCollapser.new(pattern, methods_hash)
+    end
+    attr_reader :pattern
+
+    def each_status_group
+      @methods_hash.each_pair do |method, hash|
+        hash.each_pair do |status, requests|
+          GroupCollapser.new(@collapser.pattern, @collapser.param_letname_map, method, status, requests).each_group_context do |context|
+            yield context
+          end
+        end
+      end
+    end
+
+    def param_fields
+      @collapser.params_fields
+    end
+
+    def filename
+      @collapser.pattern.gsub(%r{[:/().]+},'_').gsub(/^_|_$/, '') + "_spec.rb"
+    end
+
+    def context_binding
+      binding
+    end
+  end
+end

data/lib/fluoride-analyzer/rails.rb

@@ -0,0 +1 @@
+require 'fluoride-analyzer/rails/railtie'

data/lib/fluoride-analyzer/rails/railtie.rb

@@ -0,0 +1,14 @@
+require 'fluoride-analyzer'
+
+module Fluoride
+  module Analyzer
+    class Railtie < ::Rails::Railtie
+      #config.fluoride.directory = "fluoride-collector"
+
+      rake_tasks do
+        # load '/path/to/task'
+      end
+
+    end
+  end
+end

data/lib/fluoride-analyzer/request-processor.rb

@@ -0,0 +1,7 @@
+require 'fluoride-analyzer'
+
+module Fluoride::Analyzer
+  class RequestProcessor
+  end
+end
+

data/lib/fluoride-analyzer/request-templater.rb

@@ -0,0 +1,26 @@
+require 'erb'
+require 'fluoride-analyzer/pattern-context'
+
+module Fluoride::Analyzer
+  class RequestTemplater
+    def initialize
+
+    end
+    attr_accessor :template, :template_string, :target_dir, :results
+
+    def template
+      @template ||= ERB.new(template_string, nil, '<>')
+    end
+
+    def go
+      results.each_pair do |pattern, statuses|
+        context = PatternContext.new(pattern, statuses)
+
+        path = File.join(context.filename)
+        contents = template.result(context.context_binding)
+
+        yield(path, contents)
+      end
+    end
+  end
+end

data/lib/fluoride-analyzer/request.rb

@@ -0,0 +1,11 @@
+require 'fluoride-analyzer'
+
+module Fluoride::Analyzer
+  class Request
+    attr_accessor :request_hash
+
+    def initialize
+      @request_hash = {}
+    end
+  end
+end

data/lib/fluoride-analyzer/result-collection.rb

@@ -0,0 +1,5 @@
+require 'fluoride-analyzer'
+module Fluoride::Analyzer
+  class ResultCollection
+  end
+end

data/lib/fluoride-analyzer/tasks.rake

@@ -0,0 +1,46 @@
+require 'fluoride-analyzer/request-templater'
+
+FLUORIDE_PATH = 'fluoride-collector'
+LIMIT = 2000
+
+directory 'spec/requests'
+
+task :parse_fluoride => 'paths.yml'
+
+task :rebuild_request_specs => [:clobber_request_specs, :template_request_specs]
+
+task :clobber_request_specs do
+  sh("rm -rf spec/requests/*")
+end
+
+file 'results.yml' => FileList[ "#{FLUORIDE_PATH}/*.yml" ] do |task|
+  Rake::Task[:environment].invoke
+  parser = Fluoride::Analyzer::Parser.new
+
+  task.prerequisites.find_all do |prereq|
+    next unless File.file?(prereq) && __FILE__ != prereq
+    parser.parse_stream(File.read(prereq))
+  end
+
+  #parser.limit = LIMIT #XXX Uncomment to limit number of files parsed
+  parser.target_path = task.name
+
+  File.open(task.name, "w") do |target_file|
+    target_file.write(YAML.dump(parser.formatted_results))
+  end
+
+  puts "Found #{parser.formatted_results.keys.length} unique requests"
+end
+
+task :template_request_specs => ['spec/requests', 'results.yml'] do
+  templater = Fluoride::Analyzer::RequestTemplater.new
+
+  templater.template_string = File::read(File::expand_path("../../../templates/request_spec.erb", __FILE__))
+  templater.results = YAML.load(File.read('results.yml'))
+  templater.go do |filename, contents|
+    path = File.join("spec/requests", filename)
+    File.open(path, "w") do |spec_file|
+      spec_file.write(contents)
+    end
+  end
+end

data/spec-help/gem-test-suite.rb

@@ -0,0 +1,17 @@
+puts Dir::pwd
+require 'test/unit'
+begin
+  require 'spec'
+rescue LoadError
+  false
+end
+
+class RSpecTest < Test::Unit::TestCase
+  def test_that_rspec_is_available
+    assert_nothing_raised("\n\n *  RSpec isn't available - please run: gem install rspec  *\n\n"){ ::Spec }
+  end
+
+  def test_that_specs_pass
+    assert(system(*%w{spec -f e -p **/*.rb spec}),"\n\n *  Specs failed  *\n\n")
+  end
+end

data/spec/railtie_spec.rb

@@ -0,0 +1,27 @@
+require "action_controller/railtie"
+require 'fluoride-analyzer/rails'
+
+describe Fluoride::Analyzer::Railtie do
+
+  def config(app)
+
+  end
+
+  let :rails_application do
+    Class.new(::Rails::Application).tap do |app|
+      app.configure do
+        config.active_support.deprecation = :stderr
+        config.eager_load = false
+      end
+      config(app)
+      app.initialize!
+    end
+  end
+
+  after :each do
+    Rails.application = nil #because Rails has ideas of it's own, silly thing
+  end
+
+  it "should add rake tasks"
+
+end

data/spec/result-parser.rb

@@ -0,0 +1,110 @@
+require 'action_controller/railtie'
+require 'fluoride-analyzer/parser'
+
+describe Fluoride::Analyzer::Parser do
+  def config(app)
+    app.routes.draw do
+      get "/", :to => 'root#index', :as => :root
+    end
+  end
+
+  let! :rails_application do
+    Class.new(::Rails::Application).tap do |app|
+      app.configure do
+        config.active_support.deprecation = :stderr
+        config.eager_load = false
+      end
+      config(app)
+      app.initialize!
+    end
+  end
+
+  after :each do
+    Rails.application = nil
+  end
+
+  let :requests_stream do
+    YAML::dump_stream(*requests)
+  end
+
+  let :parser do
+    Fluoride::Analyzer::Parser.new.tap do |parser|
+      parser.parse_stream("test-file.yaml", requests_stream)
+    end
+  end
+
+  let :results do
+    parser.formatted_results
+  end
+
+  let :requests do
+    [
+      {"type"=>"normal_exchange",
+      "tags"=>nil,
+      "request"=>
+       {"query_string"=>"",
+        "body"=>"",
+        "method"=>"GET",
+        "accept"=>
+         "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+        "content_type"=>nil,
+        "user_agent"=>
+         "Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36",
+        "referer"=>nil,
+        "host"=>"0.0.0.0:3000",
+        "authorization"=>nil,
+        "cookies"=>nil,
+        "path"=>"/",
+        "accept_encoding"=>"gzip,deflate,sdch"},
+      "response"=>
+       {"body"=>
+         ["<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n\n<!--\n\tsomebody@gmail.com june 2014\n-->\n\n\t<meta charset=\"utf-8\" />\n\t<title>Application</title>\n\t<meta name=\"viewport\" content=\"width=device-width, initial-sc"],
+        "status"=>200,
+        "headers"=>
+         {"Content-Type"=>"text/html; charset=utf-8",
+          "ETag"=>"\"5ff1d9c9172424e5d906216dcdacd9ef\"",
+          "X-UA-Compatible"=>"IE=Edge,chrome=1",
+          "Cache-Control"=>"max-age=0, private, must-revalidate",
+          "X-Runtime"=>"0.873536"}}
+    },
+
+     {"type"=>"normal_exchange",
+      "tags"=>nil,
+      "request"=>
+       {"query_string"=>"",
+        "body"=>"",
+        "method"=>"GET",
+        "accept"=>"text/css,*/*;q=0.1",
+        "content_type"=>nil,
+        "user_agent"=>
+         "Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36",
+        "referer"=>"http://0.0.0.0:3000/",
+        "host"=>"0.0.0.0:3000",
+        "authorization"=>nil,
+        "cookies"=>nil,
+        "path"=>"/stylesheets/2014-bootstrap.css",
+        "accept_encoding"=>"gzip,deflate,sdch"},
+      "response"=>
+       {"body"=>
+         ["/*! normalize.css v3.0.0 | MIT License | git.io/normalize */\nhtml {\n  font-family: sans-serif;\n  -ms-text-size-adjust: 100%;\n  -webkit-text-size-adjust: 100%; }\n\nbody {\n  margin: 0; }\n\narticle,\naside,\n"],
+        "status"=>200,
+        "headers"=>
+         {"Content-Length"=>"15835",
+          "Content-Type"=>"text/css",
+          "Last-Modified"=>"Sun, 29 Jun 2014 00:00:48 GMT"}},
+    }
+    ]
+  end
+
+  it "should have excluded 1 request" do
+    expect(parser.counts[:excluded]).to eq(1)
+  end
+
+  it "should have 0 unrecognized requests" do
+    expect(parser.counts[:unrecognized]).to eq(0)
+  end
+
+  it "should be a well formatted version of the results" do
+    expect(results).to match("/" => {"GET" => {200 => match([ a_hash_including("path" => "/") ])}})
+  end
+end

data/spec/result-templater.rb

@@ -0,0 +1,67 @@
+require 'fluoride-analyzer/request-templater'
+
+describe Fluoride::Analyzer::RequestTemplater do
+  let :template_string do
+    <<-EOT
+require 'spec_helper'
+
+describe '<%= pattern %>' do
+<% param_fields.each do |field| %>
+  let :<%= field %> do
+    FactoryGirl.create(:<%= field %>).id
+  end
+<%end%>
+<% each_status_group do |group| %>
+
+  # HTTP status code: <%= group.status_code %> <%= group.status_description %>
+  # <%= group.request_count %> cases recorded by Fluoride
+  # See example: '<%= group.example_source %>'
+  #   example path: <%= group.example_path %>
+  describe '<%= group.request_spec_description %>' do
+    it "should <%= group.should_what %>" do
+      <%= group.test_request(6) %>
+<% group.test_result.each do |test_result_line| %>
+      <%= test_result_line %>
+<% end %>
+    end
+  end
+<%end%>
+end
+    EOT
+  end
+
+  let :results do
+    YAML.load(File.read(File.expand_path("../../spec-help/fixtures/results.yml", __FILE__)))
+  end
+
+  let :templater do
+    Fluoride::Analyzer::RequestTemplater.new.tap do |tmplr|
+      tmplr.template_string = template_string
+      tmplr.results = results
+    end
+  end
+
+  let :templated_list do
+    templated_list = []
+    templater.go do |path, contents|
+      templated_list << [path, contents]
+    end
+    templated_list
+  end
+
+  let :paths do
+    templated_list.map{|path, _| path}
+  end
+
+  let :contents do
+    templated_list.map{|_, contents| contents}
+  end
+
+  it "should template once per result" do
+    expect(templated_list.length).to eq(results.keys.length)
+  end
+
+  it "should put the right stuff in contents" do
+    expect(contents).to all(match(/HTTP status code:/))
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: fluoride-analyzer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Judson Lester
+- Evan Down
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mattock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: valise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+    Part of the Fluoride suite - tools for making your black box a bit whiter
+email:
+- nyarly@gmail.com
+- evan@lrdesign.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fluoride-analyzer/parser.rb
+- lib/fluoride-analyzer/exception-result.rb
+- lib/fluoride-analyzer/rails/railtie.rb
+- lib/fluoride-analyzer/group-context.rb
+- lib/fluoride-analyzer/config.rb
+- lib/fluoride-analyzer/request-templater.rb
+- lib/fluoride-analyzer/group-collapser.rb
+- lib/fluoride-analyzer/rails.rb
+- lib/fluoride-analyzer/pattern-collapser.rb
+- lib/fluoride-analyzer/request.rb
+- lib/fluoride-analyzer/tasks.rake
+- lib/fluoride-analyzer/result-collection.rb
+- lib/fluoride-analyzer/request-processor.rb
+- lib/fluoride-analyzer/pattern-context.rb
+- lib/fluoride-analyzer/exchange-result.rb
+- lib/fluoride-analyzer.rb
+- spec/result-templater.rb
+- spec/railtie_spec.rb
+- spec/result-parser.rb
+- spec-help/gem-test-suite.rb
+homepage: http://github.com/lrdesign/fluoride-analyzer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --inline-source
+- --main
+- doc/README
+- --title
+- fluoride-analyzer-0.0.1 Documentation
+require_paths:
+- lib/
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Analysis of recorded requests
+test_files:
+- spec-help/gem-test-suite.rb