mundo-pepino 0.1.2 → 0.1.3

data/History.txt

@@ -1,3 +1,8 @@
+== 0.1.3 2009-10-27
+* path_to method sensitivity: if present, url_mappings are disabled
+* Configuration as Rails teach me: MundoPepino.configure
+* Possibility to map to dynamic values with access to the World
+
 == 0.1.2 2009-10-20
 
 * 2 major enhancements

data/Manifest.txt

@@ -5,14 +5,17 @@ README.markdown
 README_es.markdown
 init.rb
 lib/mundo_pepino.rb
+lib/mundo_pepino/base.rb
+lib/mundo_pepino/config.rb
 lib/mundo_pepino/definitions/en_US.rb
 lib/mundo_pepino/definitions/es_ES.rb
+lib/mundo_pepino/en_US.rb
+lib/mundo_pepino/es_ES.rb
 lib/mundo_pepino/implementations.rb
+lib/mundo_pepino/implementations_api.rb
 lib/mundo_pepino/resources_history.rb
 lib/mundo_pepino/version.rb
 lib/mundo_pepino/visits_history.rb
-lib/mundo_pepino_en_US.rb
-lib/mundo_pepino_es_ES.rb
 rails_generators/caracteristica/USAGE
 rails_generators/caracteristica/caracteristica_generator.rb
 rails_generators/caracteristica/templates/caracteristica.erb

data/README.markdown

@@ -17,8 +17,14 @@ MundoPepino is a set of reusable step definitions to test Rails apps with Cucumb
 
 **DISCLAIMER**:
 
-MundoPepino was originally implemented to write features in Spanish. However its design has been modified to support different languages (and, theoretically, at the same time if needed). Currently only part of the original set of steps (and just a little of the documentation) has been translated to English.
+MundoPepino was originally implemented to write features in Spanish. Its code has been recently modified to support different languages (and, theoretically, at the same time if needed).
 
