card 1.91 → 1.92

data/lib/card/set.rb

@@ -2,33 +2,19 @@
 
 class Card
   #
-  #  A 'Set' is a group of Cards to which 'Rules' may be applied.
-  #  Sets can be as specific as a single card, as general as all cards, or
-  #  anywhere in between.
+  #  A _Set_ is a group of {Card Cards} to which _Rules_ may apply. Sets can be as specific as a single card, as general as all cards, or anywhere in between.
   #
-  #  Rules take two main forms: card rules and code rules.
+  #  Rules can defined onto Sets in two ways:
   #
-  #  'Card rules' are defined in card content. These are generally configured
-  #  via the web interface and are thus documented at http://wagn.org/rules.
+  #  - **Card rules** are defined in card content. These are generally configured via the web interface and are thus documented at http://wagn.org/rules.
+  #  - **Code rules** can be defined in a 'set module'.
   #
-  #  'Code rules' can be defined in a 'set module'. Card::Set supports
-  #  creating and organizing these set modules.  It also provides an API for
-  #  defining special methods within set modules.
+  # The {Card::Mod} docs explain how to create mods and set_modules. This page explains how those modules become useful.
   #
-  #  Set modules follow the following naming convention:
-  #
-  #      MOD/set/PATTERN/ANCHOR[/FREENAME].rb
-  #
-  #  For example, suppose you created a "mod" (a Card modification) for managing
-  #  your contacts called "contactmanager", and you wanted to write code
-  #  that would apply to all +address cards.  You could add a file here:
+  #  Suppose you have created a "mod" for managing your contacts called "contactmanager", and it includes code that would apply to all +address cards here:
   #
   #      ./contactmanager/set/right/address.rb
   #
-  #  or here:
-  #
-  #      ./contactmanager/set/right/address/countries.rb
-  #
   #  Then, whenever you fetch or instantiate a +address card, the card will
   #  automatically include code from that set module.  In fact, it will include
   #  all the set modules associated with sets of which it is a member.
@@ -47,14 +33,6 @@ class Card
   #  ...then mycard will include the set modules associated with each of those
   #  sets in the above order.
   #
-  #  You can quickly create a new set module running
-  #
-  #      `wagn generate set MOD PATTERN ANCHOR`
-  #
-  #  In the current example, this would translate to:
-  #
-  #      `wagn generate set contactmanager right address`.
-  #
   #  Note that the set module's filename connects it to the set, so both
   #  the set_pattern and the set_anchor must correspond to the
   #  codename of a card in the database to function correctly.

data/lib/card/set/advanced_api.rb

@@ -41,9 +41,9 @@ class Card
       private
 
       # @param set_name [String] name of the constant to be defined
-      def define_set set_name
+      def define_set set_name, start_const=Card::Set
         constant_pieces = set_name.split("::")
-        constant_pieces.inject(Card::Set) do |set_mod, module_name|
+        constant_pieces.inject(start_const) do |set_mod, module_name|
           set_mod.const_get_or_set module_name do
             Module.new
           end

data/lib/card/set/event.rb

@@ -1,11 +1,9 @@
 class Card
   def deserialize_for_active_job! attr
-    attr.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]
-      instance_variable_set("@#{attname}", value)
+    attr.each do |attname, val|
+      instance_variable_set("@#{attname}", val)
     end
+
     include_set_modules
   end
 
@@ -26,14 +24,41 @@ class Card
 
   def serialize_for_active_job
     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
+      hash[name] = instance_variable_get("@#{name}")
+    end
+  end
+
+  def serialize_value value
+    # ActiveJob doesn't accept symbols and Time as arguments
+    case value
+    when Symbol
+      { value: value.to_s, type: "symbol" }
+    when Time
+      { value: value.to_s, type: "time" }
+    when Hash
+      {
+        value: value.each_with_object({}) { |(k, v), h| h[k] = serialize_value(v) },
+        type: "hash"
+      }
+    when ActionController::Parameters
+      serialize_value value.to_unsafe_h
+    else
+      { value: value }
+    end
+  end
+
+  def deserialize_value val, type
+    case type
+    when "symbol"
+      val.to_sym
+    when "time"
+      DateTime.parse val
+    when "hash"
+      val.each_with_object({}) do |(k, v), h|
+        h[k] = deserialize_value v[:value], v[:type]
+      end
+    else
+      val
     end
   end
 
@@ -127,7 +152,7 @@ class Card
         end
       end
 
-      class IntegrateWithDelayJob < ActiveJob::Base
+      class IntegrateWithDelayJob < ApplicationJob
         def perform card, card_attribs, env, auth, method_name
           card.deserialize_for_active_job! card_attribs
           card.with_env_and_auth env, auth do

data/lib/card/set/helpers.rb

@@ -4,16 +4,17 @@ class Card
       def shortname
         parts = name.split "::"
         first = 2 # shortname eliminates Card::Set
