card 1.16.8 → 1.16.9

data/lib/card/cache.rb

@@ -147,7 +147,7 @@ class Card
 
     def write_variable key, variable, value
       key = @prefix + key
-      if @store and object = @store.read(key)
+      if @store && (object = @store.read key)
         object.instance_variable_set "@#{ variable }", value
         @store.write key, object
       end
@@ -174,7 +174,7 @@ class Card
     end
 
     def fetch_local key
-      read_local key or write_local key, yield
+      read_local(key) || write_local(key, yield)
     end
 
     def delete key
@@ -182,6 +182,10 @@ class Card
       @local.delete key
     end
 
+    def delete_local key
+      @local.delete key
+    end
+
     def dump
       p "dumping local...."
       @local.each do |k, v|
@@ -211,7 +215,7 @@ class Card
     end
 
     def exist? key
-      @local.has_key?(key) || @store.exist?(key)
+      @local.has_key?(key) || (@store && @store.exist?(key))
     end
   end
 end

data/lib/card/codename.rb

@@ -29,10 +29,10 @@ class Card
       def bootdata hash
         @@codehash = hash
       end
-      
-  
+
+
       private
-      
+
       def cache
         Card::Cache[Codename]
       end
@@ -53,10 +53,10 @@ class Card
         end
       end
     end
-    
+
   end
-  
-  
+
+
   def self.const_missing const
     if const.to_s =~ /^([A-Z]\S*)ID$/ and code=$1.underscore.to_sym
       if card_id = Codename[code]
@@ -68,5 +68,5 @@ class Card
       super
     end
   end
-  
+
 end

data/lib/card/format.rb

@@ -204,7 +204,8 @@ class Card
         args = default_render_args view, args
         with_inclusion_mode view do
           Card::ViewCache.fetch(self, view, args) do
-            send "_view_#{ view }", args
+            method = method "_view_#{ view }"
+            method.arity == 0 ? method.call : method.call(args)
           end
         end
       end

data/lib/card/migration.rb

@@ -1,16 +1,17 @@
 # -*- encoding : utf-8 -*-
 
 class Card::Migration < ActiveRecord::Migration
+  include Card::ActiveRecordHelper
   @type = :deck_cards
 
   class << self
-
     # Rake tasks use class methods, migrations use instance methods.
-    # To avoid repetition a lot of instance methods here just call class methods.
+    # To avoid repetition a lot of instance methods here just call class
+    # methods.
     # The subclass Card::CoreMigration needs a different @type so we can't use a
     # class variable @@type. It has to be a class instance variable.
-    # Migrations are subclasses of Card::Migration or Card::CoreMigration but they
-    # don't inherit the @type. The method below solves this problem.
+    # Migrations are subclasses of Card::Migration or Card::CoreMigration
+    # but they don't inherit the @type. The method below solves this problem.
     def type
       @type || (ancestors[1] && ancestors[1].type)
     end
@@ -18,9 +19,9 @@ class Card::Migration < ActiveRecord::Migration
     def find_unused_name base_name
       test_name = base_name
       add = 1
-      while Card.exists?(test_name) do
+      while Card.exists?(test_name)
         test_name = "#{base_name}#{add}"
-        add +=1
+        add += 1
       end
       test_name
     end
@@ -50,18 +51,18 @@ class Card::Migration < ActiveRecord::Migration
 
     def assume_migrated_upto_version
       schema_mode do
-        ActiveRecord::Schema.assume_migrated_upto_version schema, migration_paths
+        ActiveRecord::Schema.assume_migrated_upto_version schema,
+                                                          migration_paths
       end
     end
 
     def data_path filename=nil
       path = migration_paths.first
-      File.join( [ migration_paths.first, 'data', filename ].compact )
+      File.join([path, 'data', filename].compact)
     end
-
   end
 
-  def contentedly &block
+  def contentedly
     Card::Cache.reset_global
     Cardio.schema_mode '' do
       Card::Auth.as_bot do
@@ -78,14 +79,15 @@ class Card::Migration < ActiveRecord::Migration
 
   def import_json filename, merge_opts={}
     Card.config.action_mailer.perform_deliveries = false
