card 1.93.3 → 1.93.4

data/spec/support/helper/card_helper.rb

@@ -1,58 +0,0 @@
-class Card
-  module SpecHelper
-    # to be included in Card
-    module CardHelper
-      module ClassMethods
-        def gimme! name, args={}
-          Card::Auth.as_bot do
-            c = Card.fetch(name, new: args)
-            c.putty args
-            Card.fetch name
-          end
-        end
-
-        def gimme name, args={}
-          Card::Auth.as_bot do
-            c = Card.fetch(name, new: args)
-            if args[:content] && c.content != args[:content]
-              c.putty args
-              c = Card.fetch name
-            end
-            c
-          end
-        end
-
-        cattr_accessor :rspec_binding
-      end
-
-      def putty args={}
-        Card::Auth.as_bot do
-          if args.present?
-            update_attributes! args
-          else
-            save!
-          end
-        end
-      end
-
-      # rubocop:disable Lint/Eval
-      def method_missing m, *args, &block
-        return super unless Card.rspec_binding
-        suppress_name_error do
-          method = eval("method(%s)" % m.inspect, Card.rspec_binding)
-          return method.call(*args, &block)
-        end
-        suppress_name_error do
-          return eval(m.to_s, Card.rspec_binding)
-        end
-        super
-      end
-      # rubocop:enable Lint/Eval
-
-      def suppress_name_error
-        yield
-      rescue NameError
-      end
-    end
-  end
-end

data/spec/support/helper/event_helper.rb

@@ -1,94 +0,0 @@
-class Card
-  module SpecHelper
-    module EventHelper
-      # Make expectations in the event phase.
-      # Takes a stage and registers the event_block in this stage as an event.
-      # Unknown methods in the event_block are executed in the rspec context
-      # instead of the card's context.
-      # An additionally :trigger block in opts is expected that is called
-      # to start the event phase.
-      # You can restrict the event to a specific card by passing a name
-      # with :for options.
-      # That's for example necessary if you create a card in a event.
-      # Otherwise you get a loop of card creations.
-      # @example
-      #   in_stage :initialize,
-      #            for: "my test card",
-      #            trigger: -> { test_card.update_attributes! content: '' } do
-      #     expect(item_names).to eq []
-      #   end
-      def in_stage stage, opts={}, &event_block
-        Card.rspec_binding = binding
-        add_test_event stage, :in_stage_test, opts, &event_block
-        trigger =
-          if opts[:trigger].is_a?(Symbol)
-            method(opts[:trigger])
-          else
-            opts[:trigger]
-          end
-        trigger.call
-      ensure
-        remove_test_event stage, :in_stage_test
-      end
-
-      # if you need more then one test event (otherwise use #in_stage)
-      # @example
-      #   with_test_events do
-      #     test_event :store, for: "my card" do
-      #        Card.create name: "other card"
-      #     end
-      #     test_event :finalize, for: "other card" do
-      #        expect(content).to be_empty
-      #     end
-      #   end
-      def with_test_events
-        @events = []
-        Card.rspec_binding = binding
-        yield
-      ensure
-        @events.each do |stage, name|
-          remove_test_event stage, name
-        end
-        Card.rspec_binding = false
-      end
-
-      def test_event stage, opts={}, &block
-        event_name = :"test_event_#{@events.size}"
-        @events << [stage, event_name]
-        add_test_event stage, event_name, opts, &block
-      end
-
-      def add_test_event stage, name, opts={}, &event_block
-        # use random set module that is always included so that the
-        # event applies to all cards
-        opts[:set] ||= Card::Set::All::Fetch
-        if (only_for_card = opts.delete(:for))
-          opts[:when] = proc { |c| c.name == only_for_card }
-        end
-        Card.class_eval do
-          extend Card::Set::Event
-          event name, stage, opts, &event_block
-        end
-      end
-
-      def remove_test_event stage, name
-        stage_sym = :"#{stage}_stage"
-        Card.skip_callback stage_sym, :after, name
-      end
-
-      # Turn delayed jobs on and run jobs after the given block.
-      # If count is given check if it matches the number of created jobs.
-      def with_delayed_jobs count=nil
-        Delayed::Worker.delay_jobs = true
-        expect(Delayed::Job.count).to eq(0), "expected delayed job to start with an empty queue"
-        yield
-        if count
-          expect(Delayed::Job.count).to eq(count)
-        end
-        Delayed::Worker.new.work_off
-        expect(Delayed::Job.count).to eq(0), "not all delayed jobs were executed"
-        Delayed::Worker.delay_jobs = false
-      end
-    end
-  end
-end

