card 1.103.3 → 1.104.2

data/lib/card/set/pattern.rb

@@ -1,54 +1,65 @@
 class Card
   module Set
-    class Pattern
+    # Each deck can have countless sets of cards, each of which follows one of a small
+    # list of patterns. This module provides methods for managing those patterns.
+    module Pattern
       class << self
+        # Pattern classes all the patterns except for Abstract.
+        # They are concrete because they are defined on a set of cards
+        # (while abstract sets must be included on them explicitly).
+        #
+        # @return [Array <Class>]
         def concrete
           @concrete ||= []
         end
 
+        # Pattern classes that can be reloaded without reloading Card
+        # (everything but all)
+        # @return [Array <Class>]
+        def reloadables
+          concrete - [Set::All] + Abstract
+        end
+
+        # remove reloadable sets and prepare for reloading
         def reset
           reloadables.each do |set_pattern|
             Set.const_remove_if_defined set_pattern.to_s.split("::").last
           end
-          @concrete = []
-          @card_keys = @codes = @nonbase_codes = @ids = nil
-        end
-
-        def reloadables
-          r = concrete.push(Abstract)
-          r.delete Set::All
-          r
+          @concrete = @codes = @type_assigner_codes = @nonbase_codes = @ids = nil
         end
 
+        # finds pattern class associated with codename
+        # e.g. find(:type) returns `Card::Set::Type`
+        #
+        # @return [Class] pattern class
         def find pattern_code
           concrete.find { |sub| sub.pattern_code == pattern_code }
         end
 
-        def card_keys
-          @card_keys ||=
-            concrete.each_with_object({}) do |set_pattern, hash|
-              hash[set_pattern.pattern_id.cardname.key] = true
-            end
+        # list of codenames of pattern cards
+        # @return [Array <Symbol>]
+        def codes
+          @codes ||= concrete.map(&:pattern_code).to_set
         end
 
+        # list of lists of codenames in pattern load order
+        # @return [Array <Array <Symbol>>]
         def grouped_codes with_all: true
           g = [[:abstract], nonbase_codes.reverse]
           g.unshift [:all] if with_all
           g
         end
 
+        # list of ids of pattern cards
+        # @return [Array <Integer>]
         def ids
           @ids ||= concrete.map(&:pattern_id)
         end
 
         private
 
-        def codes
-          @codes ||= concrete.map(&:pattern_code)
-        end
-
         def nonbase_codes
-          @nonbase_codes ||= codes.tap { |list| list.delete :all }
+          @nonbase_codes ||= codes.to_a - [:all]
         end
       end
     end

data/lib/card/set/trait.rb

@@ -1,6 +1,6 @@
 class Card
   module Set
-    # ActiveCard support: accessing plus cards as attributes
+    # accessing plus cards as attributes
     module Trait
       def card_accessor *args
         options = args.extract_options!
@@ -45,11 +45,25 @@ class Card
           define_trait_card trait, new_opts
           define_trait_reader trait if options[:reader]
           define_trait_writer trait if options[:writer]
+          assign_trait_type trait, options[:type]
 
           mod_traits[trait.to_sym] = options
         end
       end
 
+      def assign_trait_type trait, type
+        return unless type && (parts = trait_module_key_parts trait)
+        assign_type type, normalize_const(parts)
+      end
+
+      def trait_module_key_parts trait
+        if all_set?
+          [:right, trait]
+        elsif type_set?
+          [:type_plus_right, set_name_parts.last, trait]
+        end
+      end
+
       def new_trait_opts options
         %i[type default_content].each_with_object({}).each do |key, hash|
           hash[key] = options[key] if options[key]
@@ -58,6 +72,7 @@ class Card
 
       def define_trait_card trait, opts
         define_method "#{trait}_card" do
+          # opts = opts.clone.merge supercard: card
           fetch trait.to_sym, new: opts.clone, eager_cache: true
         end
       end

data/lib/card/set/type.rb

@@ -1,6 +1,9 @@
 class Card
   module Set
     class Type < Pattern::Base
+      cattr_accessor :assignment
+      self.assignment = {}
+
       def initialize card
         super
         # support type inheritance