-    merge_opts.reverse_merge! output_file: File.join(data_path,"unmerged_#{ filename }")
+    output_file = File.join data_path, "unmerged_#{ filename }"
+    merge_opts[:output_file] ||= output_file
     Card.merge_list read_json(filename), merge_opts
   end
 
   def read_json filename
-    raw_json = File.read( data_path filename )
+    raw_json = File.read data_path(filename)
     json = JSON.parse raw_json
-    json["card"]["value"]
+    json['card']['value']
   end
 
   def data_path filename=nil
@@ -101,8 +103,8 @@ class Card::Migration < ActiveRecord::Migration
   end
 
   # Execute this migration in the named direction
-  # copied from ActiveRecord to wrap "up" in "contentendly"
-  def exec_migration(conn, direction)
+  # copied from ActiveRecord to wrap 'up' in 'contentendly'
+  def exec_migration conn, direction
     @connection = conn
     if respond_to?(:change)
       if direction == :down
@@ -117,7 +119,6 @@ class Card::Migration < ActiveRecord::Migration
     @connection = nil
   end
 
-
   def down
     raise ActiveRecord::IrreversibleMigration
   end

data/lib/card/name.rb

@@ -5,61 +5,112 @@ require 'smart_name'
 
 class Card
   class Name < SmartName
+    RELATIVE_REGEXP = /\b_(left|right|whole|self|user|main|\d+|L*R?)\b/
 
     self.params  = Card::Env # yuck!
     self.session = proc { Card::Auth.current.name }
     self.banned_array = ['/']
 
     def star?
-      simple? and '*' == s[0,1]
+      simple? && '*' == s[0, 1]
     end
 
     def rstar?
-      right and '*' == right[0,1]
+      right && '*' == right[0, 1]
     end
 
     def trait_name? *traitlist
       junction? && begin
         right_key = right_name.key
-        !!traitlist.find do |codename|
-          card_id = Card::Codename[ codename ] and card = Card.fetch( card_id, skip_modules: true, skip_virtual: true ) and
+        traitlist.find do |codename|
+          (card_id = Card::Codename[codename]) &&
+            (card = Card.quick_fetch card_id) &&
             card.key == right_key
-        end
+        end.present?
       end
     end
 
     def trait_name tag_code
-      card_id = Card::Codename[ tag_code ] and card = Card.fetch( card_id, skip_modules: true, skip_virtual: true ) and
-        [ self, card.cardname ].to_name
+      (card_id = Card::Codename[tag_code]) &&
+        (card = Card.quick_fetch card_id) &&
+        [self, card.cardname].to_name
     end
 
     def trait tag_code
-      name = trait_name( tag_code )
-      name ? name.s : ( raise Card::NotFound, "unknown codename: #{tag_code}" )
+      name = trait_name(tag_code)
+      name ? name.s : (fail Card::NotFound, "unknown codename: #{tag_code}")
+    end
+
+    def field tag_name
+      field_name(tag_name).s
     end
 
     def code
-      Card::Codename[ Card.fetch_id self ]
+      Card::Codename[Card.fetch_id self]
+    end
+
+    # returns full name for a field
+    def field_name tag_name
+      case tag_name
+      when Symbol
+        trait_name tag_name
+      else
+        if tag_name.to_s[0] == '+'
+          tag_name = tag_name.to_s[1..-1]
+        end
+        [ self, tag_name ].to_name
+      end
+    end
+
+    def relative_field_name tag_name
+      field_name(tag_name).relative_name(self)
+    end
+
+    def relative_name context_name
+      to_show(*context_name.to_name.parts).to_name
     end
 
+    def absolute_name context_name
+      to_absolute_name(context_name)
+    end
 
-    def is_a_field_of? context_name
+    def field_of? context_name
       if context_name.present?
-        # Do I still equal myself after I've been relativised in the context of context_name?
-        relative_name = self.to_show(*context_name.to_name.parts).to_name
-        absolute_name = self.to_absolute_name(context_name)
-        relative_name.key != absolute_name.key
+        # Do I still equal myself after I've been relativised in the context
+        # of context_name?
+        relative_name(context_name).key != absolute_name(context_name).key
       else
