card 1.101.2 → 1.102.0

data/lib/generators/card/set/templates/set_spec_template.erb

@@ -1,5 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::<%= set_pattern.camelize %>::<%= anchors.map(&:camelize).join('::') %> do
-
-end

data/lib/generators/card/set/templates/set_template.erb

@@ -1 +0,0 @@
-

data/lib/generators/card/template/USAGE

@@ -1,10 +0,0 @@
-Description:
-    Generates a haml template.
-
-Example:
-    decko generate card:template standard type tshirt core
-
-    This will create:
-        mod/standard/template/type/tshirt/core.haml
-
-

data/lib/generators/card/template/template_generator.rb

@@ -1,46 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require "generators/card"
-
-class Card
-  module Generators
-    # A decko generator that creates a haml template for a view.
-    # Run "decko generate card:template" to get usage information.
-    class TemplateGenerator < NamedBase
-      source_root File.expand_path("../templates", __FILE__)
-
-      argument :set_pattern, required: true
-      argument :anchors, required: true, type: :array
-      class_option "core", type: :boolean, aliases: "-c",
-                           default: false, group: :runtime,
-                           desc: "create haml template in Card gem"
-
-      def create_files
-        with_valid_arguments do
-          template "haml_template.erb", set_path
-        end
-      end
-
-      private
-
-      def with_valid_arguments
-        if !Dir.exist? mod_path
-          warn "invalid mod name: #{file_name}. Directory #{mod_path} doesn't exist."
-        # Card.set_patterns not loaded at this point
-        elsif !%w[self type right type_plus_right ltype_rtype rstar star
-                  type all_plus all].include? set_pattern
-          warn "invalid set pattern: #{set_pattern}"
-        else
-          yield
-        end
-      end
-
-      def set_path
-        filename = "#{anchors.last}.haml"
-        dirs = anchors[0..-2]
-        path_parts = [mod_path, "template", set_pattern, dirs, filename]
-        File.join(*path_parts.compact)
-      end
-    end
-  end
-end

data/lib/generators/card/template/templates/haml_template.erb

@@ -1 +0,0 @@
-

data/mod/admin/set/self/trash.rb

@@ -1,63 +0,0 @@
-format :html do
-  view :core do
-    rows = trashed_cards.map { |tc| trash_table_row(tc) }
-    output [
-      restored,
-      (empty_trash_link if rows.present?),
-      table(rows, header: ["card", "deleted", "by", ""])
-    ]
-  end
-
-  def trashed_cards
-    Card.where(trash: true).order(updated_at: :desc)
-  end
-
-  def trash_table_row card
-    [
-      card.name,
-      "#{time_ago_in_words(card.updated_at)} ago",
-      Card[card.updater_id].name,
-      "#{history_link(card)} | #{restore_link(card)}"
-    ]
-  end
-
-  def restored
-    return unless (res_id = Env.params[:restore]) &&
-                  (res_card = Card[res_id.to_i])
-    alert :success, true do
-      wrap_with(:h5, "restored") + subformat(res_card).render_bar
-    end
-  end
-
-  def empty_trash_link
-    wrap_with(
-      :p,
-      button_link("empty trash",
-                  btn_type: :default,
-                  path: { mark: :admin, action: :update, task: :empty_trash,
-                          success: { id: "~#{card.id}" } },
-                  "data-confirm" => "Are you sure you want to delete "\
-                                    "all cards in the trash?")
-    )
-  end
-
-  def history_link trashed_card
-    link_to_card trashed_card, "history",
-                 path: { view: :history, look_in_trash: true }
-  end
-
-  def restore_link trashed_card
-    before_delete = trashed_card.actions[-2]
-    link_to "restore", method: :post,
-                       rel: "nofollow",
-                       remote: true,
-                       class: "slotter",
-                       path: { id: trashed_card.id,
-                               view: :open,
-                               look_in_trash: true,
-                               action: :update,
-                               restore: trashed_card.id,
-                               action_ids: [before_delete],
-                               success: { id: "~#{card.id}" } }
-  end
-end

data/mod/core/set/all/actify.rb

