remarkable 3.0.0

data/lib/remarkable/dsl/optionals.rb

@@ -0,0 +1,142 @@
+module Remarkable
+  module DSL
+    module Optionals
+
+      OPTIONAL_KEYS = [ :positive, :negative, :not_given ]
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        protected
+
+          # Creates optional handlers for matchers dynamically. The following
+          # statement:
+          #
+          #   optional :range, :default => 0..10
+          #
+          # Will generate:
+          #
+          #   def range(value=0..10)
+          #     @options ||= {}
+          #     @options[:range] = value
+          #     self
+          #   end
+          #
+          # Options:
+          #
+          # * <tt>:default</tt> - The default value for this optional
+          # * <tt>:alias</tt>  - An alias for this optional
+          # * <tt>:splat</tt>  - Should be true if you expects multiple arguments
+          #
+          # Examples:
+          #
+          #   optional :name, :title
+          #   optional :range, :default => 0..10, :alias => :within
+          #
+          # Optionals will be included in description messages if you assign them
+          # properly on your locale file. If you have a validate_uniqueness_of
+          # matcher with the following on your locale file:
+          #
+          #   description: validate uniqueness of {{attributes}}
+          #   optionals:
+          #     scope:
+          #       positive: scoped to {{value}}
+          #     case_sensitive:
+          #       positive: case sensitive
+          #       negative: case insensitive
+          #
+          # When invoked like below will generate the following messages:
+          #
+          #   validate_uniqueness_of :project_id, :scope => :company_id
+          #   #=> "validate uniqueness of project_id scoped to company_id"
+          #
+          #   validate_uniqueness_of :project_id, :scope => :company_id, :case_sensitive => true
+          #   #=> "validate uniqueness of project_id scoped to company_id and case sensitive"
+          #
+          #   validate_uniqueness_of :project_id, :scope => :company_id, :case_sensitive => false
+          #   #=> "validate uniqueness of project_id scoped to company_id and case insensitive"
+          #
+          # The interpolation options available are "value" and "inspect". Where
+          # the first is the optional value transformed into a string and the
+          # second is the inspected value.
+          #
+          # Three keys are available to be used in I18n files and control how
+          # optionals are appended to your description:
+          #
+          #   * <tt>positive</tt> - When the optional is given and it evaluates to true (everything but false and nil).
+          #   * <tt>negative</tt> - When the optional is given and it evaluates to false (false or nil).
+          #   * <tt>not_given</tt> - When the optional is not given.
+          #
+          def optionals(*names)
+            options = names.extract_options!
+            @matcher_optionals += names
+
+            splat   = options[:splat]   ? '*' : ''
+            default = options[:default] ? "=#{options[:default].inspect}" : ""
+
+            names.each do |name|
+              class_eval <<-END, __FILE__, __LINE__
+                def #{name}(#{splat}value#{default})
+                  @options ||= {}
+                  @options[:#{name}] = value
+                  self
+                end
+              END
+            end
+            class_eval "alias_method(:#{options[:alias]}, :#{names.last})" if options[:alias]
+
+            # Call unique to avoid duplicate optionals.
+            @matcher_optionals.uniq!
+          end
+          alias :optional :optionals
+
+          # Instead of appending, prepend optionals to the beginning of optionals
+          # array. This is important because this decide how the description
+          # message is generated.
+          #
+          def prepend_optionals(*names)
+            current_optionals  = @matcher_optionals.dup
+            @matcher_optionals = []
+            optional(*names)
+            @matcher_optionals += current_optionals
+            @matcher_optionals.uniq!
+          end
+          alias :prepend_optional :prepend_optionals
+
+      end
+
+      # Overwrites description to support optionals. Check <tt>optional</tt> for
+      # more information.
+      #
+      def description(options={})
+        message = super(options)
+        message.strip!
+
+        optionals = self.class.matcher_optionals.map do |optional|
+          scope = matcher_i18n_scope + ".optionals.#{optional}"
+
+          if @options.key?(optional)
+            value = @options[optional]
+            defaults = [ (value ? :positive : :negative) ]
+
+            # If optional is a symbol and it's not any to any of the reserved symbols, search for it also
+            defaults.unshift(value) if value.is_a?(Symbol) && !OPTIONAL_KEYS.include?(value)
+
+            Remarkable.t defaults.shift, :default => defaults, :raise => true, :scope => scope,
+                                         :inspect => value.inspect, :value => value.to_s
+          else
+            Remarkable.t :not_given, :raise => true, :scope => scope
+          end rescue nil
+        end.compact
+
+        message << ' ' << array_to_sentence(optionals)
+        message.strip!
+        message
+      end
+
+    end
+  end
+end

data/lib/remarkable/dsl.rb

@@ -0,0 +1,39 @@
+dir = File.dirname(__FILE__)
+require File.join(dir, 'dsl', 'assertions')
+require File.join(dir, 'dsl', 'optionals')
+require File.join(dir, 'dsl', 'matches')
+require File.join(dir, 'dsl', 'callbacks')
+
+module Remarkable
+  module DSL
+    ATTR_READERS = [ :matcher_arguments, :matcher_optionals, :matcher_single_assertions,
+      :matcher_collection_assertions, :before_assert_callbacks, :after_initialize_callbacks
+    ] unless self.const_defined?(:ATTR_READERS)
+
+    def self.extended(base)
+      # Load modules
+      base.extend Assertions
+      base.send :include, Callbacks
+      base.send :include, Matches
+      base.send :include, Optionals
+
+      # Set the default value for matcher_arguments
+      base.instance_variable_set('@matcher_arguments', { :names => [] })
+    end
+
+    # Make Remarkable::Base DSL inheritable.
+    #
+    def inherited(base)
+      base.class_eval do
+        class << self
+          attr_reader *ATTR_READERS
+        end
+      end
+
+      ATTR_READERS.each do |attr|
+        current_value = self.instance_variable_get("@#{attr}")
+        base.instance_variable_set("@#{attr}", current_value ? current_value.dup : [])
+      end
+    end
+  end
+end

data/lib/remarkable/i18n.rb

@@ -0,0 +1,54 @@
+# This is a wrapper for I18n default functionality
+module Remarkable
+  module I18n
+
+    # Add locale files to I18n and to load path, if it exists.
+    def add_locale(*locales)
+      ::I18n.backend.load_translations *locales
+      ::I18n.load_path += locales if ::I18n.respond_to?(:load_path)
+    end
+
+    # Set Remarkable locale (which is not necessarily the same as the application)
+    def locale=(locale)
+      @@locale = locale
+    end
+
+    # Get Remarkable locale (which is not necessarily the same as the application)
+    def locale
+      @@locale
+    end
+
+    # Wrapper for translation
+    def translate(string, options = {})
+      ::I18n.translate string, { :locale => @@locale }.merge(options)
+    end
+    alias :t :translate
+
+    # Wrapper for localization
+    def localize(object, options = {})
+      ::I18n.localize object, { :locale => @@locale }.merge(options)
+    end
+    alias :l :localize
+
+  end
+end
+
+# Load I18n
+RAILS_I18N = Object.const_defined?(:I18n) unless Object.const_defined?(:RAILS_I18N) # Rails >= 2.2
+
+unless RAILS_I18N
+  begin
+    require 'i18n'
+  rescue LoadError
+    require 'rubygems'
+    # TODO Move to i18n gem as soon as it gets updated
+    gem 'svenfuchs-i18n'
+    require 'i18n'
+  end
+
+  # Set default locale
+  ::I18n.default_locale = :en
+end
+
+Remarkable.extend Remarkable::I18n
+Remarkable.locale = :en

data/lib/remarkable/macros.rb

@@ -0,0 +1,48 @@
+module Remarkable
+  module Macros
+
+    protected
+
+      def method_missing(method_id, *args, &block)
+        if method_id.to_s =~ /^(should_not|should)_(.+)/
+          should_or_should_not_method_missing($1, $2, caller, *args, &block)
+        elsif method_id.to_s =~ /^x(should_not|should)_(.+)/
+          disabled_method_missing($1, $2, *args, &block)
+        else
+          super(method_id, *args, &block)
+        end
+      end
+
+      def should_or_should_not_method_missing(should_or_should_not, method, calltrace, *args, &block)
+        it {
+          begin
+            send(should_or_should_not, send(method, *args, &block))
+          rescue Exception => e
+            e.set_backtrace(calltrace.to_a)
+            raise e
+          end
+        }
+      end
+
+      def disabled_method_missing(should_or_should_not, method, *args, &block)
+        description = get_description_from_matcher(should_or_should_not, method, *args, &block)
+        xexample(description)
+      end
+
+      # Try to get the description from the matcher. If an error is raised, we
+      # deduct the description from the matcher name, but it will be shown in
+      # english.
+      #
+      def get_description_from_matcher(should_or_should_not, method, *args, &block)
+        verb = should_or_should_not.to_s.gsub('_', ' ')
+
+        desc = Remarkable::Matchers.send(method, *args, &block).spec(self).description
+        verb = Remarkable.t("remarkable.core.#{should_or_should_not}", :default => verb)
+      rescue
+        desc = method.to_s.gsub('_', ' ')
+      ensure
+        verb << ' ' << desc
+      end
+
+  end
+end

data/lib/remarkable/matchers.rb

@@ -0,0 +1,19 @@
+# Remarkable core module
+module Remarkable
+  # A module that keeps all matchers added. This is useful because it allows
+  # to include matchers in Test::Unit as well.
+  module Matchers; end
+
+  # Helper that includes required Remarkable modules into the given klass.
+  def self.include_matchers!(base, klass)
+    # Add Remarkable macros core module
+    klass.send :extend, Remarkable::Macros
+
+    if defined?(base::Matchers)
+      klass.send :include, base::Matchers
+
+      Remarkable::Matchers.send :extend, base::Matchers
+      Remarkable::Matchers.send :include, base::Matchers
+    end
+  end
+end

data/lib/remarkable/messages.rb

@@ -0,0 +1,98 @@
+module Remarkable
+  module Messages
+
+    # Provides a default description message. Overwrite it if needed.
+    # By default it uses default i18n options, but without the subjects, which
+    # usually are not available when description is called.
+    #
+    def description(options={})
+      options = default_i18n_options.merge(options)
+
+      # Remove subject keys
+      options.delete(:subject_name)
+      options.delete(:subject_inspect)
+
+      Remarkable.t 'description', options
+    end
+
+    # Provides a default failure message. Overwrite it if needed.
+    #
+    def failure_message_for_should
+      Remarkable.t 'remarkable.core.failure_message_for_should', :expectation => @expectation
+    end
+    alias :failure_message :failure_message_for_should
+
+    # Provides a default negative failure message. Overwrite it if needed.
+    #
+    def failure_message_for_should_not
+      Remarkable.t 'remarkable.core.failure_message_for_should_not', :expectation => @expectation
+    end
+    alias :negative_failure_message :failure_message_for_should_not
+
+    private
+
+      # Returns the matcher scope in I18n.
+      #
+      # If the matcher is Remarkable::ActiveRecord::Matchers::ValidatePresenceOfMatcher
+      # the default scope will be:
+      #
+      #   'remarkable.active_record.validate_presence_of'
+      #
+      def matcher_i18n_scope
+        @matcher_i18n_scope ||= self.class.name.to_s.
+                                gsub(/::Matchers::/, '::').
+                                gsub(/::/, '.').
+                                gsub(/Matcher$/, '').
+                                gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+                                gsub(/([a-z\d])([A-Z])/,'\1_\2').
+                                tr("-", "_").
+                                downcase
+      end
+
+      # Matcher i18n options used in description, failure_message and
+      # negative_failure_message. It provides by default the subject_name and
+      # the subject_inspect value. But when used with DSL, it provides a whole
+      # bunch of options (check dsl/matches.rb for more information).
+      #
+      def default_i18n_options
+        interpolation_options.update(
+          :scope => matcher_i18n_scope,
+          :subject_name => subject_name,
+          :subject_inspect => @subject.inspect
+        )
+      end
+
+      # Method to be overwritten if user wants to provide more interpolation
+      # options to I18n.
+      #
+      def interpolation_options
+        {}
+      end
+
+      # Returns the not word from I18n API.
+      #
+      def not_word
+        Remarkable.t('remarkable.core.not', :default => 'not') + " "
+      end
+
+      # Converts an array to a sentence
+      #
+      def array_to_sentence(array)
+        words_connector     = Remarkable.t 'remarkable.core.helpers.words_connector'
+        two_words_connector = Remarkable.t 'remarkable.core.helpers.two_words_connector'
+        last_word_connector = Remarkable.t 'remarkable.core.helpers.last_word_connector'
+
+        case array.length
+          when 0
+            ''
+          when 1
+            array[0].to_s
+          when 2
+            "#{array[0]}#{two_words_connector}#{array[1]}"
+          else
+            "#{array[0...-1].join(words_connector)}#{last_word_connector}#{array[-1]}"
+        end
+      end
+
+  end
+end

data/lib/remarkable/pending.rb

@@ -0,0 +1,33 @@
+module Remarkable
+  module Macros
+
+    protected
+
+      def pending(description=nil, &block)
+        PendingSandbox.new(description, self).instance_eval(&block)
+      end
+
+      class PendingSandbox < Struct.new(:description, :spec)
+        include Macros
+
+        def example(mather_description=nil)
+          method_caller = caller.detect{ |c| c !~ /method_missing'/ }
+
+          error = begin
+            ::Spec::Example::ExamplePendingError.new(description || 'TODO', method_caller)
+          rescue # For rspec <= 1.1.12
+            ::Spec::Example::ExamplePendingError.new(description || 'TODO')
+          end
+
+          spec.send(:example, mather_description){ raise error }
+        end
+        alias :it      :example
+        alias :specify :example
+
+        def should_or_should_not_method_missing(should_or_should_not, method, calltrace, *args, &block)
+          example(get_description_from_matcher(should_or_should_not, method, *args, &block))
+        end
+      end
+
+  end
+end

data/lib/remarkable/rspec.rb

@@ -0,0 +1,26 @@
+# Hacks into rspec to provide I18n.
+#
+module Spec #:nodoc:
+  module Matchers #:nodoc:
+    # Provides I18n on should and should_not.
+    #
+    def self.generated_description
+      return nil if last_should.nil?
+      verb = Remarkable.t "remarkable.core.#{last_should}", :default => last_should.to_s.gsub('_',' ')
+      "#{verb} #{last_description}"
+    end
+  end
+
+  module Example #:nodoc:
+    module ExampleGroupMethods #:nodoc:
+      # Provides I18n on example disabled message.
+      #
+      def xexample(description=nil, opts={}, &block)
+        disabled = Remarkable.t 'remarkable.core.example_disabled', :default => 'Example disabled'
+        Kernel.warn("#{disabled}: #{description}")
+      end
+      alias_method :xit, :xexample
+      alias_method :xspecify, :xexample
+    end
+  end
+end