mundo-pepino 0.1.0

data/lib/mundo_pepino/resources_history.rb

@@ -0,0 +1,214 @@
+module MundoPepino
+  module ResourcesHistory
+    module MentionedResource
+      def mr_instance
+        self.is_a?(Array) ? self.first : self
+      end
+      
+      def mr_new_record?
+        self.mr_instance.new_record?
+      end
+      
+      def mr_model
+        self.mr_instance.class
+      end
+      
+      def mr_singular
+        self.mr_model.name.underscore
+      end
+      
+      def mr_plural
+        self.mr_model.table_name
+      end
+    end
+
+    class ResourceNotFound < RuntimeError
+      def initialize(resource_info=nil)
+        @resource_info = resource_info && " (#{resource_info})"
+      end
+      def message
+        "Resource not found#{@resource_info}"
+      end
+    end
+  
+    class WithoutResources < ResourceNotFound
+      def initialize
+        super 'there is no resources'
+      end
+    end
+
+    class NotFoundInDatabase
+      def initialize(model, value='')
+        super "#{model} #{value} not found in database"
+      end
+    end
+
+    class NotMapped < RuntimeError
+      def initialize(type, string)
+        @type = type
+        @string = string
+      end
+      def message
+        "#{@type} not mapped '#{@string}'"
+      end
+    end
+
+    class ModelNotMapped < NotMapped
+      def initialize(string)
+        super('Model', string)
+      end
+    end
+
+    class FieldNotMapped < NotMapped
+      def initialize(string)
+        super('Field', string)
+      end
+    end
+
+    class CrudActionNotMapped < NotMapped
+      def initialize(string)
+        super('CRUD Action', string)
+      end
+    end
+
+    # options: :force_creation 
+    def add_resource(model, attribs=[], options = {})
+      attributes = if attribs.is_a?(Hash)
+        [ attribs ] 
+      else
+        attribs
+      end
+      res = if attributes.size == 1
+        find_or_create(model, attributes.first, options)
+      else
+        attributes.map do |hash| 
+          find_or_create(model, hash, options) 
+        end
+      end
+      pile_up res
+    end
+  
+    def add_resource_from_database(modelo, nombre)
+      model = modelo.to_unquoted.to_model
+      field = field_for(model, 'nombre')
+      if resource = model.send("find_by_#{field}", nombre)
+        pile_up resource
+      else
+        NotFoundInDatabase.new(model, name)
+      end
+    end
+
+    def pile_up(mentioned)
+      @resources ||= []
+      if mentioned != last_mentioned
+        mentioned.class.send :include, MentionedResource
+        @resources.unshift mentioned
+      end
+      mentioned
+    end
+  
+    def last_mentioned
+      @resources && @resources.first
+    end
+  
+    def last_mentioned_url 
+      if mentioned = last_mentioned
+        if mentioned.mr_new_record?
+          eval("#{mentioned.mr_plural}_path")
+        else
+          eval("#{mentioned.mr_singular}_path(mentioned.mr_instance)")
+        end
+      else
+        raise WithoutResources
+      end
+    end
+  
+    def last_mentioned_of(modelo, with_name = nil)
+      if model = modelo.to_model
+        resource = if with_name
+          detect_first @resources.flatten, [model, with_name]
+        elsif(last_mentioned.mr_model == model)
+          last_mentioned
+        else
+          if group = recursive_group_search(model, @resources[1..-1])
+            group
+          else
+            detect_first @resources.flatten, model
+          end
+        end
+        resource || raise(ResourceNotFound.new("model:#{model.name}, name:#{with_name||'nil'}"))
+      else
+        raise ModelNotMapped.new(modelo)
+      end
+    end
+  
+    def last_mentioned_called(name)
+      detect_first @resources.flatten, name
+    end
+  
+    def recursive_group_search(model, resources)
+      if lm = resources.shift
+        if(lm.is_a?(Array) and (lm.mr_model == model))
+          lm
+        else
+          recursive_group_search(model, resources)
+        end
+      end
+    end
+  
+    def detect_first(arr, value, method = nil)
+      if value.is_a? String
+        method ||= :name
+        arr.detect { |r| r.respond_to?(method) && (r.send(method) =~ /#{value}/i) }
+      elsif value.is_a? Class
+        method ||= :is_a?
+        arr.detect { |r| r.respond_to?(method) && r.send(method, value) }
+      elsif value.is_a? Array
+        model, val = value # [ class, value ]
+        name_field = field_for(model, 'nombre')
+        arr.detect do |r| 
+          r.respond_to?(:is_a?) && r.is_a?(model) && r.send(name_field) =~ /#{val}/i
+        end
+      else
+        method ||= :id
+        arr.detect { |r| r.respond_to?(method) && r.send(method) == value }
+      end
+    end
+  
+    def resources_array_field_and_values(mentioned, campo, valor)
+      resources, valores = if mentioned.is_a?(Array)
+        valores = valor.split(/ ?, | y /)
+        if valores.size == mentioned.size
+          [mentioned, valores]
+        else
+          [mentioned, [ valor ] * mentioned.size]
+        end
+      else
+        [[ mentioned ], [ valor ]]
+      end
+      field, values = if (child_model = campo.to_model)
+        child_name_field = field_for(mentioned.mr_model, 'nombre')
+        values = add_resource(child_model,
+          valores.map { |val| { child_name_field => val } })
+        values = [ values ] unless values.is_a?(Array)
+        [ campo.to_field || child_model.name.underscore, values ]
+      else
+        [ field_for(mentioned.mr_model, campo), valores ]
+      end 
+      [resources, field, values]
+    end
+  
+    def method_missing(method, *args, &block)
+      if (method.to_s =~ /^last_mentioned_(.+)$/)
+        if mentioned = last_mentioned
+          last_mentioned.send("mr_#{$1}") 
+        else
+          nil
+        end
+      else
+        super
+      end
+    end
+  
+  end
+end

data/lib/mundo_pepino/version.rb

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

data/lib/mundo_pepino/visits_history.rb

@@ -0,0 +1,13 @@
+module MundoPepino
+  module VisitsHistory
+    def do_visit(url)
+      @visits ||= []
+      @visits << url
+      visit url
+    end
+    
+    def last_visited
+      @visits.last
+    end
+  end
+end

data/lib/mundo_pepino_es_ES.rb

@@ -0,0 +1,2 @@
+require 'mundo_pepino'
+require 'mundo_pepino/definitions/es_ES'

data/mundo-pepino.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+require 'rake'
+
+Gem::Specification.new do |s|
+  s.name = %q{mundo-pepino}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Fernando García Samblas"]
+  s.autorequire = %q{mundo-pepino}
+  s.date = %q{2009-09-30}
+  s.email = %q{fernando.garcia@the-cocktail.com}
+  s.files = ["History.txt", "COPYING", "README.markdown"] + FileList['lib/**/*.rb', 'rails_generators/**/*'].to_a
+  s.homepage = %q{http://github.com/nando/mundo-pepino}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{Convention over self-implementation for 'cucumber --language=es features' writers}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+      s.add_runtime_dependency(%q<cucumber>, ["<= 0.3.101"])
+      s.add_runtime_dependency(%q<nando-string-mapper>, [">= 0.0.1"])
+    else
+      s.add_dependency(%q<cucumber>, ["<= 0.3.101"])
+      s.add_dependency(%q<nando-string-mapper>, [">= 0.0.1"])
+    end
+  else
+    s.add_dependency(%q<cucumber>, ["<= 0.3.101"])
+    s.add_dependency(%q<nando-string-mapper>, [">= 0.0.1"])
+  end
+end

data/rails_generators/caracteristica/USAGE

@@ -0,0 +1,16 @@
+Description:
+    Generates a skeleton for a new feature file written in Spanish (característica) that
+    describes an standard resource management (currently only C and D of the CRUD).
+    This generator should be used with moderation.
+    See http://github.com/aslakhellesoy/cucumber/wikis/feature-coupled-steps-antipattern
+    for details about the dangers involved.
+
+    It takes at least two arguments: the name of a model and its translation to Spanish.
+    
+    This generator can take an optional list of attribute pairs similar to Rails'
+    built-in resource generator but adding also the field Spanish translation after the
+    field type (see an example below). 
+
+Examples:
+    `./script/generate caracteristica Post Artículo` # no attributes
+    `./script/generate caracteristica Post Artículo title:string:título body:string:cuerpo published:boolean:publicado`

data/rails_generators/caracteristica/caracteristica_generator.rb

@@ -0,0 +1,126 @@
+# Este generador crea una plantilla de caracteristica (feature) ligada a un modelo
+module Rails::Generator::Commands
+  MUNDO_PEPINO_ENV = 'features/step_definitions/mundo_pepino_es_ES.rb'
+
+  MODEL_CLEANING = '"\n    # ENTRADA AUTO-GENERADA PARA #{model}\n' +
+                   '    #{model}, # ' +
+                   '(TODO: quitar la coma final si es el primer modelo)\n"'
+
+  MODEL_MAPPING = '"\n  # MAPEO DE MODELO AUTO-GENERADO (#{model})\n' +
+                  '  /^#{regexp}$/i => #{model},' + 
+                  ' # (TODO: validar RegExp para forma plural y coma final)\n"'
+
+  FIELD_MAPPING = '"\n  # MAPEO DE CAMPO AUTO-GENERADO (#{field})\n' +
+                  '  /^#{regexp}$/i => :#{field},' + 
+                  ' # (TODO: validar RegExp para forma plural y coma final)\n"'
+
+  class Create < Base
+    def mp_model_cleaning(model)
+      add_to_mundo_pepino_env "MundoPepino::ModelsToClean = [", 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)
+      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)
+      logger.field_mapping " added /^#{regexp}$/i => :#{field}"
+    end
+
+    private
+    def add_to_mundo_pepino_env(sentinel, content)
+      unless options[:pretend]
+        gsub_file MUNDO_PEPINO_ENV, /(#{Regexp.escape(sentinel)})/mi do |match|
+          "#{match}#{content}"
+        end
+      end
+    end
+  end
+
+  class Destroy < RewindBase
+    def mp_model_cleaning(model)
+      remove_from_mundo_pepino_env eval(MODEL_CLEANING)
+      logger.model_cleaning "removing Before { #{model}.destroy_all }"
+    end
+
+    def mp_model_mapping(model, regexp)
+      remove_from_mundo_pepino_env eval(MODEL_MAPPING)
+      logger.model_mapping " removing /^#{regexp}$/i => #{model}"
+    end
+
+    def mp_field_mapping(field, regexp)
+      remove_from_mundo_pepino_env eval(FIELD_MAPPING)
+      logger.model_mapping " removing /^#{regexp}$/i => #{field}"
+    end
+
+    private
+    def remove_from_mundo_pepino_env(content)
+      unless options[:pretend]
+        gsub_file MUNDO_PEPINO_ENV, /(#{Regexp.escape(content)})/mi, ''
+      end
+    end
+  end
+end
+
+class CaracteristicaGenerator < Rails::Generator::NamedBase
+  attr_reader :modelo_en_singular, :campos
+
+  def manifest
+    record do |m|
+      if args.any?
+        @modelo_en_singular = args.shift
+        m.mp_model_cleaning class_name
+        m.mp_model_mapping class_name, plural_regexp(modelo_en_singular)
+        named_args.each do |arg|
+          m.mp_field_mapping arg.name, plural_regexp(arg.nombre)
+        end
+      end
+      m.template  'caracteristica.erb',
+        "features/gestion_de_#{modelo_en_plural.downcase}.feature"
+    end
+  end
+
+  def named_args
+    @named_args ||= args.map{|arg| NamedArg.new(arg)}
+  end
+
+  def modelo_en_plural
+    modelo_en_singular + (modelo_en_singular =~ /[aeiou]$/i ? 's' : 'es')
+  end
+
+  def plural_regexp(nombre)
+    suffix = if nombre =~ /[aeiou]$/i
+      's?'
+    else
+      '(es)?'
+    end
+    nombre.downcase + suffix
+  end
+
+  class NamedArg
+    attr_reader :name, :nombre
+
+    def initialize(s)
+      @name, @type, @nombre = *s.split(':')
+    end
+
+    def value(n=0)
+      if @type == 'boolean'
+        (n % 2) == 0
+      elsif @type == 'integer'
+        n
+      else
+        "#{@nombre} #{n}"
+      end
+    end
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} caracteristica ModelName NombreDelModelo [field:type:campo, field:type:campo]"
+  end
+end

data/rails_generators/caracteristica/templates/caracteristica.erb

@@ -0,0 +1,31 @@
+Característica: Gestión de <%= modelo_en_plural %>
+  Para [beneficio]
+  Como [sujeto]
+  Quiero [característica/comportamiento]
+  
+  Escenario: Añadir un/a nuevo/a <%= modelo_en_singular %>
+    Dado que visito la página de nuevo/a <%= modelo_en_singular %>
+<% keyword = 'Cuando' -%>
+<% named_args.each do |arg| -%>
+    <%= keyword %> relleno <%= arg.nombre %> con "<%= arg.value %>"
+<% keyword = '     Y' -%>
+<% end -%>
+         Y pulso el botón "Crear"
+<% keyword = 'Entonces' -%>
+<% named_args.each do |arg| -%>
+    <%= keyword %> debería ver el texto "<%= arg.value %>"
+<% keyword = '       Y' -%>
+<% end -%>
+
+  Escenario: Borrar <%= modelo_en_singular %>
+    Dado que tenemos los/las siguientes <%= modelo_en_plural %>:
+      |<%= named_args.map(&:nombre).join('|') %>|
+<% (1..4).each do |n| -%>
+      |<%= named_args.map{ |arg| arg.value(n) }.join('|') %>|
+<% end -%>
+    Cuando borro el/la <%= modelo_en_singular %> en la tercera posición
+    Entonces debería ver una tabla con los siguientes contenidos:
+      |<%= named_args.map(&:nombre).join('|') %>|
+<% [1,2,4].each do |n| -%>
+      |<%= named_args.map{ |arg| arg.value(n) }.join('|') %>|
+<% end -%>