card 1.18.4 → 1.18.5

data/lib/card/set/format.rb

@@ -0,0 +1,122 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  module Set
+    #  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.
+    #
+    # 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
+      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] }
+        end
+        format_names.each do |f|
+          define_on_format f, &block
+        end
+      end
+
+      def view *args, &block
+        format do
+          view(*args, &block)
+        end
+      end
+
+      def define_on_format format_name=:base, &block
+        # 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::AbstractFormat
+          m
+        end
+        mod.class_eval(&block)
+      end
+
+      def register_set_format format_class, mod
+        if all_set?
+          all_set_format_mod! format_class, mod
+        else
+          format_type = abstract_set? ? :abstract_format : :nonbase_format
+          # ready to include dynamically in set members' format singletons
+          format_hash = modules[format_type][format_class] ||= {}
+          format_hash[shortname] ||= []
+          format_hash[shortname] << mod
+        end
+      end
+
+      # make mod ready to include in base (non-set-specific) format classes
+      def all_set_format_mod! format_class, mod
+        modules[:base_format][format_class] ||= []
+        modules[:base_format][format_class] << mod
+      end
+
+      # iterate through each format associated with a set
+      def each_format set
+        set_type = set.abstract_set? ? :abstract : :nonbase
+        format_type = "#{set_type}_format".to_sym
+        modules[format_type].each_pair do |format, set_format_mod_hash|
+          next unless (format_mods = set_format_mod_hash[set.shortname])
+          yield format, format_mods
+        end
+      end
+
+      def applicable_format? format, except, only
+        return false if except && Array(except).include?(format)
+        return false if only && !Array(only).include?(format)
+        true
+      end
+
+      # All Format modules are extended with this module in order to support
+      # the basic format API (ok, view definitions.  It's just view
+      # definitions.)
+      module AbstractFormat
+        mattr_accessor :views
+        self.views = {}
+
+        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
+                           lookup_alias_block view, args
+                         end
+          define_method "_view_#{view}", view_block
+        end
+
+        def lookup_alias_block view, args
+          opts = args[0].is_a?(Hash) ? args.shift : { view: args.shift }
+          opts[:mod] ||= self
+          opts[:view] ||= view
+          views[opts[:mod]][opts[:view]] || begin
+            raise "cannot find #{opts[:view]} view in #{opts[:mod]}; " \
+                  "failed to alias #{view} in #{self}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/set/helpers.rb

@@ -0,0 +1,100 @@
+class Card
+  module Set
+    # advanced set module API
+    module Helpers
+      # include a set module and all its format modules
+      # @param [Module] set
+      # @param [Hash] opts choose the formats you want to include
+      # @option opts [Symbol, Array<Symbol>] :only include only these formats
+      # @option opts [Symbol, Array<Symbol>] :except don't include these formats
+      # @example
+      # include_set Type::Basic, except: :css
+      def include_set set, opts={}
+        set_type = set.abstract_set? ? :abstract : :nonbase
+        Card::Set.modules[set_type][set.shortname].each do |set_mod|
+          include set_mod
+        end
+        include_set_formats set, opts
+      end
+
+      # include a format modules of a set
+      # @param [Module] set
+      # @param [Hash] opts choose the formats you want to include
+      # @option opts [Symbol, Array<Symbol>] :only include only these formats
+      # @option opts [Symbol, Array<Symbol>] :except don't include these formats
+      # @example
+      # include_set Type::Basic, except: :css
+      def include_set_formats set, opts={}
+        each_format set do |format, format_mods|
+          match = format.to_s.match(/::(?<format>[^:]+)Format/)
+          format_sym = match ? match[:format] : :base
+          next unless applicable_format?(format_sym, opts[:except], opts[:only])
+          format_mods.each do |format_mod|
+            define_on_format format_sym do
+              include format_mod
+            end
+          end
+        end
+      end
+
+      def ensure_set &block
+        set_module = yield
+      rescue NameError => e
+        if e.message =~ /uninitialized constant (?:Card::Set::)?(.+)$/
+          constant_pieces = Regexp.last_match(1).split('::')
+          constant_pieces.inject(Card::Set) do |set_mod, module_name|
+            set_mod.const_get_or_set module_name do
+              Module.new
+            end
+          end
+        end
+        # try again - there might be another submodule that doesn't exist
+        ensure_set(&block)
+      else
+        set_module.extend Card::Set
+      end
+
+      def attachment name, args
+        include Abstract::Attachment
+        add_attributes name, "remote_#{name}_url".to_sym, :load_from_mod,
+                       :action_id_of_cached_upload, :empty_ok
+        uploader_class = args[:uploader] || FileUploader
+        mount_uploader name, uploader_class
+      end
+
+      def stage_method method, opts={}, &block
+        class_eval do
+          define_method "_#{method}", &block
+          define_method method do |*args|
+            if (error = wrong_stage(opts) || wrong_action(opts[:on]))
+              raise Card::Error, error
+            else
+              send "_#{method}", *args
+            end
+          end
+        end
+      end
+
+      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 = Card::SetPattern.find pattern_name
+                 first + set_class.anchor_parts_count
+               end
+        parts[first..last].join '::'
+      end
+
+      def abstract_set?
+        name =~ /^Card::Set::Abstract::/
+      end
+
+      def all_set?
+        name =~ /^Card::Set::All::/
+      end
+    end
+  end
+end

data/lib/card/set/loader.rb