data/lib/card/subcards/add.rb

@@ -53,9 +53,7 @@ class Card
 
       def new_by_card card
         card.supercard = @context_card
-        if !card.name.simple? && card.name.field_of?(@context_card.name)
-          card.superleft = @context_card
-        end
+        card.update_superleft card.name
         @keys << card.key
         Card.write_to_soft_cache card
         card.director = @context_card.director.subdirectors.add card

data/lib/card/subcards/all.rb

@@ -2,18 +2,6 @@ class Card
   class Subcards
     # subcard-related Card instance methods
     module All
-      def subcard card_name
-        subcards.card card_name
-      end
-
-      def subfield field_name
-        subcards.field field_name
-      end
-
-      def field? tag
-        field(tag) || subfield(tag)
-      end
-
       def subcards
         @subcards ||= Card::Subcards.new self
       end
@@ -22,66 +10,50 @@ class Card
         subcards.present?
       end
 
-      def expire_subcards
-        subcards.clear
-      end
-
-      # phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
-      # TODO: handle differently in different stages
-      def add_subcard name_or_card, args={}
-        subcards.add name_or_card, args
-      end
-      alias_method :attach_subcard, :add_subcard
-
-      def add_subcard! name_or_card, args={}
-        subcard = subcards.add name_or_card, args
-        subcard.director.reset_stage
-        subcard
+      def subcard card_name, args={}
+        if (sc = subcards.card card_name)
+          sc.assign_attributes args
+          sc
+        else
+          subcards.add card_name, args
+        end
       end
-      alias_method :attach_subcard!, :add_subcard!
 
-      # phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
-      def attach_subfield name_or_card, args={}
-        subcards.add_field name_or_card, args
+      def subcard_content card_name
+        subcards.card(card_name)&.content
       end
-      alias_method :add_subfield, :attach_subfield
 
-      def attach_subfield! name_or_card, args={}
-        subcard = subcards.add_field name_or_card, args
-        subcard.director.reset_stage
-        subcard
+      def subcard? card_name
+        subcards.card(card_name).present?
       end
 
-      def detach_subcard name_or_card
-        subcards.remove name_or_card
+      def subfield field_name, args={}
+        if (sf = subcards.field field_name)
+          sf.assign_attributes args
+          sf
+        else
+          subcards.add_field field_name, args
+        end
       end
-      alias_method :remove_subcard, :detach_subcard
 
-      def detach_subfield name_or_card
-        subcards.remove_field name_or_card
+      def subfield_content field_name
+        subcards.field(field_name)&.content
       end
-      alias_method :remove_subfield, :detach_subfield
 
-      def clear_subcards
-        subcards.clear
+      def subfield? field_name
+        subcards.field(field_name).present?
       end
 
-      # ensures subfield is present
-      # does NOT override subfield content if already present
-      def ensure_subfield field_name, args={}
-        if subfield_present? field_name
-          subfield field_name
-        else
-          add_subfield field_name, args
-        end
+      def field? tag
+        field(tag) || subfield?(tag)
       end
 
-      def subfield_present? field_name
-        subfield(field_name)&.content&.present?
+      def drop_subcard name_or_card
+        subcards.remove name_or_card
       end
 
-      def deep_clear_subcards
-        subcards.deep_clear
+      def drop_subfield name_or_card
+        subcards.remove_field name_or_card
       end
 
       def handle_subcard_errors
@@ -93,6 +65,8 @@ class Card
         end
       end
 
+      private
+
       def subcard_error subcard, error
         msg = error.message
         msg = "#{error.attribute} #{msg}" unless %i[content abort].member? error.attribute

data/lib/card/view/options.rb