-        pattern_name = parts[first].underscore
-        last = if pattern_name == "abstract"
-                 first + 1
-               else
-                 set_class = Pattern.find pattern_name
-                 first + set_class.anchor_parts_count
-               end
+        pattern_code = parts[first].underscore.to_sym
+        last = first + num_set_parts(pattern_code)
         parts[first..last].join "::"
       end
 
+      # move to Set::Pattern?
+      def num_set_parts pattern_code
+        return 1 if pattern_code == :abstract
+        Pattern.find(pattern_code).anchor_parts_count
+      end
+
       def abstract_set?
         name =~ /^Card::Set::Abstract::/
       end

data/lib/card/set/i18n_scanner.rb

@@ -0,0 +1,22 @@
+# lib/my_custom_scanner.rb
+require 'i18n/tasks/scanners/file_scanner'
+class Card
+  module Set
+    class I18nScanner < ::I18n::Tasks::Scanners::FileScanner
+      include ::I18n::Tasks::Scanners::RelativeKeys
+      include ::I18n::Tasks::Scanners::OccurrenceFromPosition
+
+      # @return [Array<[absolute key, Results::Occurrence]>]
+      def scan_file(path)
+        text = read_file(path)
+
+        text.scan(/[^\w._-]tr[( ]\s*["':](\w+)/).map do |_match|
+          occurrence = occurrence_from_position(
+              path, text, Regexp.last_match.offset(0).first)
+          [absolute_key(".#{_match[0]}", path), occurrence]
+        end
+      end
+    end
+    ::I18n::Tasks.add_scanner 'Card::Set::I18nScanner'
+  end
+end

data/lib/card/set/i18n_scope.rb

@@ -3,31 +3,56 @@ class Card
     module I18nScope
       # return scope for I18n
       def scope backtrace
-        parts = tmp_set_path_parts backtrace
+        parts = set_path_parts backtrace
         "mod.#{parts.first}.set.#{parts[1..-1].join '.'}"
       end
 
       # extract the mod name from the path of a set's tmp file
       def mod_name backtrace
-        tmp_set_path_parts(backtrace).first
+        parts = path_parts backtrace
+        parts[path_mod_index(parts)]
       end
 
       private
 
+      def path_parts backtrace
+        find_set_path(backtrace).split(File::SEPARATOR)
+      end
+
+      # extract mod and set from real path
+      # @example
+      #   if the path looks like ~/mydeck/mod/core/set/all/event.rb/
+      #   this method returns ["core", "all", "event"]
+      def set_path_parts backtrace
+        parts = path_parts backtrace
+        res = parts[path_mod_index(parts)..-1]
+        res.delete_at 1
+        res[-1] = res.last.split(".").first
+        res
+      end
+
       # extract mod and set from tmp path
       # @example
-      #   a tmp paths looks like ~/mydeck/tmp/set/mod002-core/all/event.rb/
+      #   a tmp path looks like ~/mydeck/tmp/set/mod002-core/all/event.rb/
       #   this method returns ["core", "all", "event"]
       def tmp_set_path_parts backtrace
         path_parts = find_tmp_set_path(backtrace).split(File::SEPARATOR)
-        res = path_parts[path_mod_index(path_parts)..-1]
+        res = path_parts[tmp_path_mod_index(path_parts)..-1]
         res[0] = mod_name_from_tmp_dir res.first
         res[-1] = res.last.split(".").first
         res
       end
 
       def find_tmp_set_path backtrace
-        path = backtrace.find { |line| line.include? "tmp/set/" }
+        path = backtrace.find {|line| line.include? "tmp/set/"}
+        unless path
+          raise Error, "couldn't find set path in backtrace: #{backtrace}"
+        end
+        path
+      end
+
+      def find_set_path backtrace
+        path = backtrace.find {|line| line =~ %r{(?<!card)/set/}}
         unless path
           raise Error, "couldn't find set path in backtrace: #{backtrace}"
         end
@@ -35,9 +60,9 @@ class Card
       end
 
       # index of the mod part in the tmp path
-      def path_mod_index parts
+      def tmp_path_mod_index parts
         unless (set_index = parts.index("set")) &&
-               parts.size >= set_index + 2
+          parts.size >= set_index + 2
           raise Error, "not a valid set path: #{path}"
         end
         set_index + 1
@@ -47,6 +72,15 @@ class Card
         match = dir.match(/^mod\d+-(?<mod_name>.+)$/)
         match[:mod_name]
       end
+
+      # index of the mod part in the path
+      def path_mod_index parts
+        unless (set_index = parts.index("set")) &&
+          parts.size >= set_index + 2
+          raise Error, "not a valid set path: #{path}"
+        end
+        set_index - 1
+      end
     end
   end
 end

data/lib/card/set/loader.rb

@@ -36,55 +36,6 @@ class Card
       #  extend the module with Card::Set.
 
       #
-      def write_tmp_file from_file, to_file, rel_path
-        pattern, submodules = pattern_and_modules_from_path rel_path
-        FileUtils.mkdir_p File.dirname(to_file)
-        File.write to_file, tmp_file_template(pattern, submodules, from_file)
-        to_file
-      end
-
-      def pattern_and_modules_from_path path
-        # remove file extension and number prefixes
-        parts = path.gsub(/\.rb/, "").gsub(%r{(?<=\A|/)\d+_}, "")
-                    .split(File::SEPARATOR)
-        parts.map! &:camelize
-        [parts.shift, parts]
-      end
-
-      def tmp_file_template pattern, modules, content_path
-        content = File.read(content_path)
-        wrapped_content = tmp_file_wrapped_content content_path, content
-
-        # TODO: load directly without tmp file
-        return wrapped_content if content =~ /\A#!\s?simple load/
-
-        submodules = modules.map { |m| "module #{m};" }
-        if content =~ /\A#!\s?not? set module/
-          submodules.pop
-        else
-          submodules[-1] += " extend Card::Set"
-        end
-        tmp_file_frame pattern, submodules, wrapped_content, content_path
-      end
-
-      def tmp_file_frame pattern, submodules, content, content_path
-<<-RUBY
-# -*- encoding : utf-8 -*-
-class Card; module Set; class #{pattern}; #{submodules.join ' '}
-  def self.source_location; "#{content_path}"; end
-#{content}
-end;end;end;#{'end;' * submodules.size}
-RUBY
-      end
-
-      def tmp_file_wrapped_content content_path, content
-<<-RUBY
-# ~~ above autogenerated; below pulled from #{content_path} ~~
-#{content}
-
-# ~~ below autogenerated; above pulled from #{content_path} ~~
-RUBY
-      end
 
       # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # Organization Phase
@@ -93,13 +44,13 @@ RUBY
       # Format class
       # 'nonbase modules' are included dynamically on singleton_classes
       def process_base_modules
-        return unless modules[:base]
+        return unless modules[:base].present?
         Card.add_set_modules modules[:base]
         modules[:base_format].each do |format_class, modules_list|
           format_class.add_set_modules modules_list
         end
-        modules.delete :base
-        modules.delete :base_format
+        modules[:base].clear
+        modules[:base_format].clear
       end
 
       def clean_empty_modules

data/lib/card/set_pattern.rb

@@ -9,33 +9,15 @@ class Card
         def card_keys
           @card_keys ||=
             Card.set_patterns.inject({}) do |hash, set_pattern|
-              card_key = Card.quick_fetch(set_pattern.pattern_code.to_sym).key
+              card_key = Card.quick_fetch(set_pattern.pattern_code).key
               hash[card_key] = true
               hash
             end
         end
 
-        def write_tmp_file pattern_code, from_file, seq
-          to_file = "#{Card.paths['tmp/set_pattern'].first}/" \
-                    "#{seq}-#{pattern_code}.rb"
-          klass = "Card::Set::#{pattern_code.camelize}"
-          file_content = <<EOF
-# -*- encoding : utf-8 -*-
-class #{klass} < Card::Set::Pattern::Abstract
-  cattr_accessor :options
-  class << self
-# ~~ above autogenerated; below pulled from #{from_file} ~~
-
-#{File.read from_file}
-
-# ~~ below autogenerated; above pulled from #{from_file} ~~
-  end
-  register "#{pattern_code}", (options || {})
-end
-
-EOF
-          File.write to_file, file_content
-          to_file
+        def in_load_order
+          @in_load_order ||=
+            Card.set_patterns.reverse.map(&:pattern_code).unshift :abstract
         end
       end
 
@@ -78,6 +60,12 @@ EOF
           def anchor_parts_count
             @anchor_parts_count ||= (anchorless? ? 0 : 1)
           end
+
+          def module_key anchor_codes
+            return pattern_code.to_s.camelize if anchorless?
+            return unless anchor_codes # is this not an error?
+            ([pattern_code] + anchor_codes).map { |code| code.to_s.camelize }.join "::"
+          end
         end
 
         # Instance methods
@@ -85,28 +73,24 @@ EOF
         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
+            @anchor_id = find_anchor_id card
           end
           self
         end
 
+        def find_anchor_id card
+          if self.class.respond_to? :anchor_id
+            self.class.anchor_id card
+          else
+            Card.fetch_id @anchor_name
+          end
+        end
+
         def module_key
           if defined? @module_key
             @module_key
           else
-            @module_key = begin
-              if self.class.anchorless?
-                self.class.pattern_code.camelize
-              elsif anchor_codenames
-                codenames = [self.class.pattern_code] +
-                            anchor_codenames.map(&:to_s)
-                codenames.map(&:camelize).join "::"
-              end
-            end
+            @module_key = self.class.module_key(anchor_codenames)
           end
         end
 
@@ -158,7 +142,7 @@ EOF
         end
 
         def safe_key
-          caps_part = self.class.pattern_code.tr(" ", "_").upcase
+          caps_part = self.class.pattern_code.to_s.tr(" ", "_").upcase
           if self.class.anchorless?
             caps_part
           else
@@ -168,7 +152,7 @@ EOF
 
         def rule_set_key
           if self.class.anchorless?
-            self.class.pattern_code
+            self.class.pattern_code.to_s
           elsif @anchor_id
             "#{@anchor_id}+#{self.class.pattern_code}"
           end