makevoid-taza 0.8.6

data/generators/partial/templates/partial.rb.erb

@@ -0,0 +1,7 @@
+require 'rubygems'
+
+module <%= site_name.camelize %>
+  class <%= name.camelize %> < ::Taza::Page
+    
+  end
+end

data/generators/site/site_generator.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rubigen'
+require 'activesupport'
+
+class SiteGenerator < RubiGen::Base
+  default_options :author => nil
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      site_path = File.join('lib','sites')
+      m.template "site.rb.erb", File.join(site_path,"#{name.underscore}.rb")
+      m.directory File.join(site_path,"#{name.underscore}")
+      m.directory File.join(site_path,("#{name.underscore}"),"flows")
+      m.directory File.join(site_path,("#{name.underscore}"),"pages")
+      m.directory File.join(site_path,("#{name.underscore}"),"pages","partials")
+      m.directory File.join('spec','isolation',name.underscore)
+      m.template "site.yml.erb", File.join('config',"#{name.underscore}.yml")
+    end
+  end
+
+  protected
+  def banner
+    <<-EOS
+    Creates a taza site.
+
+    USAGE: #{$0} #{spec.name} name
+    EOS
+  end
+
+  def add_options!(opts)
+    # opts.separator ''
+    # opts.separator 'Options:'
+    # For each option below, place the default
+    # at the top of the file next to "default_options"
+    # opts.on("-a", "--author=\"Your Name\"", String,
+    #         "Some comment about this option",
+    #         "Default: none") { |options[:author]| }
+    # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+  end
+
+  def extract_options
+    # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+    # Templates can access these value via the attr_reader-generated methods, but not the
+    # raw instance variable value.
+    # @author = options[:author]
+  end
+
+end

data/generators/site/templates/site.rb.erb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'taza'
+
+module <%= name.camelize %>
+  include ForwardInitialization
+
+  class <%= name.camelize %> < ::Taza::Site
+
+  end
+end

data/generators/site/templates/site.yml.erb

@@ -0,0 +1,3 @@
+---
+isolation:
+    :url: http://www.google.com