@@ -40,6 +40,7 @@ class Card
         heir: [
           :main,           # format object is page's "main" object (Boolean)
           :home_view,      # view for slot to return to when no view specified
+          :buttons_view,
           :edit_structure, # use a different structure for editing (Array)
           :cql,            # contextual cql alterations for search cards (Hash)
           :action_id,      # a Card::Action id (Integer)
@@ -50,20 +51,21 @@ class Card
           :help,           # cue text when editing
           :structure,      # overrides the content of the card
           :title,          # overrides the name of the card
-          :variant,        # override the canonical version of the name with a different
-          # variant
+          :variant,        # override the standard name with a different variant
           :input_type,     # inline_nests makes a form within standard content (Symbol)
           :type,           # set the default type of new cards
           :size,           # set an image size
-          # (also used for character limit in one_line_content)
-          :params,         # parameters for add button.  deprecated!
+          #                    (also used for character limit in one_line_content)
           :items,          # options for items (Hash)
           :cache,          # change view cache behaviour
           #                    (Symbol<:always, :standard, :never>)
           :edit,           # edit mode
           #                    (Symbol<:inline, :standard, :full>)
           :separator,      # item separator in certain lists
-          :filter
+          :filter,
+
+          # DEPRECATED
+          :params          # parameters for add button
         ],
         none: [
           :skip_perms,     # do not check permissions for this view (Boolean)

data/lib/card/view/permission.rb

@@ -34,18 +34,11 @@ class Card
       def alter_unknown
         return if card.known?
 
-        unknown_from_options || unknown_from_view_definition
-      end
-
-      def unknown_from_options
-        unknown.to_sym if unknown.present?
-      end
-
-      def unknown_from_view_definition
-        setting = setting(:unknown)
-        return if setting == true # use original view
+        unknown_setting = setting :unknown
+        return if unknown_setting&.to_s == "true" # requested view supports unknown
 
-        setting.is_a?(Symbol) ? setting : format.view_for_unknown(requested_view)
+        configured_view = (unknown || unknown_setting)&.to_sym
+        format.view_for_unknown configured_view
       end
 
       def denial

data/lib/cardio/cli.rb

@@ -1,4 +1,5 @@
 require "rbconfig"
+require "colorize"
 require "cardio/script_loader"
 
 # If we are inside a Decko application this method performs an exec and thus

data/lib/cardio/commands/custom.rb

@@ -0,0 +1,60 @@
+require "optparse"
+require "cardio/version"
+
+module Cardio
+  class Commands
+    module Custom
+      private
+
+      def run_new
+        if !["-h", "--help"].intersection(args).empty?
+          require "cardio/commands/application"
+        else
+          puts "Can't initialize a new deck within the directory of another, " \
+               "please change to a non-deck directory first.\n"
+          puts "Type '#{gem}' for help."
+          exit 1
+        end
+      end
+
+      def run_version
+        puts "Card #{Version.card_release}".light_cyan
+      end
+
+      def run_rspec
+        require "cardio/commands/rspec_command"
+        RspecCommand.new(args).run
+      end
+
+      # def run_jasmine
+      #   require "cardio/commands/rake_command"
+      #   RakeCommand.new("spec:javascript", envs: "test").run
+      # end
+
+      def run_help
+        puts "Usage:"
+        puts "  #{gem} COMMAND [OPTIONS]".green
+        puts
+        puts "Run commands with -h (or --help) for more info."
+
+        %i[shark monkey].each do |group|
+          puts
+          puts "For " + "#{group}s".yellow + ":"
+          map.each do |command, conf|
+            next unless conf[:group] == group
+            puts command_help(command, conf)
+          end
+          puts
+        end
+      end
+
+      private
+
+      # formats command string for help text
+      def command_help command, conf
+        alt = conf[:alias] ? "(or #{conf[:alias]})" : ""
+        "    " + command.to_s.ljust(12).light_cyan + alt.ljust(10) + conf[:desc]
+      end
+    end
+  end
+end

data/lib/cardio/commands/rake_command/parser.rb

@@ -1,50 +1,51 @@
 # -*- encoding : utf-8 -*-
 
-require "optparse"
-
-module Cardio
-  class Commands
-    class RakeCommand
-      # parse decko/card -specific options for rake
-      class Parser < OptionParser
-        ONS = {
-          production: {
-            desc: "production database (default)"
-          },
-          test: {},
-          development: {},
-          all: {
-            desc: "production, test, and development database",
-            envs: %w[production development test]
-          }
-        }.freeze
-
-        def initialize command, opts
-          super() do |parser|
-            parser.banner = "Usage: decko #{command} [options]\n\n" \
-                            "Run decko:#{command} task on the production "\
-                            " database specified in config/database.yml\n\n"
-            parser_ons parser, command do |env_array|
-              opts[:envs] = env_array
-            end
-          end
-        end
-
-        def parser_ons parser, command
-          ONS.each do |env, vals|
-            parser.on(*parser_on_opts(env, command, vals[:desc])) do
-              yield (vals[:envs] || [env.to_s])
-            end
-          end
-        end
-
-        def parser_on_opts env, command, desc
-          main = "--#{env}"
-          short = "-#{env.to_s[0]}"
-          desc ||= "#{env} database"
-          [main, short, "#{command} #{desc}"]
-        end
-      end
-    end
-  end
-end
+# require "optparse"
+#
+# module Cardio
+#   class Commands
+#     class RakeCommand
+#       # parse decko/card -specific options for rake
+#       class Parser < OptionParser
+#         ONS = {
+#           production: {
+#             desc: "production database (default)"
+#           },
+#           test: {},
+#           development: {},
+#           all: {
+#             desc: "production, test, and development database",
+#             envs: %w[production development test]
+#           }
+#         }.freeze
+#
+#         def initialize command, opts
+#           super() do |parser|
+#             parser.banner =
+#               "Usage:\n" +
+#                 "  #{Commands.gem} #{command} [options]".green +
+#                 "\n\nRuns `rake #{Commands.gem}:#{command}` task."
+#             parser_ons parser, command do |env_array|
+#               opts[:envs] = env_array
+#             end
+#           end
+#         end
+#
+#         def parser_ons parser, command
+#           ONS.each do |env, vals|
+#             parser.on(*parser_on_opts(env, command, vals[:desc])) do
+#               yield (vals[:envs] || [env.to_s])
+#             end
+#           end
+#         end
+#
+#         def parser_on_opts env, command, desc
+#           main = "--#{env}"
+#           short = "-#{env.to_s[0]}"
+#           desc ||= "#{env} database"
+#           [main, short, "#{command} #{desc}"]
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/cardio/commands/rake_command.rb

@@ -1,24 +1,25 @@
 require File.expand_path("command", __dir__)
-# require "pry"
 
 module Cardio
   class Commands
     # enhance standard rake command with some decko/card -specific options
     class RakeCommand < Command
-      def initialize rake_task, args={}
-        @task = rake_task
-        opts = {}
-        if args.is_a? Array
-          Parser.new(rake_task, opts).parse!(args)
-        else
-          opts = args
-        end
-        @envs = Array(opts[:envs])
+      def initialize gem, command, args={}
+        @command = command
+        @task = "#{gem}:#{command}"
+        @args = [args].flatten
+        # opts = {}
+        # if args.is_a? Array
+        #   Parser.new(rake_task, opts).parse!(args)
+        # else
+        #   opts = args
+        # end
+        # @envs = Array(opts[:envs])
       end
 
       def run
         commands.each do |cmd|
-          puts cmd
+          # puts cmd
           # exit_with_child_status cmd
 
           result = `#{cmd}`
@@ -30,14 +31,15 @@ module Cardio
 
       def commands
         task_cmd = "bundle exec rake #{@task}"
+        task_cmd += " -- #{@args.join ' '}" if !@args.empty?
         return [task_cmd] if !@envs || @envs.empty?
 
-        @envs.map do |env|
-          "env RAILS_ENV=#{env} #{task_cmd}"
-        end
+        # @envs.map do |env|
+        #   "env RAILS_ENV=#{env} #{task_cmd}"
+        # end
       end
     end
   end
 end
 
-require File.expand_path("rake_command/parser", __dir__)
+# require File.expand_path("rake_command/parser", __dir__)

data/lib/cardio/commands/rspec_command.rb

@@ -24,6 +24,8 @@ module Cardio
       end
 
       def coverage
+        return if @opts[:simplecov]
+
         # no coverage if rspec was started with file argument
         return unless @opts[:files] || @rspec_args.any?