spbtv_pickle 0.5.1

data/features/support/pickle_app.rb

@@ -0,0 +1,4 @@
+Pickle.configure do |c|
+  c.map 'I', :to => 'user: "me"'
+  c.map 'killah fork', :to => 'fancy fork: "of cornwood"'
+end

data/lib/generators/pickle_generator.rb

@@ -0,0 +1,44 @@
+require 'rails/generators'
+
+class PickleGenerator < Rails::Generators::Base
+  desc "Generates Pickle step files."
+
+  # Use the same templates as Rails 2 generator
+  source_root File.expand_path("../../../rails_generators/pickle/templates", __FILE__)
+
+  class_option :paths, :desc => "Generate features/support/paths.rb file.", :type => :boolean
+  class_option :email, :desc => "Generate features/step_definitions/email_steps.rb file", :type => :boolean
+
+  def create_directories
+    empty_directory "features/step_definitions"
+    empty_directory "features/support"
+  end
+
+  def copy_pickle_steps_file
+    template "pickle_steps.rb", "features/step_definitions/pickle_steps.rb"
+    template "pickle.rb", "features/support/pickle.rb"
+  end
+
+  def copy_paths_file
+    return unless options.paths?
+    template "paths.rb", "features/support/paths.rb"
+  end
+
+  def copy_email_steps_file
+    return unless options.email?
+    template "email_steps.rb", "features/step_definitions/email_steps.rb"
+    template "email.rb", "features/support/email.rb"
+  end
+
+
+  private
+
+  # Compatibility methods for Rails 2 templates
+  def pickle_path
+    options.paths?
+  end
+
+  def pickle_email
+    options.email?
+  end
+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/lib/pickle/adapter.rb

@@ -0,0 +1,183 @@
+require 'active_support/core_ext'
+
+module Pickle
+  # Abstract Factory adapter class, if you have a factory type setup, you
+  # can easily create an adaptor to make it work with Pickle.
+  #
+  # The factory adaptor must have a #factories class method that returns
+  # its instances, and each instance must respond to:
+  #
+  #   #name : identifies the factory by name (default is attr_reader)
+  #   #klass : returns the associated model class for this factory (default is attr_reader)
+  #   #create(attrs = {}) : returns a newly created object
+  class Adapter
+    attr_reader :name, :klass
+
+    def create(attrs = {})
+      raise NotImplementedError, "create and return an object with the given attributes"
+    end
+
+    if respond_to?(:class_attribute)
+      class_attribute :model_classes
+    else
+      cattr_writer :model_classes
+    end
+
+    self.model_classes = nil
+
+    # Include this module into your ORM adapter
+    # this will register the adapter with pickle and it will be picked up for you
+    # To create an adapter you should create an inner constant "PickleAdapter"
+    #
+    # e.g. ActiveRecord::Base::PickleAdapter
+    #
+    # @see pickle/adapters/active_record
+    # @see pickle/adapters/datamapper
+    # @see pickle/adapters/mongoid
+    module Base
+      def self.included(base)
+        adapters << base
+      end
+
+      # A collection of registered adapters
+      def self.adapters
+        @@adapters ||= []
+      end
+    end
+
+    class << self
+      def factories
+        raise NotImplementedError, "return an array of factory adapter objects"
+      end
+
+      def model_classes
+        @@model_classes ||= self::Base.adapters.map{ |a| a.model_classes }.flatten
+      end
+
+      # Returns the column names for the given ORM model class.
+      def column_names(klass)
+        klass.const_get(:PickleAdapter).column_names(klass)
+      end
+
+      def get_model(klass, id)
+        klass.const_get(:PickleAdapter).get_model(klass, id)
+      end
+
+      def find_first_model(klass, conditions)
+        klass.const_get(:PickleAdapter).find_first_model(klass, conditions)
+      end
+
+      def find_all_models(klass, conditions)
+        klass.const_get(:PickleAdapter).find_all_models(klass, conditions)
+      end
+
+      def create_model(klass, attributes)
+        klass.const_get(:PickleAdapter).create_model(klass, attributes)
+      end
+    end
+
+    # machinist adapter
+    class Machinist < Adapter
+      def self.factories
+        factories = []
+        model_classes.each do |klass|
+          if blueprints = klass.instance_variable_get('@blueprints')
+            blueprints.keys.each {|blueprint| factories << new(klass, blueprint)}
+          end
+        end
+        factories
+      end
+
+      def initialize(klass, blueprint)
+        @klass, @blueprint = klass, blueprint
+        @name = @klass.name.underscore.gsub('/','_')
+        @name = "#{@blueprint}_#{@name}" unless @blueprint == :master
+      end
+
+      def create(attrs = {})
+        @klass.send(:make!, @blueprint, attrs)
+      end
+    end
+
+    # factory-girl adapter
+    class FactoryGirl < Adapter
+      def self.factories
+        if defined? ::FactoryGirl
+          factories = []
+          ::FactoryGirl.factories.each do |factory|
+            factory.names.each do |name|
+              factories << new(factory, name)
+            end
+          end
+          factories
+        else
+          (::Factory.factories.values rescue []).map {|factory| new(factory)}
+        end
+      end
+
+      def initialize(factory, factory_name)
+        if defined? ::FactoryGirl
+          @klass, @name = factory.build_class, factory_name.to_s
+        else
+          @klass, @name = factory.build_class, factory.factory_name.to_s
+        end
+      end
+
+      def create(attrs = {})
+        if defined? ::FactoryGirl
+          ::FactoryGirl.create(@name, attrs)
+        else
+          Factory(@name, attrs)
+        end
+      end
+
+      def build(attrs = {})
+        if defined? ::FactoryGirl
+          ::FactoryGirl.build(@name, attrs)
+        else
+          Factory.build(@name, attrs)
+        end
+      end
+    end
+
+    # fabrication adapter
+    class Fabrication < Adapter
+      def self.factories
+        if defined? ::Fabrication
+          ::Fabrication.manager.load_definitions if ::Fabrication.manager.schematics.empty?
+          ::Fabrication.manager.schematics.map { |name, klass| new([name, klass]) }
+        else
+          []
+        end
+      end
+
+      def initialize(factory)
+        if defined? ::Fabrication
+          @klass, @name = factory[1].klass, factory[0].to_s
+        end
+      end
+
+      def create(attrs = {})
+        if defined? ::Fabrication
+          Fabricate(@name.to_sym, attrs)
+        end
+      end
+    end
+
+    # ORM adapter.  If you have no factory adapter, you can use this adapter to
+    # use your orm as 'factory' - ie create objects
+    class Orm < Adapter
+      def self.factories
+        model_classes.map{|k| new(k)}
+      end
+
+      def initialize(klass)
+        @klass, @name = klass, klass.name.underscore.gsub('/','_')
+      end
+
+      def create(attrs = {})
+        Pickle::Adapter.create_model(@klass, attrs)
+      end
+    end
+  end
+end