-        self.s.match /^\s*\+/
+        s.match(/^\s*\+/)
       end
     end
 
-    def is_setting?
-      Set::Type::Setting.member_names[ key ]
+    def setting?
+      Set::Type::Setting.member_names[key]
+    end
+
+    def set?
+      SetPattern.card_keys[tag_name.key]
+    end
+
+
+    def relative?
+      s =~ RELATIVE_REGEXP || starts_with_joint?
+    end
+
+    def absolute?
+      !relative?
+    end
+
+    def stripped
+      s.gsub RELATIVE_REGEXP, ''
+    end
+
+    def starts_with_joint?
+      s =~ /^\+/
     end
 
-    def is_set?
-      SetPattern.card_keys[ tag_name.key ]
+    def to_sym
+      s.to_sym
     end
   end
 end

data/lib/card/set.rb

@@ -1,86 +1,91 @@
 # -*- encoding : utf-8 -*-
 
 class Card
-  #remove_const :Set if const_defined?(:Set, false)
+  # remove_const :Set if const_defined?(:Set, false)
 
   module Set
-
     mattr_accessor :modules, :traits
     @@modules = { base: [], base_format: {}, nonbase: {}, nonbase_format: {} }
 
-
-=begin
-    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.
-
-    Rules take two main forms: card rules and code 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 file" within any "Mod" (short for both "module" and
-    "modification"). In accordance with Wagn's "MoVE" architecture, there are two main kinds of
-    code rules you can create in a set file: Views, and Events.  Events are associated with the
-    Card class, and Views are associated with a Format class.  You can also use set files to
-    add or override Card and/or Format methods directly.  The majority of Card code is contained
-    in these files.
-
-        (FIXME - define mod, add generator)
-
-    Whenever you fetch or instantiate a card, it will automatically include all the
-    set modules defined in set files associated with sets of which it is a member.  This
-    entails both simple model methods and "events", which are special methods explored
-    in greater detail below.
-
-    For example, say you have a Plaintext card named "Philipp+address", and you have set files
-    for the following sets:
-
-        * all cards
-        * all Plaintext cards
-        * all cards ending in +address
-
-    When you run this:
-
-        mycard = Card.fetch 'Philipp+address'
-
-    ...then mycard will include the set modules associated with each of those sets in the above
-    order.  (The order is determined by the set pattern; see lib/card/set_pattern.rb for more
-    information about set_ptterns and mod/core/set/all/fetch.rb for more about fetching.)
-
-    Similarly, whenever a Format object is instantiated for a card, it includes all views
-    associated with BOTH (a) sets of which the card is a member and (b) the current format or
-    its ancestors.  More on defining views below.
-
-
-    In order to have a set file associated with "all cards ending in +address", you could create
-    a file in mywagn/mod/mymod/set/right/address.rb.  The recommended mechanism for doing so
-    is running `wagn generate set modname set_pattern set_anchor`. In the current example, this
-    would translate to `wagn generate set mymod right address`. Note that both the set_pattern
-    and the set_anchor must correspond to the codename of a card in the database to function
-    correctly but you can add arbitrary subdirectories to organize your code rules. The rule above
-    for example could be saved in mywagn/mod/mymod/set/right/address/america/north/canada.rb.
-
-
-    When a Card application loads, it uses these files to autogenerate a tmp_file that uses this set file to
-    createa Card::Set::Right::Address module which itself is extended with Card::Set. A set file
-    is "just ruby" but is generally quite concise because Card uses its file location to
-    autogenerate ruby module names and then uses Card::Set module to provide additional API.
-
-
- View definitions
-
-   When you declare:
-     view :view_name do |args|
-       #...your code here
-     end
-
-   Methods are defined on the format
-
-   The external api with checks:
-     render(:viewname, args)
-
-
-=end
+ #    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.
+ #
+ #    Rules take two main forms: card rules and code 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 file' within any 'Mod' (short for
+ #    both 'module' and 'modification'). In accordance with Wagn's 'MoVE'
+ #    architecture, there are two main kinds of code rules you can create in
+ #    set file: Views, and Events.
+ #    Events are associated with the Card class, and Views are associated with
+ #    a Format class.
+ #    You can also use set files to add or override Card and/or Format methods
+ #    directly.  The majority of Card code is contained in these files.
+ #
+ #        (FIXME - define mod, add generator)
+ #
+ #    Whenever you fetch or instantiate a card, it will automatically include
+ #    all the set modules defined in set files associated with sets of which it
+ #    is a member.  This entails both simple model methods and 'events', which
+ #    are special methods explored in greater detail below.
+ #
+ #    For example, say you have a Plaintext card named 'Philipp+address', and
+ #    you have set files for the following sets:
+ #
+ #        * all cards
+ #        * all Plaintext cards
+ #        * all cards ending in +address
+ #
+ #    When you run this:
+ #
+ #        mycard = Card.fetch 'Philipp+address'
+ #
+ #    ...then mycard will include the set modules associated with each of those
+ #   sets in the above order.  (The order is determined by the set pattern;
+ #   see lib/card/set_pattern.rb for more information about set_ptterns and
+ #   mod/core/set/all/fetch.rb for more about fetching.)
+ #
+ #   Similarly, whenever a Format object is instantiated for a card, it
+ #   includes all views associated with BOTH (a) sets of which the card is a
+ #   member and (b) the current format or its ancestors.  More on defining
+ #   views below.
+ #
+ #
+ #    In order to have a set file associated with "all cards ending in
+ #    +address", you could create a file in
+ #    mywagn/mod/mymod/set/right/address.rb.
+ #    The recommended mechanism for doing so is running `wagn generate set
+ #    modname set_pattern set_anchor`. In the current example, this
+ #    would translate to `wagn generate set mymod right address`.
+ #    Note that both the set_pattern and the set_anchor must correspond to the
+ #    codename of a card in the database to function correctly but you can add
+ #    arbitrary subdirectories to organize your code rules. The rule above
+ #    for example could be saved in
+ #    mywagn/mod/mymod/set/right/address/america/north/canada.rb.
+ #
+ #
+ #    When a Card application loads, it uses these files to autogenerate a
+ #    tmp_file that uses this set file to create a Card::Set::Right::Address
+ #    module which itself is extended with Card::Set. A set file is 'just ruby'
+ #    but is generally quite concise because Card uses its file location to
+ #    autogenerate ruby module names and then uses Card::Set module to provide
+ #    additional API.
+ #
+ #
+ # View definitions
+ #
+ #   When you declare:
+ #     view :view_name do |args|
+ #       #...your code here
+ #     end
+ #
+ #   Methods are defined on the format
+ #
+ #   The external api with checks:
+ #     render(:viewname, args)
 
     module Format
       mattr_accessor :views