@@ -1,68 +0,0 @@
-def act options={}, &block
-  if act_card
-    add_to_act options, &block
-  else
-    start_new_act &block
-  end
-end
-
-def act_card
-  Card::Director.act_card
-end
-
-def act_card?
-  self == act_card
-end
-
-module ClassMethods
-  def create! opts
-    card = Card.new opts
-    card.save!
-    card
-  end
-
-  def create opts
-    card = Card.new opts
-    card.save
-    card
-  end
-end
-
-def save! *args
-  as_subcard = args.first&.delete :as_subcard
-  act(as_subcard: as_subcard) { super }
-end
-
-def save(*)
-  act { super }
-end
-
-def valid?(*)
-  act(validating: true) { super }
-end
-
-def update *args
-  act { super }
-end
-
-def update! *args
-  act { super }
-end
-
-alias_method :update_attributes, :update
-alias_method :update_attributes!, :update!
-
-private
-
-def start_new_act
-  self.director = nil
-  Director.run_act(self) do
-    run_callbacks(:act) { yield }
-  end
-end
-
-def add_to_act options={}
-  director.appoint self unless @director
-  director.head = true unless options[:validating] || options[:as_subcard]
-  yield
-end

data/mod/core/set/all/cache.rb

@@ -1,109 +0,0 @@
-module ClassMethods
-  def retrieve_from_cache cache_key, local_only=false
-    return unless cache
-    local_only ? cache.soft.read(cache_key) : cache.read(cache_key)
-  end
-
-  def retrieve_from_cache_by_id id, local_only=false
-    key = Card::Lexicon.name(id)&.key
-    return unless key.present?
-
-    retrieve_from_cache key, local_only if key
-  end
-
-  def retrieve_from_cache_by_key key, local_only=false
-    retrieve_from_cache key, local_only
-  end
-
-  def write_to_cache card, local_only=false
-    if local_only
-      write_to_soft_cache card
-    elsif cache
-      cache.write card.key, card
-    end
-  end
-
-  def write_to_soft_cache card
-    return unless cache
-    cache.soft.write card.key, card
-  end
-
-  def expire name
-    key = name.to_name.key
-    return unless (card = Card.cache.read key)
-    card.expire
-  end
-end
-
-def update_soft_cache
-  Card.write_to_soft_cache self
-end
-
-def expire_pieces
-  name.piece_names.each do |piece|
-    Card.expire piece
-  end
-end
-
-def expire cache_type=nil
-  return unless (cache_class = cache_class_from_type cache_type)
-  expire_views
-  expire_names cache_class
-  expire_id cache_class
-end
-
-def cache_class_from_type cache_type
-  cache_type ? Card.cache.send(cache_type) : Card.cache
-end
-
-def view_cache_clean?
-  !db_content_changed?
-end
-
-def view_cache_keys
-  @view_cache_keys ||= hard_read_view_cache_keys || []
-end
-
-def ensure_view_cache_key cache_key
-  return if view_cache_keys.include? cache_key
-
-  @view_cache_keys << cache_key
-  hard_write_view_cache_keys
-end
-
-def hard_read_view_cache_keys
-  Card.cache.hard&.read_attribute key, :view_cache_keys
-end
-
-def hard_write_view_cache_keys
-  # puts "WRITE VIEW CACHE KEYS (#{name}): #{view_cache_keys}"
-  Card.cache.hard&.write_attribute key, :view_cache_keys, view_cache_keys
-end
-
-def expire_views
-  # puts "EXPIRE VIEW CACHE (#{name}): #{view_cache_keys}"
-  return unless view_cache_keys.present?
-  Array.wrap(view_cache_keys).each do |view_cache_key|
-    Card::View.cache.delete view_cache_key
-  end
-  @view_cache_keys = []
-  hard_write_view_cache_keys
-end
-
-def expire_names cache
-  [name, name_before_act].uniq.each do |name_version|
-    expire_name name_version, cache
-  end
-end
-
-def expire_name name_version, cache
-  return unless name_version.present?
-  key_version = name_version.to_name.key
-  return unless key_version.present?
-  cache.delete key_version
-end
-
-def expire_id cache
-  return unless id.present?
-  cache.delete "~#{id}"
-end

data/mod/core/set/all/contextual_content.rb

@@ -1,28 +0,0 @@
-def context_card
-  @context_card || self
-end
-
-def with_context context_card
-  old_context = @context_card
-  @context_card = context_card if context_card
-  yield
-ensure
-  @context_card = old_context
-end
-
-format do
-  def context_card
-    card.context_card
-  end
-
-  def with_context context_card
-    card.with_context context_card do
-      yield
-    end
-  end
-
-  def contextual_content context_card, options={}
-    view = options.delete(:view) || :core
-    with_context(context_card) { render! view, options }
-  end
-end

data/mod/core/set/all/event_conditions.rb

