card 1.17.4 → 1.18.0

data/lib/card/set/event.rb

@@ -0,0 +1,126 @@
+class Card
+  module Set
+    module Event
+      def event event, stage_or_opts={}, opts={}, &final
+        if stage_or_opts.is_a? Symbol
+          opts[:in] = stage_or_opts
+        else
+          opts = stage_or_opts
+        end
+        process_stage_opts opts
+
+        Card.define_callbacks event
+        define_event event, opts, &final
+        set_event_callbacks event, opts
+      end
+
+      def define_event event, opts, &final
+        final_method_name = "#{event}_without_callbacks" # should be private?
+        class_eval do
+          define_method final_method_name, &final
+        end
+
+        if with_delay? opts
+          delaying_method = "#{event}_with_delay"
+          define_event_delaying_method event, delaying_method
+          define_event_method event, delaying_method, opts
+          define_active_job event, final_method_name, opts[:queue_as]
+        else
+          define_event_method event, final_method_name, opts
+        end
+      end
+
+      private
+
+      def with_delay? opts
+        opts[:after] == :integrate_with_delay_stage
+      end
+
+      def process_stage_opts opts
+        case
+        when opts[:after] || opts[:before]
+          # ignore :in options
+        when opts[:in]
+          opts[:after] = :"#{opts.delete(:in)}_stage" if opts[:in]
+        end
+        opts[:on] = [:create, :update] if opts[:on] == :save
+      end
+
+      def define_event_delaying_method event, method_name
+        class_eval do
+          define_method method_name, proc {
+            s_attr =
+              serializable_attributes.each_with_object({}) do |name, hash|
+                value = instance_variable_get("@#{name}")
+                hash[name] =
+                  # ActiveJob doesn't accept symbols as arguments
+                  if value.is_a? Symbol
+                    { value: value.to_s, symbol: true }
+                  else
+                    { value: value }
+                  end
+              end
+            Object.const_get(event.to_s.camelize).perform_later(self, s_attr)
+          }
+        end
+      end
+
+      def define_event_method event, call_method, _opts
+        class_eval do
+          define_method event do
+            # puts "#{name}:#{event}".green
+            run_callbacks event do
+              send call_method
+            end
+          end
+        end
+      end
+
+      # creates an Active Job.
+      # The scheduled job gets the card object as argument and all serializable
+      # attributes of the card.
+      # (when the job is executed ActiveJob fetches the card from the database
+      # so all attributes get lost)
+      # @param name [String] the name for the ActiveJob child class
+      # @param final_method [String] the name of the card instance method to be
+      # queued
+      # @option queue [Symbol] (:default) the name of the queue8
+      def define_active_job name, final_method, queue=:default
+        class_name = name.to_s.camelize
+        eval %(
+          class ::#{class_name} < ActiveJob::Base
+            queue_as #{queue}
+          end
+        )
+        Object.const_get(class_name).class_eval do
+          define_method :perform, proc { |card, attributes|
+            attributes.each do |attname, args|
+              # symbols are not allowed so all symbols arrive here as strings
+              # convert strings that were symbols before back to symbols
+              value = args[:symbol] ? args[:value].to_sym : args[:value]
+              card.instance_variable_set("@#{attname}", value)
+            end
+            card.include_set_modules
+            card.send final_method
+          }
+        end
+      end
+
+      def set_event_callbacks event, opts
+        [:before, :after, :around].each do |kind|
+          next unless (object_method = opts.delete(kind))
+          this_set_module = self
+          Card.class_eval do
+            set_callback(
+              object_method, kind, event,
+              prepend: true, if: proc do |c|
+                c.singleton_class.include?(this_set_module) &&
+                  c.event_applies?(opts)
+              end
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/set_pattern.rb

@@ -29,14 +29,14 @@ class Card
       end
 
       def pattern
-        Card.fetch(self.pattern_id, skip_modules: true).cardname
+        Card.fetch(pattern_id, skip_modules: true).cardname
       end
 
       def register pattern_code, opts={}
-        if self.pattern_id = Card::Codename[pattern_code]
+        if (self.pattern_id = Card::Codename[pattern_code])
           self.pattern_code = pattern_code
           Card.set_patterns.insert opts.delete(:index).to_i, self
-          self.anchorless = !respond_to?( :anchor_name )
+          self.anchorless = !respond_to?(:anchor_name)
           opts.each { |key, val| send "#{key}=", val }
         else
           warn "no codename for pattern_code #{pattern_code}"
@@ -48,11 +48,12 @@ class Card
       end
 
       def anchor_parts_count
-        @anchor_parts_count ||= ( anchorless? ? 0 : 1 )
+        @anchor_parts_count ||= (anchorless? ? 0 : 1)
       end
 
       def write_tmp_file pattern_code, from_file, seq
-        to_file = "#{Card.paths['tmp/set_pattern'].first}/#{seq}-#{pattern_code}.rb"
+        to_file = "#{Card.paths['tmp/set_pattern'].first}/" \
+                  "#{seq}-#{pattern_code}.rb"
         klass = "Card::#{pattern_code.camelize}Set"
         file_content = <<EOF
 # -*- encoding : utf-8 -*-
@@ -61,7 +62,7 @@ class #{klass} < Card::SetPattern
   class << self
 # ~~~~~~~~~~~ above autogenerated; below pulled from #{from_file} ~~~~~~~~~~~
 
-#{ File.read from_file }
+#{File.read from_file}
 
 # ~~~~~~~~~~~ below autogenerated; above pulled from #{from_file} ~~~~~~~~~~~
   end
@@ -74,17 +75,16 @@ EOF
       end
     end
 
-
     # Instance methods
 
     def initialize card
       unless self.class.anchorless?
         @anchor_name = self.class.anchor_name(card).to_name
         @anchor_id = if self.class.respond_to? :anchor_id
-          self.class.anchor_id card
-        else
-          Card.fetch_id @anchor_name
-        end
+                       self.class.anchor_id card
+                     else
+                       Card.fetch_id @anchor_name
+                     end
       end
       self
     end
@@ -100,21 +100,21 @@ EOF
     end
 
     def lookup_module_list modules_hash
-      module_key && modules_hash[ module_key ]
+      module_key && modules_hash[module_key]
     end
 
     def module_list
-      lookup_module_list Card::Set.modules[ :nonbase ]
+      lookup_module_list Card::Set.modules[:nonbase]
     end
 
     def format_module_list klass
-      hash = Card::Set.modules[ :nonbase_format ][ klass ] and lookup_module_list hash
+      (hash = Card::Set.modules[:nonbase_format][klass]) && lookup_module_list(hash)
     end
 
     def anchor_codenames
       @anchor_name.parts.map do |part|
         part_id = Card.fetch_id part
-        part_id && Card::Codename[ part_id.to_i ] or return nil
+        part_id && Card::Codename[part_id.to_i] || (return nil)
       end
     end
 
@@ -131,15 +131,19 @@ EOF
     end
 
     def safe_key
-      caps_part = self.class.pattern_code.gsub(' ','_').upcase
-      self.class.anchorless? ? caps_part : "#{caps_part}-#{@anchor_name.safe_key}"
+      caps_part = self.class.pattern_code.tr(' ', '_').upcase
+      if self.class.anchorless?
+        caps_part
+      else
+        "#{caps_part}-#{@anchor_name.safe_key}"
+      end
     end
 
     def rule_set_key
       if self.class.anchorless?
         self.class.pattern_code
       elsif @anchor_id
-        [ @anchor_id, self.class.pattern_code ].map( &:to_s ) * '+'
+        "#{@anchor_id}+#{self.class.pattern_code}"
       end
     end
   end
@@ -152,24 +156,33 @@ EOF
 
     def lookup_inherited_key
       return unless @inherit_card
-      card, @inherit_card = @inherit_card, nil
-
-      default_rule = card.rule_card(:default) and
-        type_code = default_rule.type_code and
-        #default_rule.cardname.size > 2 and
-        #default_rule.left.right.codename == self.class.pattern_code
-        mod_key = "Type::#{type_code.to_s.camelize}" and
-        ( Card::Set.modules[:nonbase_format].values +
-          [Card::Set.modules[:nonbase]] ).any?{|hash| hash[mod_key]} and
+      card = @inherit_card
+      @inherit_card = nil
+
+      (default_rule = card.rule_card(:default)) &&
+        (type_code = default_rule.type_code) &&
+        # default_rule.cardname.size > 2 and
+        # default_rule.left.right.codename == self.class.pattern_code
+        (mod_key = "Type::#{type_code.to_s.camelize}") &&
+        (Card::Set.modules[:nonbase_format].values +
+          [Card::Set.modules[:nonbase]]).any? { |hash| hash[mod_key] } &&
         mod_key
     end
 
     def inherited_key
-      (defined? @inherited_key) ? @inherited_key : @inherited_key = lookup_inherited_key
+      if defined?(@inherited_key)
+        @inherited_key
+      else
+        @inherited_key = lookup_inherited_key
+      end
     end
 
     def lookup_module_list modules_hash
-      module_key ? modules_hash[ module_key ] : inherited_key && modules_hash[ inherited_key ]
+      if module_key
+        modules_hash[module_key]
+      else
+        inherited_key && modules_hash[inherited_key]
+      end
     end
   end
 end

data/lib/card/simplecov_helper.rb

@@ -1,41 +1,41 @@
-def is_in_mod? file,mod_path
+def is_in_mod? file, mod_path
   mod_msg = "below pulled from #{Rails.root}/mod/#{mod_path}/"
-  file.src.join("") =~ /#{mod_msg}/
+  file.src.join('') =~ /#{mod_msg}/
 end
+
 def card_simplecov_filters
   add_filter 'spec/'
   add_filter '/config/'
   add_filter '/tasks/'
   # filter all card mods
   add_filter do |src_file|
-    src_file.filename =~ /tmp\// and not
-    /\d+-(.+\.rb)/.match(src_file.filename) do |m|
-      Dir["mod/**/#{m[1].gsub("-","/").sub("/","/set/")}"].present?
+    src_file.filename =~ /tmp\// && !/\d+-(.+\.rb)/.match(src_file.filename) do |m|
+      Dir["mod/**/#{m[1].tr('-', '/').sub('/', '/set/')}"].present?
     end
   end
   # add group for each deck mod
-  Dir['mod/*'].map{ |path| path.sub('mod/','') }.each do |mod|
+  Dir['mod/*'].map { |path| path.sub('mod/', '') }.each do |mod|
     add_group mod.capitalize do |src_file|
-      src_file.filename =~ /mod\/#{mod}\// or
+      src_file.filename =~ /mod\/#{mod}\// ||
         (
-          src_file.filename =~ /tmp\// and
-          match = /\d+-(.+\.rb)/.match(src_file.filename) do |m|
+          src_file.filename =~ /tmp\// &&
+          (match = /\d+-(.+\.rb)/.match(src_file.filename) do |m|
             # '/set' is not in the path anymore after some updates
             # but `set` exists in the path of the source files
-            Dir["mod/**/#{m[1].gsub("-","/").sub("/","/set/")}"].present?
-          end and
-          is_in_mod? src_file,mod
+            Dir["mod/**/#{m[1].tr('-', '/').sub('/', '/set/')}"].present?
+          end) &&
+          is_in_mod?(src_file, mod)
         )
     end
   end
 
   add_group 'Sets' do |src_file|
-    src_file.filename =~ /tmp\/set\// and
-    /\d+-(.+\.rb)/.match(src_file.filename) { |m| Dir["mod/**/#{m[1]}"].present? }
+    src_file.filename =~ /tmp\/set\// &&
+      /\d+-(.+\.rb)/.match(src_file.filename) { |m| Dir["mod/**/#{m[1]}"].present? }
   end
   add_group 'Set patterns' do |src_file|
-    src_file.filename =~ /tmp\/set_pattern\// and
-    /\d+-(.+\.rb)/.match(src_file.filename) { |m| Dir["mod/**/#{m[1]}"].present? }
+    src_file.filename =~ /tmp\/set_pattern\// &&
+      /\d+-(.+\.rb)/.match(src_file.filename) { |m| Dir["mod/**/#{m[1]}"].present? }
   end
   add_group 'Formats' do |src_file|
     src_file.filename =~ /mod\/[^\/]+\/formats/
@@ -49,8 +49,8 @@ def card_core_dev_simplecov_filters
   filters.clear # This will remove the :root_filter that comes via simplecov's defaults
   add_filter do |src|
     !(src.filename =~ /^#{SimpleCov.root}/) unless src.filename =~ /card/
-  end    
-  
+  end
+
   add_filter '/spec/'
   add_filter '/features/'
   add_filter '/config/'
@@ -58,7 +58,7 @@ def card_core_dev_simplecov_filters
   add_filter '/generators/'
   add_filter 'lib/card'
 
-  add_group 'Card', 'lib/card'  
+  add_group 'Card', 'lib/card'
   add_group 'Set Patterns', 'tmp/set_pattern/'
   add_group 'Sets',         'tmp/set/'
   add_group 'Formats' do |src_file|

data/lib/card/spec_helper.rb

@@ -11,8 +11,7 @@ module Card::SpecHelper
     # warn "(ath)login_as #{user.inspect}, #{Card::Auth.current_id}, #{@request.session[:user]}"
   end
 
-  def newcard name, content=''
-    #FIXME - misleading name; sounds like it doesn't save.
+  def create! name, content=''
     Card.create! name: name, content: content
   end
 
@@ -27,7 +26,7 @@ module Card::SpecHelper
 
   def debug_assert_view_select view_html, *args, &block
     Rails.logger.rspec %(
-      #{CodeRay.scan(Nokogiri::XML(view_html, &:noblanks).to_s, :html).div}
+                       #{CodeRay.scan(Nokogiri::XML(view_html, &:noblanks).to_s, :html).div}
       <style>
         .CodeRay {
           background-color: #FFF;
@@ -75,19 +74,27 @@ module Card::SpecHelper
   end
 
   # Make expectations in the event phase.
-  # Takes the usual event options :on and :before/:after/:around
-  # and registers the event_block with these options as an event.
+  # 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 additionaly :trigger block in opts is expected that is called
+  # An additionally :trigger block in opts is expected that is called
   # to start the event phase.
+  # Other event options like :on or :when are not supported yet.
   # Example:
-  # in_phase before: :approve, on: :save,
+  # in_stage :initialize,
   #          trigger: ->{ test_card.update_attributes! content: '' } do
   #            expect(item_names).to eq []
   #          end
-  def in_phase opts, &event_block
+  def in_stage stage, opts={}, &event_block
+    stage_sym = :"#{stage}_stage"
     $rspec_binding = binding
+    add_test_event stage_sym, :in_stage_test, &event_block
+    opts[:trigger].call
+  ensure
+    remove_test_event stage_sym, :in_stage_test
+  end
+
+  def add_test_event stage, name, &event_block
     Card.class_eval do
       def method_missing m, *args
         begin
@@ -102,16 +109,33 @@ module Card::SpecHelper
         rescue NameError
         end
         super
-#        raise NoMethodError
+        #        raise NoMethodError
       end
-      define_method :in_phase_test, event_block
+
+      define_method name, event_block
     end
-    Card.define_callbacks :in_phase_test
-    kind =  ([:before, :after, :around] & opts.keys).first
-    name = opts.delete(kind)
-    Card.set_callback name, kind, :in_phase_test, prepend: true
-    opts[:trigger].call
+    Card.define_callbacks name
+    Card.set_callback stage, :before, name, prepend: true
+  end
+
+  def remove_test_event stage, name
+    Card.skip_callback stage, :before, name
+  end
+
+  def test_event stage, _opts, &block
+    event_name = :"test_event_#{@events.size}"
+    stage_sym = :"#{stage}_stage"
+    @events << [stage_sym, event_name]
+    add_test_event stage_sym, event_name, &block
+  end
+
+  def with_test_events
+    @events = []
+    $rspec_binding = binding
+    yield
   ensure
-    Card.skip_callback name, kind, :in_phase_test
+    @events.each do |stage, name|
+      remove_test_event stage, name
+    end
   end
 end