@@ -89,32 +94,33 @@ class Card
       def view view, *args, &block
         view = view.to_viewname.key.to_sym
         views[self] ||= {}
-        view_block = views[self][view] = if block_given?
-          Card::Format.extract_class_vars view, args[0]
-          block
-        else
-          alias_block view, args
-        end
+        view_block = views[self][view] =
+          if block_given?
+            Card::Format.extract_class_vars view, args[0]
+            block
+          else
+            alias_block view, args
+          end
         define_method "_view_#{ view }", view_block
       end
 
       def alias_block view, args
-        opts = Hash===args[0] ? args.shift : { view: args.shift }
+        opts = args[0].is_a?(Hash) ? args.shift : { view: args.shift }
         opts[:mod]  ||= self
         opts[:view] ||= view
-        views[ opts[:mod] ][ opts[:view] ] or fail
+        views[opts[:mod]][opts[:view]] || fail
       rescue
-        raise "cannot find #{ opts[:view] } view in #{ opts[:mod] }; failed to alias #{view} in #{self}"
+        raise "cannot find #{ opts[:view] } view in #{ opts[:mod] }; " \
+              "failed to alias #{view} in #{self}"
       end
-
     end
 
-
     def format *format_names, &block
       if format_names.empty?
         format_names = [:base]
       elsif format_names.first == :all