data/spec/support/helper/render_helper.rb

@@ -1,44 +0,0 @@
-class Card
-  module SpecHelper
-    module RenderHelper
-      def view view_name, card: { name: "test card", type: :basic }, format: :html
-        render_card_with_args view_name, card, format: format
-      end
-
-      def render_editor type
-        card = Card.create(name: "my favority #{type} + #{rand(4)}", type: type)
-        card.format.render!(:edit)
-      end
-
-      def render_content content, format_args={}
-        render_content_with_args content, format_args
-      end
-
-      def render_content_with_args content, format_args={}, view_args={}
-        @card ||= Card.new name: "Tempo Rary 2"
-        @card.content = content
-        @card.format(format_args)._render :core, view_args
-      end
-
-      def render_card view, card_args={}, format_args={}
-        render_card_with_args view, card_args, format_args
-      end
-
-      alias_method :render_view, :render_card
-
-      def render_card_with_args view, card_args={}, format_args={}, view_args={}
-        card =
-          if card_args.is_a?(Card)
-            card_args
-          elsif card_args.is_a?(Symbol) || card_args.is_a?(String)
-            Card.fetch card_args
-          elsif card_args[:name]
-            Card.fetch card_args[:name], new: card_args
-          else
-            Card.new card_args.merge(name: "Tempo Rary")
-          end
-        card.format(format_args)._render(view, view_args)
-      end
-    end
-  end
-end

data/spec/support/helper/save_helper.rb

@@ -1,30 +0,0 @@
-class Card
-  module SpecHelper
-    module SaveHelper
-      include Card::Model::SaveHelper
-      def create! name, content=""
-        Card.create! name: name, content: content
-      end
-
-      def create name_or_args, content_or_args=nil
-        Card::Auth.as_bot { super }
-      end
-
-      def create_or_update name_or_args, content_or_args=nil
-        Card::Auth.as_bot { super }
-      end
-
-      def update name_or_args, content_or_args={}
-        Card::Auth.as_bot { super }
-      end
-
-      def update! name_or_args, content_or_args={}
-        update_card name_or_args, content_or_args
-      end
-
-      def delete name
-        Card::Auth.as_bot { Card[name].delete! }
-      end
-    end
-  end
-end

data/spec/support/helper/set_helper.rb

@@ -1,80 +0,0 @@
-class Card
-  module SpecHelper
-    # To be included in Card.
-    # Defines helper to change card sets and formats
-    module SetHelper
-      # define dynamically views (or other things) on format objects
-      # @return format object
-      # @example add a view to a card's html format
-      # format =
-      #   Card["A"].format_with(:html) do
-      #     view :my_test_view do
-      #       card.name
-      #     end
-      #   end
-      # format.render :my_test_view  # => "A"
-      def format_with format_type=:html, &block
-        dynamic_set =
-          create_dynamic_set do
-            format(format_type, &block)
-          end
-        format_with_set dynamic_set, format_type
-        #::Card::Set::Self::DynamicSet, :html
-      end
-
-      # define dynamically sets on card objects
-      # @return card object
-      def set_with &block
-        with_set create_dynamic_set(&block)
-      end
-
-      # load set into card object
-      def with_set set
-        set = include_set_in_test_set(set) if set.abstract_set?
-        singleton_class.send :include, set
-        yield set if block_given?
-        self
-      end
-
-      # load set into a card's format object
-      def format_with_set set, format_type=:base
-        format = format format_type
-        with_set set do |extended_set|
-          format_class = set_format_class(extended_set, format_type)
-          format.singleton_class.send :include, format_class
-        end
-        block_given? ? yield(format) : format
-      end
-
-      def set_format_class set, format_type
-        format_class = Card::Format.format_class_name format_type
-        set.const_get format_class
-      end
-
-      def include_set_in_test_set set
-        # rubocop:disable Lint/Eval
-        ::Card::Set::Self.const_remove_if_defined :TestSet
-        eval <<-RUBY
-          class ::Card::Set::Self
-            module TestSet
-              extend Card::Set
-              include_set #{set}
-            end
-          end
-        RUBY
-        ::Card::Set::Self::TestSet
-        # rubocop:enable Lint/Eval
-      end
-
-      private
-
-      def create_dynamic_set &block
-        ::Card::Set::Self.const_remove_if_defined :DynamicSet
-        ::Card::Set::Self.const_set :DynamicSet, Module.new
-        ::Card::Set::Self::DynamicSet.extend Card::Set
-        ::Card::Set::Self::DynamicSet.module_eval &block
-        ::Card::Set::Self::DynamicSet
-      end
-    end
-  end
-end

