judit-pickle 0.4.2

data/lib/pickle/parser/matchers.rb

@@ -0,0 +1,87 @@
+module Pickle
+  class Parser
+    module Matchers
+      def match_ordinal
+        '(?:\d+(?:st|nd|rd|th))'
+      end
+  
+      def match_index
+        "(?:first|last|#{match_ordinal})"
+      end
+  
+      def match_prefix
+        '(?:(?:a|an|another|the|that) )'
+      end
+  
+      def match_quoted
+        '(?:[^\\"]|\\.)*'
+      end
+  
+      def match_label
+        "(?::? \"#{match_quoted}\")"
+      end
+
+      def match_value
+        "(?:\"#{match_quoted}\"|nil|true|false|[+-]?[0-9_]+(?:\\.\\d+)?)"
+      end
+
+      def match_field
+        "(?:\\w+: #{match_value})"
+      end
+  
+      def match_fields
+        "(?:#{match_field}, )*#{match_field}"
+      end
+  
+      def match_mapping
+        "(?:#{config.mappings.map(&:search).join('|')})"
+      end
+  
+      def match_factory
+        "(?:#{config.factories.keys.map{|n| n.gsub('_','[_ ]')}.join('|')})"
+      end
+      
+      def match_plural_factory
+        "(?:#{config.factories.keys.map{|n| n.pluralize.gsub('_','[_ ]')}.join('|')})"
+      end
+      
+      def match_indexed_model
+        "(?:(?:#{match_index} )?#{match_factory})"
+      end
+  
+      def match_labeled_model
+        "(?:#{match_factory}#{match_label})"
+      end
+  
+      def match_model
+        "(?:#{match_mapping}|#{match_prefix}?(?:#{match_indexed_model}|#{match_labeled_model}))"
+      end
+  
+      def match_predicate
+        "(?:#{config.predicates.map{|m| m.to_s.sub(/^has_/,'').sub(/\?$/,'').gsub('_','[_ ]')}.join('|')})"
+      end
+      
+      # create capture analogues of match methods
+      instance_methods.select{|m| m =~ /^match_/}.each do |method|
+        eval <<-end_eval                   
+          def #{method.to_s.sub('match_', 'capture_')}         # def capture_field
+            "(" + #{method} + ")"                         #   "(" + match_field + ")"
+          end                                             # end
+        end_eval
+      end
+  
+      # special capture methods
+      def capture_number_in_ordinal
+        '(?:(\d+)(?:st|nd|rd|th))'
+      end
+  
+      def capture_name_in_label
+        "(?::? \"(#{match_quoted})\")"
+      end
+  
+      def capture_key_and_value_in_field
+        "(?:(\\w+): #{capture_value})"
+      end
+    end
+  end
+end

data/lib/pickle/parser.rb