+Currently only part of the original set of steps (and just a little of the documentation) has been translated to English. On the other hand features written in English don't have to manage the complexity added by translations of models and attributes. Cousin projects like [pickle](http://github.com/ianwhite/pickle) or [email-spec](http://github.com/bmabey/email-spec) are much more advanced to write features in English.
+
+For other languages, before start your own implementation, it'd be nice if you:
+
+* start a new language in MundoPepino (we'll be glad to help you if you try), or
+* look for your language in [similar i18n projects](http://groups.google.com/group/cukes/browse_thread/thread/b9b8ff6301393c19/febf6530a1ed1a37).
 
 ## Resources
 

data/README_es.markdown

@@ -65,7 +65,11 @@ Como plugin (ver dependencias más abajo):
     script/plugin install git://github.com/dchelimsky/rspec.git
     script/plugin install git://github.com/dchelimsky/rspec-rails.git
 
-  Además necesitamos instalar la gema o plugin StringMapper (ver más abajo):
+  Además necesitamos instalar la gema o plugin StringMapper:
+
+    gem install string-mapper
+
+  o
 
     script/plugin install git://github.com/nando/string-mapper.git
 
@@ -74,12 +78,6 @@ Como plugin (ver dependencias más abajo):
 * instalar el módulo ruby-locale,
 * o redefinir la función strftime para lograr dicho comportamiento.
 
-#### [StringMapper](http://github.com/nando/string-mapper)
-
-  StringMapper es una extensión de la clase String para obtener modelos, números, nombres de campo, etc. a partir de sus nombres en castellano.
-
-    script/plugin install git://github.com/nando/string-mapper.git
-
 #### [FixtureReplacement](http://replacefixtures.rubyforge.org/)
 
 De fábrica MundoPepino utiliza ActiveRecord para incorporar a la BBDD los datos que soliciten los escenarios. 
@@ -157,62 +155,33 @@ Y posteriormente en las vistas llamamos al helper con algo parecido a:
     <%= pepino.datetime_select :harvested_at, :use_month_names => Meses %>
 
 ## Uso
-
-Para utilizar MundoPepino en una aplicación en la que todavía no estamos utilizando Cucumber lo más cómodo es comenzar utilizando los generadores (de forma similar a como se describe más arriba en *Toma de contacto*). Algo como:
-
-    cd miapp-sin-cucumber
-    script/plugin install git://github.com/nando/string-mapper.git
-    script/plugin install git://github.com/nando/mundo-pepino.git
-    script/generate mundo_pepino
-    script/generate caracteristica Model Modelo name:string:nombre used:boolean:usado
-
-Aquí ya deberíamos poder lanzar `rake caracteristicas`, obteniendo eso sí los errores pertinentes relacionados con implementación concreta de nuestro controlador. El fichero `gestion_de_modelo.feature` (que podemos renombrar por algo más chulo) nos servirá de patrón para escribir nuestra /característica/.
-
-Para utilizar MundoPepino en una aplicación en la que ya estamos utilizando Cucumber, al final de `features/support/env.rb` (o equivalente) incorporamos lo siguiente:
-
-    require 'mundo_pepino'
-    String.model_mappings = {} # Mapeo castellano-inglés de modelos
-    String.field_mappings = {} # Mapeo castellano-inglés de campos
-    
-    World do
-      MundoPepino.new
-    end
-
-Es recomendable también vaciar el contenido de la BBDD antes de comenzar la evaluación de un nuevo escenario para que los datos que pueda haber de otros escenarios no alteren su resultado. La función *Before* nos puede ayudar para conseguirlo, haciendo algo como:
-
-    Before do
-      MiModelo.destroy_all
-      MiOtroModelo.destroy_all # etc.
-    end
-
-*Before* se ejecutará antes de cada escenario y que los //Antecetentes// ((Background)[http://wiki.github.com/aslakhellesoy/cucumber/background]) de los mismos si los hubiese.
-
 ### generate mundo\_pepino
 
     rails_root$ script/generate mundo_pepino
-          create  caracteristicas/support
-          create  caracteristicas/support/mundo_pepino_env.rb
+          exists  features/step_definitions
+          create  features/step_definitions/mundo_pepino_es_ES.rb
           exists  lib/tasks
           create  lib/tasks/mundo_pepino.rake
 
-El principio de `mundo_pepino_env.rb` es el contenido del `env.rb` generado por `generate cucumber`, tras el cual añade lo siguiente:
+En `mundo_pepino_es_ES.rb` tenemos lo siguiente:
 
-    require 'mundo_pepino'          # Cargamos MundoPepino...
-    MundoPepino::ModelsToClean = [] # Array con los modelos que serán limpiados 
+    require 'mundo_pepino/es_ES'    # Cargamos las definiciones en castellano
+    MundoPepino.configure do |c|
+      c.models_to_clean = []        # Array con los modelos que serán limpiados 
                                     # antes de lanzar cada escenario.
-    String.model_mappings = {}      # Hash con el mapeo de los modelos a partir
+      c.model_mappings = {}         # Hash con el mapeo de los modelos a partir
                                     # de sus equivalencias en castellano.
-    String.field_mappings = {}      # Hash con el mapeo de los campos.
+      c.field_mappings = {}         # Hash con el mapeo de los campos.
     class MiMundo < MundoPepino     # Ejemplo de uso del MundoPepio con herencia. 
       # include FixtureReplacement  # FR listo para entrar en acción. Meter aquí 
       # def mi_funcion; ...; end    # las funciones específicas que necesitemos
     end                             # desde nuestras definiciones.
     Before do                       # La limpieza de modelos propiamente dicha... 
-      MundoPepino::ModelsToClean.each { |model| model.destroy_all }
-    end                             # ...se realizará antes de cada escenario.  
-    World do                        # Finalmente le pedimos a Cucumber que
-      MiMundo.new                   # utilice una instancia de nuestro mundo como
-    end                             # ámbito local de nuestros escenarios.
+      MundoPepino.clean_models
+    end                             # ...se realizará antes de cada escenario.
+                                    # Finalmente le pedimos a Cucumber que
+    World(MiMundo)                  # utilice una instancia de nuestro mundo como
+                                    # ámbito local de nuestros escenarios.
 
 Por otro lado `mundo_pepino.rake` añade una tarea llamada **caracteristicas** que lanza con la opción `--language es` todos los ficheros con extensión `.feature` que tengamos dentro del directorio `caracteristicas`.
 

data/lib/mundo_pepino.rb

@@ -1,260 +1,76 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-require 'cucumber/rails/world'
+require 'mundo_pepino/base'
+require 'mundo_pepino/implementations_api'
 require 'mundo_pepino/implementations'
 require 'mundo_pepino/resources_history'
 require 'mundo_pepino/visits_history'
 require 'mundo_pepino/version'
+require 'mundo_pepino/config'
 
 require 'string-mapper'
 
-String.add_mapper :model
-String.add_mapper :relation_model
-String.add_mapper(:content_type,
-  /\.png$/   => 'image/png',
-  /\.jpe?g$/ => 'image/jpg',
-  /\.gif$/   => 'image/gif') { |str| 'text/plain' }
-String.add_mapper(:underscored) { |string| string.gsub(/ +/, '_') }
-String.add_mapper(:unquoted) { |str| str =~ /^['"](.*)['"]$/ ? $1 : str}
-String.add_mapper(:translated) { |str|
-  if str =~ /^[a-z_]+\.[a-z_]+[a-z_\.]+$/
-    I18n.translate(str, :default => str)
-  elsif str =~ /^([a-z_]+\.[a-z_]+[a-z_\.]+),(\{.+\})$/
-    I18n.translate($1, {:default => str}.merge(eval($2)))
-  else
-    str
-  end
-}
-
 module MundoPepino
+  include Base
+  include ImplementationsApi
   include Implementations
   include ResourcesHistory
   include VisitsHistory
-	
-  def real_value_for(v)
-    (v.is_a?(String) ? v.to_real_value : v )
-  end
 
-  def parsed_attributes(raw_attributes)
-    attributes = {}
-    raw_attributes.each do |k, v|
-      if k =~ /^(.+)_id$/
-        if polymorph = raw_attributes.delete($1 + '_type')
-          attributes[$1.to_sym] = polymorph.constantize.find(v.to_i)
+  class << self
+    attr_accessor :world 
+    def extended(current_world)
+      self.world = current_world
+      common_mappings
+      language_specific_mappings
+      user_specific_mappings
+    end
+
+    def common_mappings
+      String.add_mapper :model
+      String.add_mapper :relation_model
+      String.add_mapper(:content_type,
+        /\.png$/   => 'image/png',
+        /\.jpe?g$/ => 'image/jpg',
+        /\.gif$/   => 'image/gif') { |str| 'text/plain' }
+      String.add_mapper(:underscored) { |string| string.gsub(/ +/, '_') }
+      String.add_mapper(:unquoted) { |str| str =~ /^['"](.*)['"]$/ ? $1 : str}
+      String.add_mapper(:translated) do |str|
+        if str =~ /^[a-z_]+\.[a-z_]+[a-z_\.]+$/
+          I18n.translate(str, :default => str)
+        elsif str =~ /^([a-z_]+\.[a-z_]+[a-z_\.]+),(\{.+\})$/
+          I18n.translate($1, {:default => str}.merge(eval($2)))
         else
-          attributes[$1.to_sym] = ($1.to_relation_model || $1.camelize.constantize).find(v.to_i)
+          str
         end
-      else
-        attributes[k] = real_value_for(v)
       end
-    end
-    attributes
-  end
-
-  def create(model, raw_attributes = {})
-    through = raw_attributes.delete(:through)
-    attributes = parsed_attributes(raw_attributes)
-    obj = if defined?(FixtureReplacement)
-      self.send "create_#{model.name.underscore}", attributes
-    elsif defined?(Machinist)
-      model.make attributes
-    elsif defined?(Factory)
-      Factory(model.name.underscore.to_sym, attributes)
-    else
-      model.create! attributes
-    end
-    if(through)
-      create through['model'], through['attributes'].merge(model.name.underscore.to_sym => obj)
-    end
-    obj
-  end
-
-  def find_or_create(model_or_modelo, attributes = {}, options = {}) 
-    model = if model_or_modelo.is_a?(String)
-      model_or_modelo.to_model
-    else
-      model_or_modelo
-    end
-    if attributes.any?
-      attribs = Hash.new
-      attributes.each do |key, value|
-        if child_model = (key.to_s.to_model || key.to_s.to_relation_model)
-          child = add_resource(child_model, field_for(child_model, 'nombre') => value)
-          field_name = key.to_s.to_relation_model ? key : child_model.name.underscore
-          attribs["#{field_name}_id"] = child.id
+      String.add_mapper(:url) do |string|
+        if world.respond_to? :path_to
+          world.path_to string
         else
-          attribs[key] = value
-        end
-      end
-      if ((options[:force_creation].nil? || !options[:force_creation])  &&
-          obj = model.find(:first, :conditions => conditions_from_attributes(attribs)))
-        if(through = attribs[:through])
-          create through['model'], through['attributes'].merge(model.name.underscore.to_sym => obj)
+          string if string =~ /^\/.*$|^https?:\/\//i
         end
-        obj
-      else
-        create model, attribs
       end
-    else
-      create model
     end
-  end
-
-  def conditions_from_attributes(attributes)
-    attribs = attributes.reject {|k,v| k == :through} 
-    [attribs.keys.map{|s| "#{s}=?"}.join(' AND ')] + attribs.values
-  end
 
-  def names_for_simple_creation(model, number, name_or_names, options = {})
-    base_hash = base_hash_for(options)
-    if name_or_names
-      field = field_for(model, 'nombre')
-      names = name_or_names.split(/ ?, | y /)
-      if names.size == number
-        names.map { |name| base_hash.dup.merge(field => name) }
-      else
-        [base_hash.dup.merge(field => name_or_names)] * number
-      end
-    else
-      [base_hash] * number
+    def config
+      @config ||= Config.new
     end
-  end
 
-  def field_for(model, campo = 'nombre')
-    "#{model && model.name}::#{campo}".to_field || campo.to_field
-  end
-  def shouldify(should_or_not)
-    affirmative = 'debo|debo ver|veo|deber[ií]a|deber[íi]a ver|leo|debo leer|deber[ií]a leer'
-    should_or_not =~ /^(#{affirmative})$/i ? :should : :should_not
-  end
-
-  def not_shouldify(should_or_not)
-    shouldify(should_or_not) == :should ? :should_not : :should
-  end
-
-  def relative_page(pagina)
-    if pagina =~ /la siguiente p[aá]gina|la p[aá]gina anterior/i
-      head, current, tail = if last_visited =~ /(.+page=)(\d+)(.*)/
-        [$1, $2.to_i, $3]
-      else
-        [last_visited + '?page=', 1, '']
-      end
-      (pagina =~ /siguiente/ ? current += 1 : current -= 1)
-      head + current.to_s + tail
-    else
-      nil
+    def configure(&block)
+      config.configure(&block)
     end
-  end
 
-  # Cucumber::Model::Table's hashes traduciendo nombres de campo
-  def translated_hashes(step_table, options = {})
-    base_hash = base_hash_for(options)
-    header = step_table[0].map do |campo| 
-      field_for(options[:model], campo) || campo 
+    def clean_models
+      config.models_to_clean.each { |model| model.destroy_all }
     end
-    step_table[1..-1].map do |row|
-      h = base_hash.dup
-      row.each_with_index do |v,n|
-        key = header[n]
-        h[key] = v
-      end
-      h
-    end
-  end
 
-  def base_hash_for(options) 
-    if options[:parent]
-      # polymorphic associations
-      if options[:polymorphic_as]
-        { "#{options[:polymorphic_as]}_id" => options[:parent].id,
-          "#{options[:polymorphic_as]}_type" => options[:parent].class.name }
-      else 
-        field_prefix = options[:parent].class.name.underscore
-        if options[:through]
-          {:through => {"model" => eval(options[:through].to_s.classify),
-                        "attributes" => {"#{field_prefix}_id"  => options[:parent].id}}}
-        else
-          { "#{field_prefix}_id" => options[:parent].id }
-        end
-      end
-    else
-      {}
-    end
-  end
-
-  def campo_to_field(campo, model = nil)
-    unless campo.nil? 
-      if field = field_for(model, campo.to_unquoted)
-        field
-      else
-        raise MundoPepino::FieldNotMapped.new(campo) 
-      end
-    end
-  end
-  
-  def last_mentioned_should_have_value(campo, valor)
-    res = last_mentioned
-    if child_model = campo.to_model
-      child = child_model.find_by_name(valor)
-      child_field = campo.to_field || child_model.name.underscore
-      (res.send child_field).should == child
-    elsif field = field_for(res.class, campo)
-      (res.send field).to_s.should == valor.to_s
-    else
-      raise FieldNotMapped.new(campo)
-    end
-  end
-  
-  def last_mentioned_should_have_child(child, name)
-    if child_model = child.to_model
-      child = child_model.find_by_name(name)
-      (last_mentioned.send child_model.table_name).detect do |c|
-        c.id == child.id 
-      end.should_not be_nil
-    else
-      raise ModelNotMapped.new(child)
+    def user_specific_mappings
+      config.model_mappings.each {|k,v| String.model_mappings[k] = v}
+      config.relation_model_mappings.each {|k,v| String.relation_model_mappings[k] = v}
+      config.field_mappings.each {|k,v| String.field_mappings[k] = v}
+      config.url_mappings.each {|k,v| String.url_mappings[k] = v}
     end
   end
-  
-  def find_field_and_do_with_webrat(action, campo, options = nil)
-    do_with_webrat action, campo.to_unquoted.to_translated, options # a pelo (localización vía labels)
-  rescue Webrat::NotFoundError
-    field = campo_to_field(campo, last_mentioned_model)
-    begin 
-      do_with_webrat action, field, options # campo traducido tal cual...
-    rescue Webrat::NotFoundError
-      if singular = last_mentioned_singular # traducido y con el modelo por delante
-        do_with_webrat action, singular + '_' + field.to_s, options # p.e.: user_name
-      else
-        raise
-      end
-    end
-  end
-
-  def do_with_webrat(action, field, options)
-    if options
-      if options[:path] and options[:content_type]
-        self.send action, field, options[:path], options[:content_type]
-      else
-        self.send action, field, options
-      end
-    else
-      self.send action, field
-    end
-  end
-
-  def parent_options(parent, child)
-   options = {:parent => parent}
-    # polymorphic associations
-    if reflections = parent.class.reflect_on_association(child.table_name.to_sym)
-      if reflections.options[:as]
-        options.merge!({:polymorphic_as => reflections.options[:as]})
-      elsif reflections.options[:through]
-        options.merge!({:through => reflections.options[:through]})
-      end
-    end
-    options
-  end
-
 end

data/lib/mundo_pepino/base.rb

@@ -0,0 +1,73 @@
+module MundoPepino
+  module Base
+    def parsed_attributes(raw_attributes)
+      attributes = {}
+      raw_attributes.each do |k, v|
+        if k =~ /^(.+)_id$/
+          if polymorph = raw_attributes.delete($1 + '_type')
+            attributes[$1.to_sym] = polymorph.constantize.find(v.to_i)
+          else
+            attributes[$1.to_sym] = ($1.to_relation_model || $1.camelize.constantize).find(v.to_i)
+          end
+        else
+          attributes[k] = real_value_for(v)
+        end
+      end
+      attributes
+    end
+  
+    def create(model, raw_attributes = {})
+      through = raw_attributes.delete(:through)
+      attributes = parsed_attributes(raw_attributes)
+      obj = if defined?(FixtureReplacement)
+        self.send "create_#{model.name.underscore}", attributes
+      elsif defined?(Machinist)
+        model.make attributes
+      elsif defined?(Factory)
+        Factory(model.name.underscore.to_sym, attributes)
+      else
+        model.create! attributes
+      end
+      if(through)
+        create through['model'], through['attributes'].merge(model.name.underscore.to_sym => obj)
+      end
+      obj
+    end
+  
+    def find_or_create(model_or_modelo, attributes = {}, options = {}) 
+      model = if model_or_modelo.is_a?(String)
+        model_or_modelo.to_model
+      else
+        model_or_modelo
+      end
+      if attributes.any?
+        attribs = Hash.new
+        attributes.each do |key, value|
+          if child_model = (key.to_s.to_model || key.to_s.to_relation_model)
+            child = add_resource(child_model, field_for(child_model, 'nombre') => value)
+            field_name = key.to_s.to_relation_model ? key : child_model.name.underscore
+            attribs["#{field_name}_id"] = child.id
+          else
+            attribs[key] = value
+          end
+        end
+        if ((options[:force_creation].nil? || !options[:force_creation])  &&
+            obj = model.find(:first, :conditions => conditions_from_attributes(attribs)))
+          if(through = attribs[:through])
+            create through['model'], through['attributes'].merge(model.name.underscore.to_sym => obj)
+          end
+          obj
+        else
+          create model, attribs
+        end
+      else
+        create model
+      end
+    end
+  
+    def conditions_from_attributes(attributes)
+      attribs = attributes.reject {|k,v| k == :through} 
+      [attribs.keys.map{|s| "#{s}=?"}.join(' AND ')] + attribs.values
+    end
+  end
+end

data/lib/mundo_pepino/config.rb

@@ -0,0 +1,26 @@
+require 'ostruct'
+
+module MundoPepino
+  class Config
+    attr_accessor :models_to_clean,
+      :model_mappings,
+      :field_mappings,
+      :relation_model_mappings,
+      :url_mappings
+    
+    def initialize(&block)
+      @models_to_clean = []
+      @model_mappings, @field_mappings, 
+        @relation_model_mappings, @url_mappings = {}, {}, {}, {}
+      configure(&block) if block_given?
+    end
+    
+    def configure(&block)
+      yield(self)
+    end
+    
+    def models_to_clean
+      @models_to_clean ||= []
+    end
+  end
+end

data/lib/mundo_pepino/definitions/en_US.rb

@@ -1,41 +1,45 @@
 # MundoPepino's step definitions in en_US
-
-String.add_mapper(:real_value, {
-  /^tru(e|th)$/i  => true,
-  /^false$/i       => false
-}) { |value| value }  # "true".to_real_value # => true
-String.add_mapper(:field, {:nombre => :name})
-
-String.add_mapper(:url, /^the home(page)?/i => '/') do |string| 
-  string if string =~ /^\/.*$|^https?:\/\//i
+module MundoPepino
+  class << self
+    def language_specific_mappings
+      String.add_mapper(:real_value, {
+        /^tru(e|th)$/i  => true,
+        /^false$/i       => false
+      }) { |value| value }  # "true".to_real_value # => true
+      String.add_mapper(:field, {:nombre => :name})
+    
+      String.add_mapper(:number, { 
+        /^an?$/i    => 1,
+        /^one$/i    => 1,
+        /^first?$/i => 1,
+        /^two$/i    => 2,
+        /^second$/i => 2,
+        /^three$/i  => 3,
+        /^third$/i  => 3,
+        /^four$/i   => 4,
+        /^fourth$/i => 4,
+        /^five$/i   => 5,
+        /^fifth$/i  => 5}) { |string| string.to_i }
+      String.add_mapper(:crud_action,
+        /^creation$/i           => 'new',
+        /^changes?$/i                => 'edit',
+        /^modifications?$/i       => 'edit',
+        /^editions?$/i            => 'edit') { |action| action }
+      String.add_mapper(:month) { |month| month.capitalize }
+      unless self.world.respond_to? :path_to
+        String.url_mappings[/^the home\s?page/i] = self.world.root_path
+      end
+    end
+  end
 end
 
-String.add_mapper(:number, { 
-  /^an?$/i    => 1,
-  /^one$/i    => 1,
-  /^first?$/i => 1,
-  /^two$/i    => 2,
-  /^second$/i => 2,
-  /^three$/i  => 3,
-  /^third$/i  => 3,
-  /^four$/i   => 4,
-  /^fourth$/i => 4,
-  /^five$/i   => 5,
-  /^fifth$/i  => 5}) { |string| string.to_i }
-String.add_mapper(:crud_action,
-  /^creation$/i           => 'new',
-  /^changes?$/i                => 'edit',
-  /^modifications?$/i       => 'edit',
-  /^editions?$/i            => 'edit') { |action| action }
-String.add_mapper(:month) { |month| month.capitalize }
-
-number = 'a|an|one|two|three|four|five|six|seven|eight|nine|ten|\d+'
+match_number = 'a|an|one|two|three|four|five|six|seven|eight|nine|ten|\d+'
 which = '(?:which|that have as)'
 # Simple creation w/ optional name/s
-Given /^(?:that we have )?(#{number}) (?!.+ #{which})(.+?)(?: (?:called )?['"](.+)["'])?$/i do |number, model, name|
+Given /^(?:that we have )?(#{match_number}) (?!.+ #{which})(.+?)(?: (?:called )?['"](.+)["'])?$/i do |number, model, name|
   given_we_have_a_number_of_instances_called number, model, name 
 end
 
-Then /^we have (#{number}) ([^ ]+)(?: (?:called )?['"](.+)["'])? in our database$/ do |number, model, names|
+Then /^we have (#{match_number}) ([^ ]+)(?: (?:called )?['"](.+)["'])? in our database$/ do |number, model, names|
   then_we_have_a_number_of_instances_in_our_database number, model, names
 end

data/lib/mundo_pepino/definitions/es_ES.rb

@@ -1,45 +1,51 @@
 # MundoPepino's step definitions in es_ES
+module MundoPepino
+  class << self
+    def language_specific_mappings
+      String.add_mapper(:real_value, {
+        /^verdader[oa]$/i  => true,
+        /^fals[ao]$/i      => false
+      }) { |value| value }
+      String.add_mapper(:field) { |str| :name if str =~ /nombres?/ }
+      
+      String.add_mapper(:number, { 
+        /^un[oa]?$/i     => 1,
+        /^primer[oa]?$/i => 1,
+        :dos             => 2,
+        /^segund[oa]?$/i => 2,
+        :tres            => 3,
+        /^tercer[ao]/i   => 3,
+        :cuatro          => 4,
+        /^cuart[ao]/i    => 4,
+        :cinco           => 5,
+        /^quint[ao]/i    => 5}) { |string| string.to_i }
+      String.add_mapper(:crud_action,
+        /^alta$/i                  => 'new',
+        /^creaci[óo]n$/i           => 'new',
+        /^nuev(?:o|a|o\/a|a\/o)$/i => 'new',
+        /^cambio$/i                => 'edit',
+        /^modificaci[oó]n(?:es)?$/i       => 'edit',
+        /^edici[oó]n$/i            => 'edit')
+      String.add_mapper(:month,
+        :enero           => 'January',
+        :febrero         => 'February',
+        :marzo           => 'March',
+        :abril           => 'April',
+        :mayo            => 'May',
+        :junio           => 'June',
+        :julio           => 'July',
+        :agosto          => 'August',
+        /^sep?tiembre$/i  => 'September',
+        :octubre         => 'October',
+        :noviembre       => 'November',
+        :diciembre       => 'December')
+      unless self.world.respond_to? :path_to
+        String.url_mappings[/^la (?:portada|home\s?(?:page)?)/i] = self.world.root_path
+      end
 
-String.add_mapper(:real_value, {
-  /^verdader[oa]$/i  => true,
-  /^fals[ao]$/i      => false
-}) { |value| value }
-String.add_mapper(:field) { |str| :name if str =~ /nombres?/ }
-String.add_mapper(:url, /^la (portada|home)/i => '/') do |string| 
-  string if string =~ /^\/.*$|^https?:\/\//i
-end
-
-String.add_mapper(:number, { 
-  /^un[oa]?$/i     => 1,
-  /^primer[oa]?$/i => 1,
-  :dos            => 2,
-  /^segund[oa]?$/i => 2,
-  :tres         => 3,
-  /^tercer[ao]/i => 3,
-  :cuatro      => 4,
-  /^cuart[ao]/i => 4,
-  :cinco       => 5,
-  /^quint[ao]/i => 5}) { |string| string.to_i }
-String.add_mapper(:crud_action,
-  /^alta$/i                  => 'new',
-  /^creaci[óo]n$/i           => 'new',
-  /^nuev(?:o|a|o\/a|a\/o)$/i => 'new',
-  /^cambio$/i                => 'edit',
-  /^modificaci[oó]n(?:es)?$/i       => 'edit',
-  /^edici[oó]n$/i            => 'edit')
-String.add_mapper(:month,
-  :enero           => 'January',
-  :febrero         => 'February',
-  :marzo           => 'March',
-  :abril           => 'April',
-  :mayo            => 'May',
-  :junio           => 'June',
-  :julio           => 'July',
-  :agosto          => 'August',
-  /^sep?tiembre$/i  => 'September',
-  :octubre         => 'October',
-  :noviembre       => 'November',
-  :diciembre       => 'December')
+    end
+  end
+end
 
 nro = 'un|una|dos|tres|cuatro|cinco|seis|siete|ocho|nueve|diez|\d+'
 cuyo = '(?:cuy[oa]s?|que tienen? como)'
@@ -300,9 +306,7 @@ Entonces /^(#{veo_o_no}) (?:las|los) siguientes (?:etiquetas|selectores):$/i do
   end
 end
 
-
-
-Entonces /^(#{veo_o_no}) un enlace (?:a|para) (.+)?$/i do |should, pagina|
+Entonces /^(#{veo_o_no}) un enlace (?:al?|para) (.+)?$/i do |should, pagina|
   lambda {
     href = relative_page(pagina) || pagina.to_unquoted.to_url 
     response.should have_tag('a[href=?]', href)

data/lib/mundo_pepino/implementations_api.rb

@@ -0,0 +1,160 @@
+module MundoPepino
+  module ImplementationsApi
+    def real_value_for(v)
+      (v.is_a?(String) ? v.to_real_value : v )
+    end
+
+    def names_for_simple_creation(model, number, name_or_names, options = {})
+      base_hash = base_hash_for(options)
+      if name_or_names
+        field = field_for(model, 'nombre')
+        names = name_or_names.split(/ ?, | y /)
+        if names.size == number
+          names.map { |name| base_hash.dup.merge(field => name) }
+        else
+          [base_hash.dup.merge(field => name_or_names)] * number
+        end
+      else
+        [base_hash] * number
+      end
+    end
+  
+    def field_for(model, campo = 'nombre')
+      "#{model && model.name}::#{campo}".to_field || campo.to_field
+    end
+
+    def shouldify(should_or_not)
+      affirmative = 'debo|debo ver|veo|deber[ií]a|deber[íi]a ver|leo|debo leer|deber[ií]a leer'
+      should_or_not =~ /^(#{affirmative})$/i ? :should : :should_not
+    end
+  
+    def not_shouldify(should_or_not)
+      shouldify(should_or_not) == :should ? :should_not : :should
+    end
+  
+    def relative_page(pagina)
+      if pagina =~ /la siguiente p[aá]gina|la p[aá]gina anterior/i
+        head, current, tail = if last_visited =~ /(.+page=)(\d+)(.*)/
+          [$1, $2.to_i, $3]
+        else
+          [last_visited + '?page=', 1, '']
+        end
+        (pagina =~ /siguiente/ ? current += 1 : current -= 1)
+        head + current.to_s + tail
+      else
+        nil
+      end
+    end
+  
+    # Cucumber::Model::Table's hashes traduciendo nombres de campo
+    def translated_hashes(step_table, options = {})
+      base_hash = base_hash_for(options)
+      header = step_table[0].map do |campo| 
+        field_for(options[:model], campo) || campo 
+      end
+      step_table[1..-1].map do |row|
+        h = base_hash.dup
+        row.each_with_index do |v,n|
+          key = header[n]
+          h[key] = v
+        end
+        h
+      end
+    end
+  
+    def base_hash_for(options) 
+      if options[:parent]
+        # polymorphic associations
+        if options[:polymorphic_as]
+          { "#{options[:polymorphic_as]}_id" => options[:parent].id,
+            "#{options[:polymorphic_as]}_type" => options[:parent].class.name }
+        else 
+          field_prefix = options[:parent].class.name.underscore
+          if options[:through]
+            {:through => {"model" => eval(options[:through].to_s.classify),
+                          "attributes" => {"#{field_prefix}_id"  => options[:parent].id}}}
+          else
+            { "#{field_prefix}_id" => options[:parent].id }
+          end
+        end
+      else
+        {}
+      end
+    end
+  
+    def campo_to_field(campo, model = nil)
+      unless campo.nil? 
+        if field = field_for(model, campo.to_unquoted)
+          field
+        else
+          raise MundoPepino::FieldNotMapped.new(campo) 
+        end
+      end
+    end
+    
+    def last_mentioned_should_have_value(campo, valor)
+      res = last_mentioned
+      if child_model = campo.to_model
+        child = child_model.find_by_name(valor)
+        child_field = campo.to_field || child_model.name.underscore
+        (res.send child_field).should == child
+      elsif field = field_for(res.class, campo)
+        (res.send field).to_s.should == valor.to_s
+      else
+        raise FieldNotMapped.new(campo)
+      end
+    end
+    
+    def last_mentioned_should_have_child(child, name)
+      if child_model = child.to_model
+        child = child_model.find_by_name(name)
+        (last_mentioned.send child_model.table_name).detect do |c|
+          c.id == child.id 
+        end.should_not be_nil
+      else
+        raise ModelNotMapped.new(child)
+      end
+    end
+    
+    def find_field_and_do_with_webrat(action, campo, options = nil)
+      do_with_webrat action, campo.to_unquoted.to_translated, options # a pelo (localización vía labels)
+    rescue Webrat::NotFoundError
+      field = campo_to_field(campo, last_mentioned_model)
+      begin 
+        do_with_webrat action, field, options # campo traducido tal cual...
+      rescue Webrat::NotFoundError
+        if singular = last_mentioned_singular # traducido y con el modelo por delante
+          do_with_webrat action, singular + '_' + field.to_s, options # p.e.: user_name
+        else
+          raise
+        end
+      end
+    end
+  
+    def do_with_webrat(action, field, options)
+      if options
+        if options[:path] and options[:content_type]
+          self.send action, field, options[:path], options[:content_type]
+        else
+          self.send action, field, options
+        end
+      else
+        self.send action, field
+      end
+    end
+  
+    def parent_options(parent, child)
+     options = {:parent => parent}
+      # polymorphic associations
+      if reflections = parent.class.reflect_on_association(child.table_name.to_sym)
+        if reflections.options[:as]
+          options.merge!({:polymorphic_as => reflections.options[:as]})
+        elsif reflections.options[:through]
+          options.merge!({:through => reflections.options[:through]})
+        end
+      end
+      options
+    end
+  end  
+end
+

data/lib/mundo_pepino/version.rb

@@ -2,7 +2,7 @@ module MundoPepino #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 2
+    TINY  = 3
     PATCH = nil # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')

data/rails_generators/caracteristica/caracteristica_generator.rb

@@ -16,17 +16,17 @@ module Rails::Generator::Commands
 
   class Create < Base
     def mp_model_cleaning(model)
-      add_to_mundo_pepino_env "MundoPepino::ModelsToClean = [", eval(MODEL_CLEANING)
+      add_to_mundo_pepino_env "config.models_to_clean = [", eval(MODEL_CLEANING)
       logger.model_cleaning "added #{model} (#{model}.destroy_all call before each scenario)"
     end
 
     def mp_model_mapping(model, regexp)
-      add_to_mundo_pepino_env 'String.model_mappings = {', eval(MODEL_MAPPING)
+      add_to_mundo_pepino_env 'config.model_mappings = {', eval(MODEL_MAPPING)
       logger.model_mapping " added /^#{regexp}$/i => #{model}"
     end
 
     def mp_field_mapping(field, regexp)
-      add_to_mundo_pepino_env 'String.field_mappings = {', eval(FIELD_MAPPING)
+      add_to_mundo_pepino_env 'config.field_mappings = {', eval(FIELD_MAPPING)
       logger.field_mapping " added /^#{regexp}$/i => :#{field}"
     end
 
@@ -43,7 +43,7 @@ module Rails::Generator::Commands
   class Destroy < RewindBase
     def mp_model_cleaning(model)
       remove_from_mundo_pepino_env eval(MODEL_CLEANING)
-      logger.model_cleaning "removing Before { #{model}.destroy_all }"
+      logger.model_cleaning "removing #{model} model cleaning"
     end
 
     def mp_model_mapping(model, regexp)

data/rails_generators/mundo_pepino/templates/mundo_pepino_es_ES.rb

@@ -1,36 +1,37 @@
-require 'mundo_pepino_es_ES'
+require 'mundo_pepino/es_ES'
 
 Webrat.configure do |config|
   config.mode = :rails
 end
 
-MundoPepino::ModelsToClean = [
-  # MODELOS PARA LIMPIAR antes de cada escenario,
-  # por ejemplo:
-  # Orchard, Terrace, Crop...
-]
-
-String.model_mappings = {
-  # TRADUCCIÓN DE MODELOS AQUÍ, por ejemplo:
-  # /^huert[oa]s?/i            => Orchard,
-  # /^bancal(es)?$/i           => Terrace,
-  # /^cultivos?$/i             => Crop...
-}
-
-String.field_mappings = {
-  # TRADUCCIÓN DE CAMPOS AQUÍ:
-  # /^[Ááa]reas?$/i    => 'area',
-  # /^color(es)?$/i   => 'color',
-  # /^latitud(es)?$/i => 'latitude',
-  # /^longitud(es)?/i => 'length'
-  #
-  # TRADUCCIÓN ESPECÍFICA PARA UN MODELO
-  # /^Orchard::longitud(es)?$/   => 'longitude'
-}
-
+MundoPepino.configure do |config|
+  config.models_to_clean = [
+    # MODELOS PARA LIMPIAR antes de cada escenario,
+    # por ejemplo:
+    # Orchard, Terrace, Crop...
+  ]
+
+  config.model_mappings = {
+    # TRADUCCIÓN DE MODELOS AQUÍ, por ejemplo:
+    # /^huert[oa]s?/i            => Orchard,
+    # /^bancal(es)?$/i           => Terrace,
+    # /^cultivos?$/i             => Crop...
+  }
+
+  config.field_mappings = {
+    # TRADUCCIÓN DE CAMPOS AQUÍ:
+    # /^[Ááa]reas?$/i    => 'area',
+    # /^color(es)?$/i   => 'color',
+    # /^latitud(es)?$/i => 'latitude',
+    # /^longitud(es)?/i => 'length'
+    #
+    # TRADUCCIÓN ESPECÍFICA PARA UN MODELO
+    # /^Orchard::longitud(es)?$/   => 'longitude'
+  }
+end
 
 Before do
-  MundoPepino::ModelsToClean.each { |model| model.destroy_all }
+  MundoPepino.clean_models
 end
 
 #module MundoPepino

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mundo-pepino
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - "Fernando Garc\xC3\xADa Samblas"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-20 00:00:00 +02:00
+date: 2009-10-27 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,7 +70,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.1.0
+        version: 0.1.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
@@ -100,14 +100,17 @@ files:
 - README_es.markdown
 - init.rb
 - lib/mundo_pepino.rb
+- lib/mundo_pepino/base.rb
+- lib/mundo_pepino/config.rb
 - lib/mundo_pepino/definitions/en_US.rb
 - lib/mundo_pepino/definitions/es_ES.rb
+- lib/mundo_pepino/en_US.rb
+- lib/mundo_pepino/es_ES.rb
 - lib/mundo_pepino/implementations.rb
+- lib/mundo_pepino/implementations_api.rb
 - lib/mundo_pepino/resources_history.rb
 - lib/mundo_pepino/version.rb
 - lib/mundo_pepino/visits_history.rb
-- lib/mundo_pepino_en_US.rb
-- lib/mundo_pepino_es_ES.rb
 - rails_generators/caracteristica/USAGE
 - rails_generators/caracteristica/caracteristica_generator.rb
 - rails_generators/caracteristica/templates/caracteristica.erb