data/lib/app_generators/taza/taza_generator.rb

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'rubigen'
+class TazaGenerator < RubiGen::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  default_options :author => nil
+
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = File.expand_path(args.shift)
+    @name = base_name
+    extract_options
+  end
+
+  def manifest
+    record do |m|    
+      create_directories(m)
+      m.template "rakefile.rb.erb", "rakefile"
+      m.template "config.yml.erb", File.join("config","config.yml")
+      m.template "spec_helper.rb.erb", File.join("spec","spec_helper.rb")
+      m.dependency "install_rubigen_scripts", [destination_root, 'taza'],
+        :shebang => options[:shebang], :collision => :force
+      m.template "console.erb", File.join("script","console")
+      m.template "console.cmd.erb", File.join("script","console.cmd")
+    end
+  end
+
+  def create_directories(m)
+    BASEDIRS.each { |path| m.directory path }
+    m.directory File.join('lib','sites')
+    m.directory File.join('spec','isolation')
+    m.directory File.join('spec','integration')
+    m.directory File.join('spec','story')
+    m.directory 'script'
+  end
+  
+  protected
+    def banner
+      <<-EOS
+USAGE: #{spec.name} path/for/your/test/project [options]
+EOS
+    end
+
+    def add_options!(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    # Installation skeleton.  Intermediate directories are automatically
+    # created so don't sweat their absence here.
+    BASEDIRS = %w(
+      lib
+      config
+      script
+      spec
+    )
+end

data/lib/app_generators/taza/templates/config.yml.erb

@@ -0,0 +1,3 @@
+---
+:browser: :firefox
+:driver: :selenium

data/lib/app_generators/taza/templates/rakefile.rb.erb

@@ -0,0 +1,10 @@
+<%= "#Generated at #{Time.now}" %>
+require 'rubygems'
+require 'taza/tasks'
+
+Taza::Rake::Tasks.new do |t|
+  file_hole = "artifacts/#{Time.now.to_i}"
+  t.spec_opts = ["--format html:#{file_hole}/index.html",
+                  "--format p",
+                  "--format failing_examples:#{file_hole}/failing_examples.txt"]
+end

data/lib/app_generators/taza/templates/spec_helper.rb.erb

@@ -0,0 +1,11 @@
+ENV['TAZA_ENV'] = "isolation" if ENV['TAZA_ENV'].nil?
+require 'rubygems'
+require 'spec'
+require 'mocha'
+
+lib_path = File.expand_path("#{File.dirname(__FILE__)}/../lib/sites")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end

data/lib/extensions/array.rb

@@ -0,0 +1,10 @@
+class Array
+  # Returns true if the two arrays elements are equal ignoring order
+  # Example:
+  #  [1,2].equivalent([2,1])    # => true
+  #  [1,2,3].equivalent([2,1])  # => false
+  def equivalent?(other_array)
+    merged_array = self & other_array
+    merged_array.size == self.size && merged_array.size == other_array.size
+  end
+end

data/lib/extensions/hash.rb

@@ -0,0 +1,15 @@
+class Hash
+  def convert_hash_keys_to_methods(fixture) # :nodoc:
+    Taza::Entity.new(self,fixture)
+  end
+
+  # Recursively replace key names that should be symbols with symbols.
+  def key_strings_to_symbols!
+    result = Hash.new
+    self.each_pair do |key,value|
+      value.key_strings_to_symbols! if value.kind_of? Hash and value.respond_to? :key_strings_to_symbols!
+      result[key.to_sym] = value
+    end
+    self.replace(result)
+  end
+end

data/lib/extensions/object.rb

@@ -0,0 +1,33 @@
+# instance_exec comes with >1.8.7 thankfully
+if VERSION <= '1.8.6'
+  class Object
+    def metaclass
+      class << self; self; end
+    end
+
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    # instance_exec method evaluates a block of code relative to the specified object, with parameters whom come from outside the object.
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(mname="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+      begin
+        ret = send(mname, *args)
+      ensure
+        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+      end
+      ret
+    end
+  end
+end
+class Object
+  def metaclass
+    class << self; self; end
+  end
+end

data/lib/extensions/string.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'activesupport'
+
+class String
+  # pluralizes a string and turns it into a symbol
+  # Example:
+  #  "apple".pluralize_to_sym    # => :apples
+  def pluralize_to_sym
+    self.pluralize.to_sym
+  end
+end

data/lib/taza.rb

@@ -0,0 +1,24 @@
+require 'taza/page'
+require 'taza/site'
+require 'taza/browser'
+require 'taza/settings'
+require 'taza/flow'
+require 'taza/entity'
+require 'taza/fixtures'
+require 'extensions/object'
+require 'extensions/string'
+require 'extensions/hash'
+require 'extensions/array'
+
+module ForwardInitialization
+  module ClassMethods
+    def new(*args,&block)
+      const_get("#{name.split("::").last}").new(*args,&block)
+    end
+  end
+
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+end
+

data/lib/taza/browser.rb

@@ -0,0 +1,53 @@
+module Taza
+  class Browser
+    
+    # Create a browser instance depending on configuration.  Configuration should be read in via Taza::Settings.config.
+    # 
+    # Example:
+    #     browser = Taza::Browser.create(Taza::Settings.config)
+    #
+    def self.create(params={})
+      self.send("create_#{params[:driver]}".to_sym,params)
+    end
+    
+    def self.browser_class(params)
+      self.send("#{params[:driver]}_#{params[:browser]}".to_sym)
+    end
+
+    private    
+
+    def self.create_watir(params)
+      method = "watir_#{params[:browser]}"
+      raise BrowserUnsupportedError unless self.respond_to?(method)
+      watir = self.send(method,params)
+      watir
+    end
+
+    def self.create_selenium(params)
+      require 'selenium'
+      Selenium::SeleniumDriver.new(params[:server_ip],params[:server_port],'*' + params[:browser].to_s,params[:timeout])
+    end
+
+    def self.watir_firefox(params)
+      require 'firewatir'
+      FireWatir::Firefox.new
+    end
+
+    def self.watir_safari(params)
+      require 'safariwatir'
+      Watir::Safari.new
+    end
+
+    def self.watir_ie(params)
+      require 'watir'
+      if params[:attach]
+         browser = Watir::IE.find(:title, //)
+      end
+      browser || Watir::IE.new
+    end
+  end
+  
+  # We don't know how to create the browser you asked for
+  class BrowserUnsupportedError < StandardError; end
+end
+

data/lib/taza/entity.rb

@@ -0,0 +1,55 @@
+module Taza
+
+  class Entity
+    #Creates a entity, pass in a hash to be methodized and the fixture to look up other fixtures (not entirely happy with this abstraction)
+    def initialize(hash,fixture)
+      @hash = hash
+      @fixture = fixture
+      define_methods_for_hash_keys
+    end
+    
+    #This method converts hash keys into methods onto the entity
+    def define_methods_for_hash_keys
+      @hash.keys.each do |key|
+        create_method(key) do
+          get_value_for_entry(key)
+        end
+      end
+    end
+
+    #This method will lookup another fixture if a pluralized fixture exists otherwise return the value in the hash
+    def get_value_for_entry(key) # :nodoc:
+      if @fixture.nil?
+        create_entity_if_value_is_hash(key)
+      elsif @fixture.fixture_exists?(key)
+        @fixture.specific_fixture_entities(key.to_sym, @hash[key])
+      elsif @fixture.pluralized_fixture_exists?(key)
+        @fixture.get_fixture_entity(key.pluralize.to_sym,@hash[key])
+      else
+        create_entity_if_value_is_hash(key)
+      end
+    end
+    alias :[] :get_value_for_entry
+    
+    def create_entity_if_value_is_hash(key)
+      if (@fixture.nil? && @hash[key].is_a?(Hash))
+          Entity.new(@hash[key], nil)
+      elsif (!@fixture.nil? && @hash[key].is_a?(Hash))
+          Entity.new(@hash[key], @fixture)
+      else
+          @hash[key]
+      end
+    end
+
+    def to_hash
+      cloned_hash = @hash.clone
+      cloned_hash.key_strings_to_symbols!
+    end
+
+    private
+    def create_method(name, &block) # :nodoc:
+      self.class.send(:define_method, name, &block)
+    end
+
+  end
+end

data/lib/taza/fixture.rb

@@ -0,0 +1,68 @@
+require 'find'
+require 'erb'
+require 'extensions/hash'
+require 'taza/entity'
+
+module Taza
+  # The module that will mixin methods based on the fixture files in your 'spec/fixtures'
+  # 
+  # Example:
+  #   describe "something" do
+  #     it "should test something" do
+  #       users(:jane_smith).first_name.should eql("jane")
+  #     end
+  #   end
+  # 
+  #  where there is a spec/fixtures/users.yml file containing a entry of:
+  # jane_smith:
+  #   first_name: jane
+  #   last_name: smith
+  class Fixture # :nodoc:
+
+    def initialize # :nodoc:
+      @fixtures = {}
+    end
+
+    def load_fixtures_from(dir) # :nodoc:
+      Dir.glob(File.join(dir,'*.yml')) do |file|
+        templatized_fixture=ERB.new(File.read(file))
+        entitized_fixture = {}
+        YAML.load(templatized_fixture.result()).each do |key, value|
+          entitized_fixture[key] = value.convert_hash_keys_to_methods(self)
+        end
+        @fixtures[File.basename(file,'.yml').to_sym] = entitized_fixture
+      end
+    end
+    
+    def fixture_names # :nodoc:
+      @fixtures.keys
+    end
+
+    def get_fixture(fixture_file_key)
+      @fixtures[fixture_file_key]
+    end  
+    
+    def get_fixture_entity(fixture_file_key,entity_key) # :nodoc:
+      @fixtures[fixture_file_key][entity_key]
+    end
+
+    def pluralized_fixture_exists?(singularized_fixture_name) # :nodoc:
+      fixture_exists?(singularized_fixture_name.pluralize.to_sym)
+    end
+    
+    def specific_fixture_entities(fixture_key, select_array)
+      cloned_fixture = @fixtures[fixture_key].clone
+      cloned_fixture.delete_if {|key , value| !select_array.include?(key)}
+    end
+
+    def fixture_exists?(fixture_name)
+      fixture_names.include?(fixture_name.to_sym)
+    end
+
+   def self.base_path # :nodoc:
+     File.join('.','spec','fixtures','')
+   end
+  end
+  
+end
+