-        format_names = Card::Format.registered.reject {|f| Card::Format.aliases[f]}
+        format_names = Card::Format.registered
+          .reject { |f| Card::Format.aliases[f] }
       end
       format_names.each do |f|
         define_on_format f, &block
@@ -122,9 +128,12 @@ class Card
     end
 
     def define_on_format format_name=:base, &block
-      klass = Card::Format.format_class_name format_name   # format class name, eg. HtmlFormat
-      mod = const_get_or_set klass do                      # called on current set module, eg Card::Set::Type::Pointer
-        m = Module.new                                     # yielding set format module, eg Card::Set::Type::Pointer::HtmlFormat
+      # format class name, eg. HtmlFormat
+      klass = Card::Format.format_class_name format_name
+      # called on current set module, eg Card::Set::Type::Pointer
+      mod = const_get_or_set klass do
+        # yielding set format module, eg Card::Set::Type::Pointer::HtmlFormat
+        m = Module.new
         register_set_format Card.const_get(klass), m
         m.extend Card::Set::Format
         m
@@ -138,11 +147,11 @@ class Card
       end
     end
 
-
     def event event, opts={}, &final
-      perform_later =  (opts[:before] == :subsequent) || (opts[:after] == :subsequent)
-      final_method = "#{event}_without_callbacks" #should be private?
-      opts[:on] = [:create, :update ] if opts[:on] == :save
+      perform_later = (opts[:before] == :subsequent) ||
+                      (opts[:after] == :subsequent)
+      final_method = "#{event}_without_callbacks" # should be private?
+      opts[:on] = [:create, :update] if opts[:on] == :save
 
       Card.define_callbacks event
 
@@ -161,26 +170,53 @@ class Card
       set_event_callbacks event, opts
     end
 
