routespec 0.0.1

data/README.txt

@@ -0,0 +1,66 @@
+= routespec
+
+http://github.com/awesome/routespec
+
+== DESCRIPTION:
+
+RouteSpec automates test writing based on routes exposed in config/routes.rb.
+A complimentary gem for Rails test-writers using RSpec.
+
+== FEATURES/PROBLEMS:
+
+* Tests
+* Features
+* each route has a controller
+* raise if there is not a controller matching the route 
+* raise if there is not a action for the 
+* each test requires a response code
+* each test requires a url to call
+* each test will use "get" as the default http_verb
+* routespec will use vcr on every test
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* Rails 3.1.1
+* RSpec
+* YAML
+* Ostruct
+* Erb
+
+== INSTALL:
+
+=== Command Line
+
+$ gem install
+
+=== Rails 3.1.1 
+
+add to Gemfile:
+gem "routespec"
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ cd YOUR_RAILS_APP 
+  $ routespec init => creates spec/routespec dir
+  $ routespec run => creates spec/routespec/request/*_spec.rb files based on config/routes.rb and the default template spec/routespec/templates/default_spec.rb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 So Awesome Man, Windermere Solutions LLC
+
+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,26 @@
+#!/usr/bin/env rake
+require 'hoe'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+#Hoe.spec 'routespec' do
+#  # HEY! If you fill these out in ~/.hoe_template/Rakefile.erb then
+#  # you'll never have to touch them again!
+#  # (delete this comment too, of course)
+#
+#  # developer('FIX', 'FIX@example.com')
+#
+#  # self.rubyforge_name = 'routespecx' # if different than 'routespec'
+#end
+
+desc "builds and installs routespec gem locally from gemspec"
+task :build_and_install do 
+  Dir.chdir(File.dirname(__FILE__)) do
+    `gem build routespec.gemspec`
+    `gem install routespec` 
+  end
+end

data/bin/routespec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'optparse'
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'routespec'
+
+module RoutespecOpt 
+  def self.command
+    OptionParser.new do |opts|
+      opts.banner = "Routespec #{Routespec::VERSION}"
+      opts.on("-i", "--init", "setup routespec in ./spec") do |x|
+        if Routespec::Dyr.init
+          puts "made spec/routespec"
+        else
+          puts "spec/routespec already exists"
+        end
+        return
+      end    
+
+      opts.on("-h", "--help", "Show this message") do
+        puts opts
+        return
+      end
+    end.parse!
+  end
+end
+
+RoutespecOpt.command

data/lib/routespec.rb

@@ -0,0 +1,22 @@
+require 'fileutils'
+require 'ostruct'
+require 'yaml'
+require 'erb'
+
+module Routespec
+  ##
+  # Base Routespec error class
+  class Error < RuntimeError
+  end
+end
+
+require "routespec/builder"
+require "routespec/dyr"
+require "routespec/fyle"
+require "routespec/parser"
+require "routespec/template_vars"
+require "routespec/tasks"
+require "routespec/version"
+
+# rails conditional requires
+require "routespec/railtie" if defined? Rails

data/lib/routespec/builder.rb

@@ -0,0 +1,111 @@
+module Routespec
+  module Builder
+    class << self
+    
+      ##
+      # takes routes.txt and creates routes.yml
+      # if not specifying filename, will put routes.yml in same dir as routes.txt
+      def text_to_yaml(routes_txt, file_name = nil)
+        raise unless File.exist?(routes_txt)
+        unless file_name
+          file_name = "#{Dir.path(routes_txt)}/routes.yml" 
+        end
+
+        hash = Routespec::Parser.parse(routes_txt)
+        Routespec::Fyle.hash_to_yaml_file(hash, file_name)
+        return true
+      end
+
+      ##
+      # writes routes.yml to multiple spec files 
+      # if not specifying dir, will put specs in "requests" in same dir as routes.yml
+      def yaml_to_specs(routes_yml, template_name, dir_name = nil)
+        raise unless File.exist?(routes_yml)
+        unless dir_name
+          path_name = File.dirname(routes_yml) 
+          dir_name = "#{path_name}/requests"
+        end
+        Routespec::Dyr.create_dir(dir_name)
+
+        hash = Routespec::Fyle.hash_from_yaml_file(routes_yml)
+        hash = Routespec::Builder.build(hash, hash.keys, template_name)
+        hash_to_specs(hash, dir_name)
+        return true
+      end
+
+      ##
+      # writes hash built from lines to mulitple spec files
+      def hash_to_specs(hash, output_dir = nil)
+        hash.each {|k,v| 
+          Routespec::Dyr.create_dir(output_dir) if output_dir
+          Routespec::Dyr.array_to_nested_dirs(v[:address], output_dir) 
+          file_name = k.sub(/^#{output_dir}/, "")
+          #Routespec::Fyle.string_to_file(v[:content], k)
+          #Routespec::Fyle.string_to_file(v[:content], "#{output_dir}/#{k}")
+          Routespec::Fyle.string_to_file(v[:content], "#{output_dir}/#{file_name}")
+        }
+        return true
+      end
+
+      ##
+      # reads erb template to string
+      # "we quote the template literally with %q{...} to avoid trouble with the backslash."--http://www.ruby-doc.org/stdlib-1.9.3/libdoc/erb/rdoc/ERB.html
+      def template_text(template_file_name)
+        str = IO.read(template_file_name)
+        str = clean_lines(str)
+        return eval("%q{#{str}}")
+      end
+
+      ##
+      # remove trailing whitespace to make clean for trim_mode in erb
+      def clean_lines(text)
+        text.split(/\n/).map {|x| x =~ /^\s*<%[^=]/ ? x.strip : x.rstrip}.join("\n").chomp
+      end
+
+      ##
+      # creates string with erb template and variables 
+      def template_init(hsh, template_file_name)
+        tmp_vars = Routespec::TemplateVars.new
+        hsh.each {|k,v|
+          tmp_vars.instance_variable_set("@#{k}", v) 
+        }
+        template = ERB.new(template_text(template_file_name), 0, "%<>")
+        # needed because erb's trim_mode usage isn't understood yet
+        #return str.gsub(/^\s*$\n/, "")
+        # now working, need to clean line endings with Ruby#chomp for trim_mode to work
+        return template.result(tmp_vars.get_binding)
+      end
+
+      ##
+      # creates objects from array
+      # takes array of hashes
+      def array_to_objects(array)
+        array.map {|x| OpenStruct.new(x)}
+      end
+      
+      ##
+      # recursive itteration over hash to turn built hash from lines to hash with erb template strings using file_names as keys
+      # returns hash
+      def build(hash, keys, template_name)
+        new_hash = {}
+        while !keys.empty?
+          key = keys.shift 
+          val = hash[key]
+          case 
+          when val.is_a?(Hash)
+            self.build(val, val.keys, template_name)
+          when val.is_a?(Array)
+            address = val.first[:address]
+            str = template_init({:routes => array_to_objects(val), :name => address.last}, template_name)
+            new_hash[Routespec::Fyle.spec_file_name(address)] = {:content => str, :address => address}
+          end
+        end
+        return new_hash
+      end
+      
+      ##
+      #
+
+    end
+  end
+end

data/lib/routespec/dyr.rb

@@ -0,0 +1,50 @@
+module Routespec
+  module Dyr
+    LOCAL_ROUTESPEC_DIR = "#{File.dirname(__FILE__)}/routespec"
+    class << self 
+      ##
+      # copies routespec dirs from gem to rails app
+      def init(output_dir_name = "spec")
+        unless Dir.exist?("#{output_dir_name}/routespec")
+          Routespec::Dyr.create_dir(output_dir_name)
+          FileUtils.cp_r(LOCAL_ROUTESPEC_DIR, output_dir_name)
+          return true
+        else
+          return false
+        end
+      end
+
+      ##
+      # creates dirs from array
+      def array_to_dirs(dir_name, array)
+        array.each {|x| create_dir("#{dir_name}/#{x}")}
+        return true
+      end
+
+      ##
+      # checks if the dir exists based on the address and creates it (if it doesn't)
+      def create_dir(dir_name) 
+        Dir.exist?(dir_name) ? nil : Dir.mkdir(dir_name)
+        return true
+      end
+
+      ##
+      # checks if the dir exists based on the address and destroys it (if it does)
+      def destroy_dir(dir_name)
+        Dir.exist?(dir_name) ? (FileUtils.rm_rf dir_name) : nil
+        return true
+      end
+
+      ##
+      # creates nested dirs from address array
+      def array_to_nested_dirs(array, root_dir)
+        addr = [root_dir]
+        array.each {|x|
+          addr << x
+          create_dir(addr.join("/"))
+        }
+        return true
+      end
+    end
+  end
+end

data/lib/routespec/fyle.rb

@@ -0,0 +1,72 @@
+module Routespec
+  module Fyle 
+    class << self
+#      ##
+#      # parses filetype path and name
+#      def file_or_dir(string)
+#        file_name = File.expand_path(string)
+#        exist = File.exist?(file_name)
+#        case  
+#        when (exist && File.ftype(file_name) == "directory")
+#          return {:ftype => "dir", :dir => File.path(string), :file => nil}
+#        when (exist && File.ftype(file_name) == "file")
+#          return {:ftype => "file", :dir => File.path(string), :file => File.basename(string)}
+#        else
+#          return {:ftype => "dir", :dir => File.path(__FILE__), :file => nil}
+#        end
+#      end
+#
+#      ##
+#      # uses default name arg if one is not present in the file_name
+#      def parse_file_name(file_name, def_name) 
+#        hsh = file_or_dir(file_name)     
+#        case hsh[:ftype]
+#        when "dir"
+#          return "#{hsh[:dir]}/#{def_name}" 
+#        when "file"
+#          return "#{hsh[:dir]}/#{hsh[:file]}" 
+#        end
+#      end
+
+      ##
+      # creates the "DIR/FILENAME_spec.rb" based on address (address derived from controller name)
+      # takes array
+      def spec_file_name(address, file_name = address.last, dir = nil)
+        [dir, address.join("/"), "#{file_name}_spec.rb"].join("/")
+      end
+
+      ##
+      # writes hash to yaml file
+      def hash_to_yaml_file(hash, file_name)
+        raise "file exists: #{file_name}" if File.exist?(file_name) 
+        string_to_file(hash.to_yaml, file_name)
+        return true
+      end
+
+      ##
+      # returns hash of yaml
+      def hash_from_yaml_file(file_name)
+        raise "invalid file name: #{file_name}" unless File.exist?(file_name) 
+        YAML.load_file(file_name)
+      end
+
+      ##
+      # writes string to file
+      def string_to_file(string, file_name, args = "w")
+        File.open(file_name, args) {|f| f.write(string)} 
+        return true
+      end
+
+      # takes lines in an array 
+      # writes array to file, each indice is a line
+      def array_to_file(lines_array, file_name, flags = "w")
+        File.open(file_name, flags) do |file| 
+          lines_array.each {|line|
+            file.print("#{line}\n")
+          }
+        end
+        return true
+      end
+    end
+  end
+end

data/lib/routespec/parser.rb

@@ -0,0 +1,143 @@
+module Routespec
+  module Parser
+    DEFAULT_HTTP_VERB = "GET"
+    STATUS_CODES = {
+      nil => 200,
+      "GET" => 200,
+      "PUT" => 200,
+      "DELETE" => 200,
+      "POST" => 201
+    }
+
+    #
+    # turns this string:
+    #  "agent_listing_gallery_photos GET    /agents/:agent_id/listings/:listing_id/galleries/:gallery_id/photos(.:format)       {:action=>\"index\", :controller=>\"agents_and_offices/photos\"}"
+    # into:
+    #  1. agent_listing_gallery_photos
+    #  2. GET
+    #  3. /agents/:agent_id/listings/:listing_id/galleries/:gallery_id/photos(.:format)
+    #  4. {:action=> "index", :controller => "agents_and_offices/photos"}
+    #
+    #LINE_REGEX = /^\s*(\w+)?\s*(GET|PUT|POST|DELETE)?\s*(\/\S+){1}\s*(\{.+\})\s*$/
+    LINE_REGEX = /^([^\/]*)(\/\S*){1}\s*(\{.+\})$/
+    SYMBOL_REGEX = /:(\w+)\W/
+
+    # :controller is found inside the hash
+    VALIDATE_CONTROLLER_REGEX = /\{.*:controller.*\}/
+    # :controller is found before the hash
+    VALIDATE_DYNAMIC_CONTROLLER_REGEX = /:controller.*\{/
+
+    class << self 
+
+      ##
+      # routes_text to lines_hash
+      def parse(file_name = "#{File.dirname(__FILE__)}/test/files/rake_routes.txt")
+        hash = routes_to_hash(file_name)
+        lines_to_hash(hash[:lines])
+      end
+
+      ##
+      # parses "rake routes" output in text file and returns hash of lines
+      def routes_to_hash(file_name)
+        hash = {:lines => {}, :lines_without_controller => {}}
+        i = 0
+        File.open(file_name).each_line{|x|
+          case
+          # validate pointing to controller
+          when x =~ VALIDATE_CONTROLLER_REGEX
+            hash[:lines][i+=1] = line_parse(x)
+          when x =~ VALIDATE_DYNAMIC_CONTROLLER_REGEX
+            hash[:lines][i+=1] = line_parse(x, {:address => ["dynamic"]})
+          else
+            hash[:lines_without_controller][i+=1] = x
+          end
+        } 
+        #puts "routes parsed: #{i}"
+        return hash
+      end
+
+      ##
+      # creates new hash with nested address as keys; endpoints are turned into arrays; lines with matching addresses are appended to arrays
+      # takes line_parse[:lines]
+      def lines_to_hash(hash)
+        new_hash = {}
+        hash.each {|k,v|
+          next unless v
+          y = []
+          key = ""
+          v[:address].each {|x| 
+            y << x
+            key = y.map {|z| "[:#{z}]"}.join
+            eval("new_hash#{key} ||= {}")
+          }
+          eval("new_hash#{key} = [] unless new_hash#{key}.is_a?(Array)") 
+          eval("new_hash#{key} << #{v}") 
+        }
+        return new_hash
+      end
+
+      ##
+      # splits nested controller names and returns array
+      def address_parse(str)
+        str ? str.split("/") : nil
+      end
+
+      ##
+      # pulls out ":symbols" for each path and returns them in array
+      # returns array of symbols in arg as string
+      def path_parse(string)
+        string.scan(/:(\w+)\W/).flatten
+      end
+
+      ##
+      # creates variables array for erb test
+      def variable_lines(array)
+        array.map {|x| "#{x} = #{x == "format" ? "nil" : "\"REPLACE\""}"}
+      end
+
+      ##
+      # creates a helper
+      def helper_helper(helper_string, path_string, array)
+        case  
+        when helper_string
+          if array.any? 
+            return "#{helper_string}_path(#{array.map {|x| ":#{x} => #{x}"}.join(", ")})"
+          else
+            return "#{helper_string}_path"
+          end
+        when path_string 
+          vars = path_string.scan(/:\w+/)
+          vars << path_string.scan(/\*\w+/)
+          vars.flatten.each {|x| path_string.sub!(x, "\#{#{x.delete(":").delete("*")}}")}
+          return "\"#{path_string.gsub(/\(|\)/, "").sub(".", "\#{format ? \".\" : nil}")}\""
+        end
+      end
+
+      ##
+      # parses raw text line to hash
+      def line_parse(string, options = {})   
+        m = string.match(LINE_REGEX)
+        helper = m[1].to_s.sub(/(GET|PUT|POST|DELETE)/, "").strip
+        helper = helper.empty? ? nil : helper
+        http_verb = Regexp.last_match ? Regexp.last_match[1] : DEFAULT_HTTP_VERB
+        rhash = m[3] ? eval("#{m[3]}") : {}
+        symbols = path_parse(m[2])
+
+        hash = {
+          :raw => string.strip.squeeze(" "),
+          :helper => helper,
+          :http_verb => http_verb, 
+          :path => m[2],
+          :action => rhash[:action],
+          :controller => rhash[:controller],
+          :symbols => symbols,
+          :address => address_parse(rhash[:controller]), 
+          :status_code => STATUS_CODES[http_verb],
+          :helper_path => helper_helper(helper, m[2], symbols),
+          :vars => variable_lines(symbols)
+        }
+        return hash.merge(options)
+      end
+    end
+  end
+end