data/lib/pickle/adapters/active_record.rb

@@ -0,0 +1,67 @@
+begin
+  require 'activerecord'
+rescue LoadError
+  require 'active_record'
+end
+
+class ActiveRecord::Base
+  module PickleAdapter
+    include Pickle::Adapter::Base
+
+    # Do not consider these to be part of the class list
+    def self.except_classes
+      @@except_classes ||= [
+        "CGI::Session::ActiveRecordStore::Session",
+        "ActiveRecord::SessionStore::Session"
+      ]
+    end
+
+    # Gets a list of the available models for this adapter
+    def self.model_classes
+      if ::ActiveRecord::Base.respond_to?(:descendants)
+        klasses = ::ActiveRecord::Base.descendants  # Rails 3, 4
+      else
+        klasses = ::ActiveRecord::Base.subclasses   # Rails 2
+      end
+
+      klasses.select do |klass|
+        !klass.abstract_class? && klass.table_exists? && !except_classes.include?(klass.name)
+      end
+    end
+
+    # get a list of column names for a given class
+    def self.column_names(klass)
+      klass.column_names
+    end
+
+    # Get an instance by id of the model
+    def self.get_model(klass, id)
+      klass.find(id)
+    end
+
+    # Find the first instance matching conditions
+    def self.find_first_model(klass, conditions)
+      if defined? ::ActiveRecord::Relation
+        klass.where(conditions).first           # Rails 3, 4
+      else
+        klass.find(:first,
+                   :conditions => conditions)   # Rails 2
+      end
+    end
+
+    # Find all models matching conditions
+    def self.find_all_models(klass, conditions)
+      if defined? ::ActiveRecord::Relation
+        klass.where(conditions)                 # Rails 3, 4
+      else
+        klass.find(:all,
+                   :conditions => conditions)   # Rails 2
+      end
+    end
+
+    # Create a model using attributes
+    def self.create_model(klass, attributes)
+      klass.create!(attributes)
+    end
+  end
+end