+    def phase_method method, opts={}, &block
+      class_eval do
+        define_method "_#{method}", &block
+        define_method method do |*args|
+          error =
+            if !phase_ok? opts
+              if !phase
+                "phase method #{method} called outside of event phases"
+              else
+                "#{opts.inspect} method #{method} called in phase #{phase}"
+              end
+            elsif !on_condition_applies?(opts[:on])
+              "on: #{opts[:on]} method #{method} called on #{@action}"
+            end
+          if error
+            raise Card::Error, error
+          else
+            send "_#{method}", *args
+          end
+        end
+      end
+    end
+
     def define_event_perform_later_method event, method_name
       class_eval do
         define_method method_name, proc {
-          s_attr = self.serializable_attributes.each_with_object({}) do |name, hash|
-                   value = self.instance_variable_get("@#{name}")
-                   hash[name] =
-                     if Symbol === value  # ActiveJob doesn't accept symbols as arguments
-                       { value: value.to_s, symbol: true }
-                     else
-                       { value: value }
-                     end
+          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 Symbol === value
+                  { 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
+    def define_event_method event, call_method, _opts
       class_eval do
         define_method event do
+          # Rails.logger.rspec event
+          # puts "#{self.name}: #{event}"
           run_callbacks event do
             send call_method
           end
@@ -188,14 +224,15 @@ class Card
       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)
+    # 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 queue
-    def define_active_job name, final_method, queue = :default
+    def define_active_job name, final_method, queue=:default
       class_name = name.to_s.camelize
       eval %{
         class ::#{class_name} < ActiveJob::Base
@@ -203,15 +240,15 @@ class Card
         end
       }
       Object.const_get(class_name).class_eval do
-       define_method :perform, proc { |card, attributes|
+        define_method :perform, proc { |card, attributes|
           attributes.each do |name, 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("@#{name}", value )
+            card.instance_variable_set("@#{name}", value)
           end
           card.send final_method
-      }
+        }
       end
     end
 
@@ -220,47 +257,45 @@ class Card
     #
     def card_accessor *args
       options = args.extract_options!
-      add_traits args, options.merge( reader: true, writer: true )
+      add_traits args, options.merge(reader: true, writer: true)
     end
 
     def card_reader *args
       options = args.extract_options!
-      add_traits args, options.merge( reader: true )
+      add_traits args, options.merge(reader: true)
     end
 
     def card_writer *args
       options = args.extract_options!
-      add_traits args, options.merge( writer: true )
+      add_traits args, options.merge(writer: true)
     end
 
-
     def ensure_set &block
       begin
         set_module = block.call
       rescue NameError => e
         if e.message.match /uninitialized constant (?:Card::Set::)?(.+)$/
-          $1.split('::').inject(Card::Set) do |set_module, module_name|
-            set_module.const_get_or_set module_name do
+          $1.split('::').inject(Card::Set) do |set_mod, module_name|
+            set_mod.const_get_or_set module_name do
               Module.new
             end
           end
         end
-        ensure_set &block # try again - there might be another submodule that doesn't exist
+        # try again - there might be another submodule that doesn't exist
+        ensure_set &block
       else
         set_module.extend Card::Set
       end
     end
-
-
     # the set loading process has two main phases:
 
-    #  1. Definition: interpret each set file, creating/defining set and set_format modules
-    #  2. Organization: have base classes include modules associated with the "all" set, and
-    #     clean up the other modules
+    #  1. Definition: interpret each set file, creating/defining set and
+    #     set_format modules
+    #  2. Organization: have base classes include modules associated with the
+    #     'all' set, and clean up the other modules
 
     class << self
-
-      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # Definition Phase
 
       # each set file calls `extend Card::Set` when loaded
@@ -268,44 +303,44 @@ class Card
         register_set mod
       end
 
-
       # make the set available for use
       def register_set set_module
-        if set_module.abstract_set?
-          # noop; only used by explicit inclusion in other set modules
-        elsif set_module.all_set?
+        return if set_module.abstract_set?  # noop; only used by explicit
+        # inclusion in other set modules
+        if set_module.all_set?
           # automatically included in Card class
-          modules[ :base ] << set_module
+          modules[:base] << set_module
         else
           # made ready for dynamic loading via #include_set_modules
-          modules[ :nonbase ][ set_module.shortname ] ||= []
-          modules[ :nonbase ][ set_module.shortname ] << set_module
+          modules[:nonbase][set_module.shortname] ||= []
+          modules[:nonbase][set_module.shortname] << set_module
         end
       end
 
       def write_tmp_file from_file, to_file, rel_path
-        name_parts = rel_path.gsub(/\.rb/,'').split(File::SEPARATOR)
+        name_parts = rel_path.gsub(/\.rb/, '').split(File::SEPARATOR)
         submodules = name_parts.map { |a| "module #{a.camelize};" } * ' '
         file_content = <<EOF
 # -*- encoding : utf-8 -*-
-class Card; module Set; #{submodules} extend Card::Set # ~~~~~~~~~~~ above autogenerated; below pulled from #{from_file} ~~~~~~~~~~~
+class Card; module Set; #{submodules} extend Card::Set
+# ~~~~~~~~~~~ above autogenerated; below pulled from #{from_file} ~~~~~~~~~~~
 #{ File.read from_file }
 
 # ~~~~~~~~~~~ below autogenerated; above pulled from #{from_file} ~~~~~~~~~~~
-end;end;#{'end;'*name_parts.size}
+end;end;#{'end;' * name_parts.size}
 EOF
 
-        FileUtils.mkdir_p to_file.gsub /[^\/]*$/, ''
+        FileUtils.mkdir_p File.dirname(to_file)
         File.write to_file, file_content
         to_file
       end
 
-
-      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # Organization Phase
 
-      # "base modules" are modules that are permanently included on the Card or Format class
-      # "nonbase modules" are included dynamically on singleton_classes
+      # 'base modules' are modules that are permanently included on the Card or
+      # Format class
+      # 'nonbase modules' are included dynamically on singleton_classes
       def process_base_modules
         process_base_module_list modules[:base], Card
         modules[:base_format].each do |format_class, modules_list|
@@ -320,15 +355,15 @@ EOF
           if mod.instance_methods.any?
             klass.send :include, mod
           end
-          if class_methods = mod.const_get_if_defined( :ClassMethods )
+          if (class_methods = mod.const_get_if_defined(:ClassMethods))
             klass.send :extend, class_methods
           end
         end
       end
 
       def clean_empty_modules
-        clean_empty_module_from_hash modules[ :nonbase ]
-        modules[ :nonbase_format ].values.each do |hash|
+        clean_empty_module_from_hash modules[:nonbase]
+        modules[:nonbase_format].values.each do |hash|
           clean_empty_module_from_hash hash
         end
       end
@@ -339,22 +374,21 @@ EOF
           hash.delete mod_name if modlist.empty?
         end
       end
-
     end
 
-
     def register_set_format format_class, mod
-      if self.abstract_set?
-        # noop; only used by explicit inclusion in other set modules
-      elsif self.all_set?
+      return if self.abstract_set? # noop; only used by explicit inclusion in
+      # other set modules
+
+      if self.all_set?
         # ready to include in base format classes
-        modules[ :base_format ][ format_class ] ||= []
-        modules[ :base_format ][ format_class ] << mod
+        modules[:base_format][format_class] ||= []
+        modules[:base_format][format_class] << mod
       else
         # ready to include dynamically in set members' format singletons
-        format_hash = modules[ :nonbase_format ][ format_class ] ||= {}
-        format_hash[ shortname ] ||= []
-        format_hash[ shortname ] << mod
+        format_hash = modules[:nonbase_format][format_class] ||= {}
+        format_hash[shortname] ||= []
+        format_hash[shortname] << mod
       end
     end
 
@@ -377,15 +411,18 @@ EOF
 
     private
 
-
     def set_event_callbacks event, opts
       [:before, :after, :around].each do |kind|
-        if object_method = opts.delete(kind)
+        if (object_method = opts.delete(kind))
           this_set_module = self
           Card.class_eval do
-            set_callback object_method, kind, event, prepend: true, if: proc { |c|
-              c.singleton_class.include?( this_set_module ) and c.event_applies? opts
-            }
+            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
@@ -393,16 +430,16 @@ EOF
 
     def get_traits mod
       Card::Set.traits ||= {}
-      Card::Set.traits[mod] or Card::Set.traits[mod] = {}
+      Card::Set.traits[mod] || Card::Set.traits[mod] = {}
     end
 
     def add_traits args, options
       mod = self
-  #    raise "Can't define card traits on all set" if mod == Card
+      # raise "Can't define card traits on all set" if mod == Card
       mod_traits = get_traits mod
 
-      new_opts = options[:type] ? {type: options[:type]} : {}
-      new_opts.merge!( {content: options[:default]} ) if options[:default]
+      new_opts = options[:type] ? { type: options[:type] } : {}
+      new_opts.merge!(content: options[:default]) if options[:default]
 
       args.each do |trait|
         define_trait_card trait, new_opts
@@ -424,7 +461,7 @@ EOF
     def define_trait_reader trait
       define_method trait do
         trait_var "@#{trait}" do
-          send( "#{trait}_card" ).content
+          send("#{trait}_card").content
         end
       end
     end
@@ -432,8 +469,7 @@ EOF
     def define_trait_writer trait
       define_method "#{trait}=" do |value|
         card = send "#{trait}_card"
-        self.subcards ||= {}
-        self.subcards[card.name] = {type_id: card.type_id, content: value }
+        subcards.add name: card.name, type_id: card.type_id, content: value
         instance_variable_set "@#{trait}", value
       end
     end
@@ -445,10 +481,10 @@ EOF
 
     def attachment name, args
       include Abstract::Attachment
-      set_specific_attributes name,  :load_from_mod, "remote_#{name}_url".to_sym,
+      set_specific_attributes name, :load_from_mod, :cached_upload,
+                                    "remote_#{name}_url".to_sym
       uploader_class = args[:uploader] || FileUploader
       mount_uploader name, uploader_class
     end
   end
 end
-