data/spec/support/matchers/card_matchers.rb

@@ -1,160 +0,0 @@
-#TODO: is this global namespace? module?
-def expect_card *marks
-  expect Card.cardish(marks)
-end
-
-RSpec::Matchers.define :exist do
-  match do |card|
-    should_be_true =
-      case card
-      when String
-        Card.exists? card
-      when Card
-        card.real?
-      else
-        card.present?
-      end
-    values_match? true, should_be_true
-  end
-
-  failure_message do |actual|
-    case actual
-    when String
-      "card '#{actual}' doesn't exist"
-    when Card
-      "#{actual.name} doesn't exist"
-    else
-      "#{actual} doesn't exist"
-    end
-  end
-end
-
-RSpec::Matchers.define :be_valid do
-  match do |card|
-    values_match?(true, card.errors.empty?)
-  end
-end
-
-[:name, :codename, :db_content, :type_id].each do |field|
-  RSpec::Matchers.define "have_#{field}".to_sym do |name|
-    match do |card|
-      values_match?(name, card.send(field))
-    end
-
-    failure_message do |card|
-      super() + ", but was #{card.send(field)}"
-    end
-  end
-end
-
-RSpec::Matchers.define :have_a_field do |field_key|
-  chain(:with_content) do |content|
-    @content = content
-  end
-
-  chain(:pointing_to) do |pointing_to|
-    @pointing_to = pointing_to
-  end
-
-  match do |card|
-    return unless card.is_a?(Card)
-    return unless (@field = card.fetch(trait: field_key))
-    if @content
-      values_match?(@content, @field.content)
-    elsif @pointing_to
-      values_match?(:pointer, @field.type_code) &&
-        @field.content.include?("[[#{@pointing_to}]]")
-    else
-      values_match(Card, @field.class)
-    end
-  end
-
-  failure_message do |card|
-    return super() unless @field
-    if @content
-      "expected #{card} to have a field '#{field_key}' with content '#{@content}',
-but content is #{@field.content.present? ? @field.content : "empty" }"
-    elsif @pointing_to
-      "expected #{card} to have a field #{field_key} pointing to #{@pointing_to} but
-content is #{@field.content}"
-    end
-  end
-end
-
-RSpec::Matchers.define :have_type do |type|
-  match do |card|
-    case type
-    when Symbol
-      values_match?(type, card.type_code)
-    when Integer
-      values_match?(type, card.type_id)
-    when String
-      values_match?(type, card.type_name)
-    end
-  end
-end
-
-RSpec::Matchers.define :have_content do |content|
-  match do |card|
-    values_match?(content, card.content)
-  end
-end
-
-RSpec::Matchers.define :increase_card_count do
-  chain(:by) do |diff|
-    @diff = diff
-  end
-
-  match do |card_creation|
-    count = Card.count
-    card_creation.call
-    if @diff
-      values_match?(count + @diff, Card.count)
-    else
-      Card.count > count
-    end
-  end
-
-  supports_block_expectations
-end
-
-RSpec::Matchers.define :be_a_new_card do
-  match do |card|
-    card.is_a?(Card) && card.new_record?
-  end
-end
-
-RSpec::Matchers.define :be_invalid do
-  match do |card|
-    # valid? clears errors
-    # For a new card we have to call valid? to create the errors.
-    # For a updated card we have to check errors because with valid? we would
-    # loose the errors.
-    @valid = card.errors.empty? && card.valid?
-    # card.errors returns an array, hence we need an extra include matcher
-    values_match?(false, @valid) &&
-      values_match?(include(@error_msg), card.errors[@error_key])
-  end
-
-  description do
-    "be invalid #{"because of #{@error_key} #{@error_msg}" if @error_key}"
-  end
-
-  chain(:because_of) do |reason|
-    @error_key, @error_msg = reason.to_a.first
-  end
-
-  failure_message do |actual|
-    super() + fail_reason(actual)
-  end
-
-  def fail_reason actual
-    if @valid
-      "but file is valid"
-    else
-      "but it is invalid because of #{actual.errors.messages}"
-    end
-  end
-end
-
-