@@ -0,0 +1,65 @@
+require 'pickle/parser/matchers'
+
+module Pickle
+  class Parser
+    include Matchers
+    
+    attr_reader :config
+    
+    def initialize(options = {})
+      @config = options[:config] || raise(ArgumentError, "Parser.new requires a :config")
+    end
+    
+    # given a string like 'foo: "bar", bar: "baz"' returns {"foo" => "bar", "bar" => "baz"}
+    def parse_fields(fields)
+      if fields.blank?
+        {}
+      elsif fields =~ /^#{match_fields}$/
+        fields.scan(/(#{match_field})(?:,|$)/).inject({}) do |m, match|
+          m.merge(parse_field(match[0]))
+        end
+      else
+        raise ArgumentError, "The fields string is not in the correct format.\n\n'#{fields}' did not match: #{match_fields}" 
+      end
+    end
+    
+    # given a string like 'foo: expr' returns {key => value}
+    def parse_field(field)
+      if field =~ /^#{capture_key_and_value_in_field}$/
+        { $1 => eval($2) }
+      else
+        raise ArgumentError, "The field argument is not in the correct format.\n\n'#{field}' did not match: #{match_field}"
+      end
+    end
+    
+    # returns really underscored name
+    def canonical(str)
+      str.to_s.underscore.gsub(' ','_').gsub('/','_')
+    end
+    
+    # return [factory_name, name or integer index]
+    def parse_model(model_name)
+      apply_mappings!(model_name)
+      if /#{capture_index} #{capture_factory}$/ =~ model_name
+        [canonical($2), parse_index($1)]
+      elsif /#{capture_factory}#{capture_name_in_label}?$/ =~ model_name
+        [canonical($1), canonical($2)]
+      end
+    end
+  
+    def parse_index(index)
+      case index
+      when nil, '', 'last' then -1
+      when /#{capture_number_in_ordinal}/ then $1.to_i - 1
+      when 'first' then 0
+      end
+    end
+
+  private
+    def apply_mappings!(string)
+      config.mappings.each do |mapping|
+        string.sub! /^#{mapping.search}$/, mapping.replacement
+      end
+    end
+  end
+end

data/lib/pickle/path/world.rb

@@ -0,0 +1,5 @@
+require 'pickle'
+require 'pickle/path'
+
+# make world pickle/path aware
+World(Pickle::Path)

data/lib/pickle/path.rb

@@ -0,0 +1,45 @@
+module Pickle
+  module Path
+    # given args of pickle model name, and an optional extra action, or segment, will attempt to find
+    # a matching named route
+    #
+    #   path_to_pickle 'the user', :action => 'edit'       # => /users/3/edit
+    #   path_to_pickle 'the user', 'the comment'           # => /users/3/comments/1
+    #   path_to_pickle 'the user', :segment => 'comments'  # => /users/3/comments
+    #
+    # If you don;t know if the 'extra' part of the path is an action or a segment, then just
+    # pass it as 'extra' and this method will run through the possibilities
+    #
+    #   path_to_pickle 'the user', :extra => 'new comment' # => /users/3/comments/new
+    def path_to_pickle(*pickle_names)
+      options = pickle_names.extract_options!
+      resources = pickle_names.map{|n| model(n) || n.to_sym}
+      if options[:extra]
+        parts = options[:extra].underscore.gsub(' ','_').split("_")
+        find_pickle_path_using_action_segment_combinations(resources, parts)
+      else
+        pickle_path_for_resources_action_segment(resources, options[:action], options[:segment])
+      end or raise "Could not figure out a path for #{pickle_names.inspect} #{options.inspect}"
+    end
+    
+  protected
+    def find_pickle_path_using_action_segment_combinations(resources, parts)
+      path = nil
+      (0..parts.length).each do |idx|
+        action  = parts.slice(0, idx).join('_')
+        segment = parts.slice(idx, parts.length).join('_')
+        path = pickle_path_for_resources_action_segment(resources, action, segment) and break
+      end
+      path
+    end
+    
+    def pickle_path_for_resources_action_segment(resources, action, segment)
+      action.blank? or action = action.downcase.gsub(' ','_')
+      segment.blank? or segment = segment.downcase.gsub(' ','_')
+      resource_names = resources.map{|s| s.is_a?(Symbol) ? s.to_s : s.class.name.underscore}.join("_")
+      models = resources.reject{|s| s.is_a?(Symbol)}
+      parts = [action, resource_names, segment].reject(&:blank?)
+      send("#{parts.join('_')}_path", *models) rescue nil
+    end
+  end
+end

data/lib/pickle/session/parser.rb

@@ -0,0 +1,34 @@
+module Pickle
+  module Session
+    # add ability to parse model names as fields, using a session
+    module Parser
+      def self.included(parser_class)
+        parser_class.alias_method_chain :parse_field, :model
+      end
+
+      attr_accessor :session
+
+      def match_field
+        "(?:\\w+: (?:#{match_model}|#{match_value}))"
+      end
+
+      def parse_field_with_model(field)
+        if session && field =~ /^(\w+): #{capture_model}$/
+          {$1 => session.model!($2)}
+        else
+          parse_field_without_model(field)
+        end
+      end    
+      
+      def parse_hash(hash)
+        hash.inject({}) do |parsed, (key, val)|
+          if session && val =~ /^#{capture_model}$/
+            parsed.merge(key => session.model($1))
+          else
+            parsed.merge(key => val)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pickle/session.rb

@@ -0,0 +1,205 @@
+module Pickle
+  module Session
+    class ModelNotKnownError < RuntimeError
+      attr_reader :name
+      
+      def initialize(name, message = nil)
+        @name = name
+        @message = message || "The model: '#{name}' is not known in this scenario.  Use #create_model to create, or #find_model to find, and store a reference in this scenario."
+      end
+      
+      def to_s
+        @message
+      end
+    end
+    
+    class << self
+      def included(world_class)
+        proxy_to_pickle_parser(world_class)
+      end
+      
+      def extended(world_object)
+        proxy_to_pickle_parser(class << world_object; self; end) # metaclass is not 2.1 compatible
+      end
+      
+    protected
+      def proxy_to_pickle_parser(world_class)
+        world_class.class_eval do
+          unless methods.include?('method_missing_with_pickle_parser')
+            alias_method_chain :method_missing, :pickle_parser
+            alias_method_chain :respond_to?, :pickle_parser
+          end
+        end
+      end
+    end
+    
+    def create_model(pickle_ref, fields = nil)
+      factory, label = *parse_model(pickle_ref)
+      raise ArgumentError, "Can't create with an ordinal (e.g. 1st user)" if label.is_a?(Integer)
+      fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
+      record = pickle_config.factories[factory].create(fields)
+      store_model(factory, label, record)
+      record
+    end
+    
+    # if a column exists in the table which matches the singular factory name, this is used as the pickle ref
+    def create_models_from_table(plural_factory, table)
+      factory = plural_factory.singularize
+      table.hashes.map do |hash|
+        pickle_ref = factory + (hash[factory] ? " \"#{hash.delete(factory)}\"" : "")
+        create_model(pickle_ref, hash)
+      end
+    end
+
+    def find_model(a_model_name, fields = nil)
+      factory, name = *parse_model(a_model_name)
+
+      raise ArgumentError, "Can't find a model with an ordinal (e.g. 1st user)" if name.is_a?(Integer)
+
+      model_class = pickle_config.factories[factory].klass
+      fields      = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
+      conditions  = convert_models_to_attributes(model_class, fields)
+      record      = Pickle::Adapter.find_first_model(model_class, conditions)
+
+      store_model(factory, name, record) if record
+
+      record
+    end
+    
+    def find_model!(name, fields = nil)
+      find_model(name, fields) or raise ModelNotKnownError, name
+    end
+    
+    def find_models(factory, fields = nil)
+      factory = pickle_parser.canonical(factory)
+      
+      models_by_index(factory).clear
+
+      model_class = pickle_config.factories[factory].klass
+      conditions  = convert_models_to_attributes(model_class, parse_fields(fields))
+      records     = Pickle::Adapter.find_all_models(model_class, conditions)
+
+      records.each {|record| store_model(factory, nil, record)}
+    end
+    
+    # if a column exists in the table which matches the singular factory name, this is used as the pickle ref
+    def find_models_from_table(plural_factory, table)
+      factory = plural_factory.singularize
+      table.hashes.map do |hash|
+        pickle_ref = factory + (hash[factory] ? " \"#{hash.delete(factory)}\"" : "")
+        find_model(pickle_ref, hash)
+      end
+    end
+    
+    # return the original model stored by create_model or find_model
+    def created_model(name)
+      factory, name_or_index = *parse_model(name)
+      
+      if name_or_index.blank?
+        models_by_index(factory).last
+      elsif name_or_index.is_a?(Integer)
+        models_by_index(factory)[name_or_index]
+      else
+        models_by_name(factory)[name_or_index] or raise ModelNotKnownError, name
+      end
+    end
+
+    # predicate version which raises no errors
+    def created_model?(name)
+      (created_model(name) rescue nil) ? true : false
+    end
+    
+    # return a newly selected model
+    def model(name)
+      model = created_model(name)
+      return nil unless model
+      Pickle::Adapter.get_model(model.class, model.id)
+    end
+    
+    # predicate version which raises no errors
+    def model?(name)
+      (model(name) rescue nil) ? true : false
+    end
+    
+    # like model, but raise an error if it can't be found
+    def model!(name)
+      model(name) or raise ModelNotKnownError, name
+    end
+    
+    # like created_model, but raise an error if it can't be found
+    def created_model!(name)
+      created_model(name) or raise ModelNotKnownError, name
+    end
+    
+    # return all original models of specified type
+    def created_models(factory)
+      models_by_index(factory)
+    end
+      
+    # return all models of specified type (freshly selected from the database)
+    def models(factory)
+      created_models(factory).map do |model|
+        Pickle::Adapter.get_model(model.class, model.id)
+      end
+    end
+    
+    def respond_to_with_pickle_parser?(method, include_private = false)
+      respond_to_without_pickle_parser?(method, include_private) || pickle_parser.respond_to?(method, include_private)
+    end
+    
+  protected
+    def method_missing_with_pickle_parser(method, *args, &block)
+      if pickle_parser.respond_to?(method)
+        pickle_parser.send(method, *args, &block)
+      else
+        method_missing_without_pickle_parser(method, *args, &block)
+      end
+    end
+    
+    def pickle_parser=(parser)
+      parser.session = self
+      @pickle_parser = parser
+    end
+    
+    def pickle_parser
+      @pickle_parser or self.pickle_parser = Pickle.parser
+    end
+
+    def pickle_config
+      pickle_parser.config
+    end
+
+    def convert_models_to_attributes(ar_class, attrs)
+      attrs.each do |key, val|
+        if ((defined?(ActiveRecord::Base) && val.is_a?(ActiveRecord::Base)) ||
+          (defined?(DataMapper::Model) && val.is_a?(DataMapper::Model))) &&
+          Pickle::Adapter.column_names(ar_class).include?("#{key}_id")
+          attrs["#{key}_id"] = val.id
+          attrs["#{key}_type"] = val.class.base_class.name if ar_class.column_names.include?("#{key}_type")
+          attrs.delete(key)
+        end
+      end
+    end
+    
+    def models_by_name(factory)
+      @models_by_name ||= {}
+      @models_by_name[pickle_parser.canonical(factory)] ||= {}
+    end
+    
+    def models_by_index(factory)
+      @models_by_index ||= {}
+      @models_by_index[pickle_parser.canonical(factory)] ||= []
+    end
+    
+    # if the factory name != the model name, store under both names
+    def store_model(factory, name, record)
+      store_record(record.class.name, name, record) unless pickle_parser.canonical(factory) == pickle_parser.canonical(record.class.name)
+      store_record(factory, name, record)
+    end
+    
+    def store_record(factory, name, record)
+      models_by_name(factory)[name] = record
+      models_by_index(factory) << record
+    end
+  end
+end

data/lib/pickle/version.rb

@@ -0,0 +1,9 @@
+module Pickle
+  module Version
+    String = File.read(File.dirname(__FILE__) + '/../../VERSION').strip
+    Array = String.split('.').map{|i| i.to_i}
+    Major = Array[0]
+    Minor = Array[1]
+    Patch = Array[2] 
+  end
+end

data/lib/pickle/world.rb

@@ -0,0 +1,14 @@
+require 'pickle'
+
+# auto require for active record, datamapper and mongoid
+require 'pickle/adapters/active_record' if defined?(ActiveRecord::Base)
+require 'pickle/adapters/data_mapper'   if defined?(DataMapper::Resource)
+require 'pickle/adapters/mongoid'       if defined?(Mongoid::Document)
+
+# make cucumber world pickle aware
+World(Pickle::Session)
+
+# shortcuts to regexps for use in step definition regexps
+class << self
+  delegate :capture_model, :capture_fields, :capture_factory, :capture_plural_factory, :capture_predicate, :capture_value, :to => 'Pickle.parser'
+end

data/lib/pickle.rb

@@ -0,0 +1,26 @@
+require 'active_support'
+require 'pickle/version'
+require 'pickle/adapter'
+require 'pickle/config'
+require 'pickle/parser'
+require 'pickle/session'
+require 'pickle/session/parser'
+
+# make the parser aware of models in the session (for fields refering to models)
+Pickle::Parser.send :include, Pickle::Session::Parser
+
+module Pickle
+  class << self
+    def config
+      @config ||= Config.new
+    end
+    
+    def configure(&block)
+      config.configure(&block)
+    end
+  
+    def parser(options = {})
+      @parser ||= Parser.new({:config => config}.merge(options))
+    end
+  end
+end

data/pickle.gemspec

@@ -0,0 +1,134 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{judit-pickle}
+  s.version = "0.4.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ian White"]
+  s.date = %q{2010-08-23}
+  s.description = %q{Easy model creation and reference in your cucumber features}
+  s.email = %q{ian.w.white@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
+     "History.txt",
+     "License.txt",
+     "README.rdoc",
+     "Rakefile",
+     "Rakefile.d/cucumber.rake",
+     "Rakefile.d/jeweler.rake",
+     "Rakefile.d/rcov.rake",
+     "Rakefile.d/rspec.rake",
+     "Rakefile.d/yard.rake",
+     "Todo.txt",
+     "VERSION",
+     "features/app/app.rb",
+     "features/app/blueprints.rb",
+     "features/app/factories.rb",
+     "features/app/views/notifier/email.erb",
+     "features/app/views/notifier/user_email.erb",
+     "features/email/email.feature",
+     "features/generator/generators.feature",
+     "features/path/models_page.feature",
+     "features/path/named_route_page.feature",
+     "features/pickle/create_from_active_record.feature",
+     "features/pickle/create_from_factory_girl.feature",
+     "features/pickle/create_from_machinist.feature",
+     "features/step_definitions/email_steps.rb",
+     "features/step_definitions/extra_email_steps.rb",
+     "features/step_definitions/fork_steps.rb",
+     "features/step_definitions/generator_steps.rb",
+     "features/step_definitions/path_steps.rb",
+     "features/step_definitions/pickle_steps.rb",
+     "features/step_definitions/raise_error_steps.rb",
+     "features/support/email.rb",
+     "features/support/env.rb",
+     "features/support/paths.rb",
+     "features/support/pickle.rb",
+     "features/support/pickle_app.rb",
+     "init.rb",
+     "lib/generators/pickle_generator.rb",
+     "lib/pickle.rb",
+     "lib/pickle/adapter.rb",
+     "lib/pickle/adapters/active_record.rb",
+     "lib/pickle/adapters/data_mapper.rb",
+     "lib/pickle/adapters/mongoid.rb",
+     "lib/pickle/config.rb",
+     "lib/pickle/email.rb",
+     "lib/pickle/email/parser.rb",
+     "lib/pickle/email/world.rb",
+     "lib/pickle/parser.rb",
+     "lib/pickle/parser/matchers.rb",
+     "lib/pickle/path.rb",
+     "lib/pickle/path/world.rb",
+     "lib/pickle/session.rb",
+     "lib/pickle/session/parser.rb",
+     "lib/pickle/version.rb",
+     "lib/pickle/world.rb",
+     "pickle.gemspec",
+     "rails_generators/pickle/pickle_generator.rb",
+     "rails_generators/pickle/templates/email.rb",
+     "rails_generators/pickle/templates/email_steps.rb",
+     "rails_generators/pickle/templates/paths.rb",
+     "rails_generators/pickle/templates/pickle.rb",
+     "rails_generators/pickle/templates/pickle_steps.rb",
+     "spec/pickle/adapter_spec.rb",
+     "spec/pickle/config_spec.rb",
+     "spec/pickle/email/parser_spec.rb",
+     "spec/pickle/email_spec.rb",
+     "spec/pickle/parser/matchers_spec.rb",
+     "spec/pickle/parser_spec.rb",
+     "spec/pickle/path_spec.rb",
+     "spec/pickle/session_spec.rb",
+     "spec/pickle_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ianwhite/pickle/tree}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Easy model creation and reference in your cucumber features}
+  s.test_files = [
+    "spec/pickle/adapter_spec.rb",
+     "spec/pickle/config_spec.rb",
+     "spec/pickle/email/parser_spec.rb",
+     "spec/pickle/email_spec.rb",
+     "spec/pickle/parser/matchers_spec.rb",
+     "spec/pickle/parser_spec.rb",
+     "spec/pickle/path_spec.rb",
+     "spec/pickle/session_spec.rb",
+     "spec/pickle_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rspec>, [">= 1.3"])
+      s.add_runtime_dependency(%q<cucumber>, [">= 0.8"])
+      s.add_runtime_dependency(%q<yard>, [">= 0"])
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.3"])
+      s.add_dependency(%q<cucumber>, [">= 0.8"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.3"])
+    s.add_dependency(%q<cucumber>, [">= 0.8"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+  end
+end
+

data/rails_generators/pickle/pickle_generator.rb

@@ -0,0 +1,33 @@
+class PickleGenerator < Rails::Generator::Base
+  def initialize(args, options)
+    super(args, options)
+    @generate_email_steps = args.include?('email')
+    if @generate_path_steps = args.include?('path') || args.include?('paths')
+      File.exists?('features/support/paths.rb') or raise "features/support/paths.rb not found, is your cucumber up to date?"
+    end
+  end
+  
+  def manifest
+    record do |m|
+      m.directory File.join('features/step_definitions')
+      m.directory File.join('features/support')
+      
+      current_pickle = File.exists?('features/support/pickle.rb') ? File.read('features/support/pickle.rb') : ''
+      pickle_assigns = {:pickle_path => false, :pickle_email => false}
+      
+      if @generate_path_steps
+        pickle_assigns[:pickle_path] = true
+        m.template 'paths.rb', File.join('features/support', 'paths.rb')
+      end
+      
+      if @generate_email_steps
+        pickle_assigns[:pickle_email] = true
+        m.template 'email_steps.rb', File.join('features/step_definitions', 'email_steps.rb')
+        m.template 'email.rb', File.join('features/support', 'email.rb')
+      end
+
+      m.template 'pickle_steps.rb', File.join('features/step_definitions', 'pickle_steps.rb')      
+      m.template 'pickle.rb', File.join('features/support', 'pickle.rb'), :assigns => pickle_assigns
+    end
+  end
+end

data/rails_generators/pickle/templates/email.rb

@@ -0,0 +1,21 @@
+module EmailHelpers
+  # Maps a name to an email address. Used by email_steps
+
+  def email_for(to)
+    case to
+  
+    # add your own name => email address mappings here
+  
+    when /^#{capture_model}$/
+      model($1).email
+  
+    when /^"(.*)"$/
+      $1
+  
+    else
+      to
+    end
+  end
+end
+
+World(EmailHelpers)