@@ -1,172 +0,0 @@
-Card.action_specific_attributes +=
-  %i[skip_hash full_skip_hash trigger_hash full_trigger_hash]
-
-def event_applies? event
-  return unless set_condition_applies? event.set_module, event.opts[:changing]
-
-  Card::Set::Event::CONDITIONS.all? do |key|
-    send "#{key}_condition_applies?", event, event.opts[key]
-  end
-end
-
-# force skipping this event for all cards in act
-def skip_event! *events
-  @full_skip_hash = nil
-  events.each do |event|
-    act_skip_hash[event.to_s] = :force
-  end
-end
-
-# force skipping this event for this card only
-def skip_event_in_action! *events
-  events.each do |event|
-    full_skip_hash[event.to_s] = :force
-  end
-end
-
-# force triggering this event (when it comes up) for all cards in act
-def trigger_event! *events
-  @full_trigger_hash = nil
-  events.each do |event|
-    act_trigger_hash[event.to_s] = :force
-  end
-end
-
-# force triggering this event (when it comes up) for this card only
-def trigger_event_in_action! *events
-  events.each do |event|
-    full_trigger_hash[event.to_s] = :force
-  end
-end
-
-# hash form of raw skip setting, eg { "my_event" => true }
-def skip_hash
-  @skip_hash ||= hash_with_value skip, true
-end
-
-def trigger_hash
-  @trigger_hash ||= hash_with_value trigger, true
-end
-
-private
-
-def set_condition_applies? set_module, old_sets
-  return true if set_module == Card
-
-  set_condition_card(old_sets).singleton_class.include? set_module
-end
-
-def on_condition_applies? _event, actions
-  actions = Array(actions).compact
-  actions.empty? ? true : actions.include?(action)
-end
-
-# if changing name/type, the old card has no-longer-applicable set modules, so we create
-# a new card to determine whether events apply.
-# (note: cached condition card would ideally be cleared after all
-# conditions are reviewed)
-# @param old_sets [True/False] whether to use the old_sets
-def set_condition_card old_sets
-  return self if old_sets || no_current_action?
-  @set_condition_card ||=
-    updating_sets? ? set_condition_card_with_new_set_modules : self
-end
-
-# existing card is being changed in a way that alters its sets
-def updating_sets?
-  action == :update && real? && (type_id_is_changing? || name_is_changing?)
-end
-
-# prevents locking in set_condition_card
-def no_current_action?
-  return false if @current_action
-
-  @set_condition_card = nil
-  true
-end
-
-def set_condition_card_with_new_set_modules
-  cc = Card.find id
-  cc.name = name
-  cc.type_id = type_id
-  cc.include_set_modules
-end
-
-def changed_condition_applies? _event, db_columns
-  return true unless action == :update
-  db_columns = Array(db_columns).compact
-  return true if db_columns.empty?
-  db_columns.any? { |col| single_changed_condition_applies? col }
-end
-alias_method :changing_condition_applies?, :changed_condition_applies?
-
-def when_condition_applies? _event, block
-  case block
-  when Proc then block.call(self)
-  when Symbol then send block
-  else true
-  end
-end
-
-# "applies always means event can run
-# so if skip_condition_applies?, we do NOT skip
-def skip_condition_applies? event, allowed
-  return true unless (val = full_skip_hash[event.name.to_s])
-
-  allowed ? val.blank? : (val != :force)
-end
-
-def trigger_condition_applies? event, required
-  return true unless required
-
-  full_trigger_hash[event.name.to_s].present?
-end
-
-def single_changed_condition_applies? db_column
-  return true unless db_column
-  send "#{db_column}_is_changing?"
-end
-
-def wrong_stage opts
-  return false if director.stage_ok? opts
-  if !stage
-    "phase method #{method} called outside of event phases"
-  else
-    "#{opts.inspect} method #{method} called in stage #{stage}"
-  end
-end
-
-def wrong_action actn
-  return false if on_condition_applies?(nil, actn)
-  "on: #{actn} method #{method} called on #{action}"
-end
-
-def full_skip_hash
-  @full_skip_hash ||= act_skip_hash.merge skip_in_action_hash
-end
-
-def act_skip_hash
-  (act_card || self).skip_hash
-end
-
-def skip_in_action_hash
-  hash_with_value skip_in_action, true
-end
-
-def full_trigger_hash
-  @full_trigger_hash ||= act_trigger_hash.merge trigger_in_action_hash
-end
-
-def trigger_in_action_hash
-  hash_with_value trigger_in_action, true
-end
-
-def act_trigger_hash
-  (act_card || self).trigger_hash
-end
-
-def hash_with_value array, value
-  Array.wrap(array).each_with_object({}) do |event, hash|
-    hash[event.to_s] = value
-  end
-end