@@ -0,0 +1,98 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  module Set
+    # 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
+    module Loader
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # Definition Phase
+
+      # each set file calls `extend Card::Set` when loaded
+      def extended mod
+        register_set mod
+      end
+
+      # make the set available for use
+      def register_set set_module
+        if set_module.all_set?
+          # automatically included in Card class
+          modules[:base] << set_module
+        else
+          set_type = set_module.abstract_set? ? :abstract : :nonbase
+          # made ready for dynamic loading via #include_set_modules
+          modules[set_type][set_module.shortname] ||= []
+          modules[set_type][set_module.shortname] << set_module
+        end
+      end
+
+      #
+      #  When a Card application loads, it uses set modules to autogenerate
+      #  tmp files that add module names (Card::Set::PATTERN::ANCHOR) and
+      #  extend the module with Card::Set.
+      #
+
+      #
+      #
+      def write_tmp_file from_file, to_file, rel_path
+        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} ~~~~~~~~~~~
+#{File.read from_file}
+
+# ~~~~~~~~~~~ below autogenerated; above pulled from #{from_file} ~~~~~~~~~~~
+end;end;#{'end;' * name_parts.size}
+EOF
+
+        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
+      def process_base_modules
+        process_base_module_list modules[:base], Card
+        modules[:base_format].each do |format_class, modules_list|
+          process_base_module_list modules_list, format_class
+        end
+        modules.delete :base
+        modules.delete :base_format
+      end
+
+      def process_base_module_list list, klass
+        list.each do |mod|
+          klass.send :include, mod if mod.instance_methods.any?
+          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 hash
+        end
+      end
+
+      def clean_empty_module_from_hash hash
+        hash.each do |mod_name, modlist|
+          modlist.delete_if { |x| x.instance_methods.empty? }
+          hash.delete mod_name if modlist.empty?
+        end
+      end
+    end
+  end
+end

data/lib/card/set/trait.rb

@@ -1,6 +1,5 @@
 class Card
   module Set
-    #
     # ActiveCard support: accessing plus cards as attributes
     module Trait
       def card_accessor *args
@@ -20,6 +19,11 @@ class Card
 
       private
 
+      def add_attributes *args
+        Card.set_specific_attributes ||= []
+        Card.set_specific_attributes += args.map(&:to_s)
+      end
+
       def get_traits mod
         Card::Set.traits ||= {}
         Card::Set.traits[mod] || Card::Set.traits[mod] = {}
@@ -27,7 +31,6 @@ class Card
 
       def add_traits args, options
         mod = self
-        # raise "Can't define card traits on all set" if mod == Card
         mod_traits = get_traits mod
 
         new_opts = options[:type] ? { type: options[:type] } : {}

data/lib/card/subcards.rb

@@ -45,22 +45,14 @@ class Card
     end
 
     def remove name_or_card
-      key = case name_or_card
-            when Card
-              name_or_card.key
-            when Symbol
-              fetch_subcard(name_or_card).key
-            else
-              name_or_card.to_name.key
-            end
-
-      key = absolutize_subcard_name(key).key unless @keys.include?(key)
+      key = subcard_key name_or_card
+      return unless @keys.include? key
       @keys.delete key
       removed_card = fetch_subcard key
       if removed_card.current_action
         removed_card.current_action.delete
       end
-      Card::DirectorRegister.delete removed_card.director
+      Card::DirectorRegister.deep_delete removed_card.director
       Card.cache.soft.delete key
       removed_card
     end
@@ -188,6 +180,19 @@ class Card
 
     private
 
+    def subcard_key name_or_card
+      key = case name_or_card
+            when Card
+              name_or_card.key
+            when Symbol
+              fetch_subcard(name_or_card).key
+            else
+              name_or_card.to_name.key
+            end
+      key = absolutize_subcard_name(key).key unless @keys.include?(key)
+      key
+    end
+
     def fetch_subcard key
       Card.fetch key, local_only: true, new: {}
     end
@@ -216,6 +221,23 @@ class Card
       end
     end
 
+    # TODO: this method already exists as card instance method in
+    #   tracked_attributes.rb. Find a place for it where its accessible
+    #   for both. There is one important difference. The keys are symbols
+    # here instead of strings
+    def extract_subcard_args! args
+      subcards = args.delete(:subcards) || {}
+      if (subfields = args.delete(:subfields))
+        subfields.each_pair do |key, value|
+          subcards[cardname.field(key)] = value
+        end
+      end
+      args.keys.each do |key|
+        subcards[key] = args.delete(key) if key =~ /^\+/
+      end
+      subcards
+    end
+
     def new_by_attributes name, attributes={}
       absolute_name = absolutize_subcard_name name
       if absolute_name.field_of?(@context_card.name) &&
@@ -224,9 +246,13 @@ class Card
         new_by_card left_card
         left_card.new_by_attributes absolute_name, attributes
       else
+
+        subcard_args = extract_subcard_args! attributes
         card = Card.assign_or_initialize_by absolute_name.s, attributes,
                                             local_only: true
-        new_by_card card
+        subcard = new_by_card card
+        card.subcards.add subcard_args
+        subcard
       end
     end
 

data/lib/cardio.rb

@@ -96,7 +96,7 @@ module Cardio
     end
 
     def set_mod_paths
-      each_mod_path { |mod_path| add_initializers mod_path }
+      each_mod_path { |mod_path| add_initializers File.join(mod_path, '*') }
     end
 
     def add_initializers dir

data/lib/generators/card/migration/templates/card_migration.erb

@@ -3,7 +3,7 @@
 class <%= migration_class_name %> < <%= @migration_parent_class %>
   def up
 <% if @migration_action == 'import' -%>
-    import_json '<%= @json_filename %>'
+    import_cards '<%= @json_filename %>'
 <% end -%>
   end
 end