data/lib/pickle/adapters/data_mapper.rb

@@ -0,0 +1,42 @@
+require 'dm-core'
+
+module DataMapper::Resource
+  module PickleAdapter
+    include Pickle::Adapter::Base
+
+    # Do not consider these to be part of the class list
+    def self.except_classes
+      @@except_classes ||= []
+    end
+
+    # Gets a list of the available models for this adapter
+    def self.model_classes
+      ::DataMapper::Model.descendants.to_a.select{|k| !except_classes.include?(k.name)}
+    end
+
+    # get a list of column names for a given class
+    def self.column_names(klass)
+      klass.properties.map(&:name)
+    end
+
+    # Get an instance by id of the model
+    def self.get_model(klass, id)
+      klass.get(id)
+    end
+
+    # Find the first instance matching conditions
+    def self.find_first_model(klass, conditions)
+      klass.first(conditions)
+    end
+
+    # Find all models matching conditions
+    def self.find_all_models(klass, conditions)
+      klass.all(conditions)
+    end
+
+    # Create a model using attributes
+    def self.create_model(klass, attributes)
+      klass.create(attributes)
+    end
+  end
+end

data/lib/pickle/adapters/mongoid.rb

@@ -0,0 +1,54 @@
+require 'mongoid'
+
+module Mongoid
+  module Document
+    module PickleAdapter
+      include Pickle::Adapter::Base
+
+      # Do not consider these to be part of the class list
+      def self.except_classes
+        @@except_classes ||= []
+      end
+
+      # Gets a list of the available models for this adapter
+      def self.model_classes
+        ObjectSpace.each_object(Class).to_a.select do |klass|
+          klass.name && klass.ancestors.include?(Mongoid::Document)
+        end
+      end
+
+      # get a list of column names for a given class
+      def self.column_names(klass)
+        klass.try(:fields).try(:keys) || []
+      end
+
+      # Get an instance by id of the model
+      def self.get_model(klass, id)
+        klass.find(id)
+      end
+
+      # Find the first instance matching conditions
+      def self.find_first_model(klass, conditions)
+        if defined? ::Mongoid::Criteria
+          klass.where(conditions).first
+        else
+          klass.first(:conditions => conditions)
+        end
+      end
+
+      # Find all models matching conditions
+      def self.find_all_models(klass, conditions)
+        if defined? ::Mongoid::Criteria
+          klass.where(conditions).to_a
+        else
+          klass.all(:conditions => conditions)
+        end
+      end
+
+      # Create a model with given attributes
+      def self.create_model(klass, attributes)
+        klass.create!(attributes)
+      end
+    end
+  end
+end

data/lib/pickle/config.rb

@@ -0,0 +1,49 @@
+module Pickle
+  class Config
+    attr_writer :adapters, :factories, :mappings, :predicates
+
+    def initialize(&block)
+      configure(&block) if block_given?
+    end
+
+    def configure(&block)
+      yield(self)
+    end
+
+    def adapters
+      @adapters ||= [:machinist, :factory_girl, :fabrication, :orm]
+    end
+
+    def adapter_classes
+      adapters.map {|a| a.is_a?(Class) ? a : "pickle/adapter/#{a}".classify.constantize}
+    end
+
+    def factories
+      @factories ||= adapter_classes.reverse.inject({}) do |factories, adapter|
+        factories.merge(adapter.factories.inject({}){|h, f| h.merge(f.name => f)})
+      end
+    end
+
+    def predicates
+      @predicates ||= Pickle::Adapter.model_classes.map do |k|
+        k.public_instance_methods.select {|m| m =~ /\?$/} + Pickle::Adapter.column_names(k)
+      end.flatten.uniq
+    end
+
+    class Mapping < Struct.new(:search, :replacement)
+    end
+
+    def mappings
+      @mappings ||= []
+    end
+
+    # Usage: map 'me', 'myself', 'I', :to => 'user: "me"'
+    def map(*args)
+      options = args.extract_options!
+      raise ArgumentError, "Usage: map 'search' [, 'search2', ...] :to => 'replace'" unless args.any? && options[:to].is_a?(String)
+      args.each do |search|
+        self.mappings << Mapping.new(search, options[:to])
+      end
+    end
+  end
+end