card 1.101.1 → 1.101.6

data/mod/core/spec/set/all/rules_spec.rb

@@ -1,100 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::Rules do
-  before do
-    Card::Auth.signin Card::WagnBotID
-  end
-
-  describe "setting data setup" do
-    it "makes Set of +*type" do
-      Card.create! name: "SpeciForm", type: "Cardtype"
-      expect(Card.create!(name: "SpeciForm+*type").type_code).to eq(:set)
-    end
-  end
-
-  describe "#rule" do
-    it "retrieves Set based value" do
-      Card.create name: "Book+*type+*help", content: "authorize"
-      help_rule = Card.new(type: "Book").rule(:help)
-      expect(help_rule).to eq("authorize")
-    end
-
-    it "retrieves single values" do
-      Card.create! name: "banana+*self+*help", content: "pebbles"
-      expect(Card["banana"].rule(:help)).to eq("pebbles")
-    end
-  end
-
-  describe "#setting_codenames_by_group" do
-    before do
-      @pointer_settings = %i[options options_label input]
-    end
-    it "doesn't fail on nonexistent trunks" do
-      codenames = Card.new(name: "foob+*right").setting_codenames_by_group
-      expect(codenames.class).to eq(Hash)
-    end
-
-    it "returns universal setting names for non-pointer set" do
-      skip "Different api, we should just put the tests in a new spec for that"
-      snbg = Card.fetch("*star").setting_codenames_by_group
-      # warn "snbg #{snbg.class} #{snbg.inspect}"
-      expect(snbg.keys.length).to eq(4)
-      expect(snbg.keys.first).to be_a Symbol
-      expect(snbg.keys.member?(:pointer)).not_to be_truthy
-    end
-  end
-
-  describe "user specific rules" do
-    before do
-      Card::Auth.signin "Joe User"
-    end
-
-    it "user rule is recognized as rule" do
-      Card::Auth.as_bot do
-        card = Card.create name: "Book+*type+Joe User+*follow",
-                           content: "[[*always]]"
-        expect(card.is_rule?).to be_truthy
-      end
-    end
-
-    it "retrieves Set based value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+Joe User+*follow", content: "[[*always]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[*always]]")
-    end
-
-    it "retrieves user independent Set based value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+*all+*follow", content: "[[Home]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[Home]]")
-    end
-
-    it "uses *all user rule when no super.s"
-
-    it "user-specific value overwrites user-independent value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+Joe User+*follow", content: "[[*never]]"
-        Card.create name: "Book+*type+*all+*follow", content: "[[*always]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[*never]]")
-    end
-
-    describe "#all_user_ids_with_rule_for" do
-      it "returns all user with values for the given Set and rule" do
-        Card::Auth.as_bot do
-          Card.create(name: "Book+*type+Joe User+*follow", content: "[[Home]]")
-          Card::Auth.signin "Joe Admin"
-          Card.create(name: "Book+*type+Joe Admin+*follow", content: "[[Home]]")
-          user_ids = Card::Rule.all_user_ids_with_rule_for(
-            Card.fetch("Book+*type"), :follow
-          )
-          expect(user_ids.sort).to eq(
-            [Card["Joe User"].id, Card["Joe Admin"].id].sort
-          )
-        end
-      end
-    end
-  end
-end

data/mod/core/spec/set/all/subcards_spec.rb

@@ -1,102 +0,0 @@
-RSpec.describe Card::Set::All::Subcards do
-  let(:create_card) { Card.create!(name: "main card") }
-  let(:create_card_with_subcards) do
-    Card.create name: "main card",
-                subcards: { "11" => { subcards: { "111" => "A" } },
-                            "12" => { subcards: { "121" => "A" } } }
-  end
-
-  class Card
-    def __current_trans
-      @current_trans = ActiveRecord::Base.connection.current_transaction
-    end
-
-    def __record_names reset=false
-      trans = @current_trans && !reset ? @current_trans : __current_trans
-      trans.records&.map { |r| r.try :name }&.compact
-    end
-  end
-
-  describe "add subcards" do
-    context "when in integrate stage" do
-      context "with default subcard handling" do
-        it "processes all cards in one transaction" do
-          with_test_events do
-            test_event :validate, on: :create, for: "main card" do
-              add_subcard("sub card")
-            end
-
-            test_event :finalize, on: :create, for: "main card" do
-              expect(__record_names).to eq ["main card", "sub card"]
-            end
-
-            create_card
-          end
-        end
-      end
-
-      context "with delayed jobs" do
-        before { Cardio.delaying! }
-        after { Cardio.delaying! :off }
-
-        context "with serial subcard handling" do
-          it "director.delay! processes subcards in separate transaction" do
-            with_test_events do
-              test_event :validate, on: :create, for: "main card" do
-                sc = add_subcard("sub card")
-                sc.director.delay!
-              end
-
-              test_event :finalize, on: :create, for: "main card" do
-                expect(__record_names(true)).to eq ["main card"]
-                expect(subcard("sub card").director.stage).to eq nil
-              end
-
-              test_event :integrate, on: :create, for: "main card" do
-                expect(__record_names(true)).to eq(nil)
-                expect(subcard("sub card").director.stage).to eq nil
-              end
-
-              test_event :finalize, on: :create, for: "sub card" do
-                expect(__record_names(true)).to eq ["sub card"]
-              end
-
-              test_event :integrate_with_delay, on: :create do
-                expect(__record_names(true)).to eq(nil)
-              end
-              create_card
-              expect(Delayed::Worker.new.work_off).to eq [2, 0]
-              expect(Card["sub card"]).to be_instance_of(Card)
-            end
-          end
-        end
-      end
-
-      describe "in integrate_with_delay stage" do
-        it "processes cards not in the same transaction" do
-          with_test_events do
-            test_event :integrate_with_delay, on: :create, for: "main card" do
-              Card.create! name: "sub create card"
-              add_subcard("sub card")
-            end
-
-            test_event :finalize, on: :create, for: "main card" do
-              __current_trans
-            end
-
-            main_card = create_card
-            Delayed::Worker.new.work_off
-
-            expect(main_card.__record_names).to eq ["main card"]
-            expect(Card["sub card"]).to exist
-            expect(Card["sub create card"]).to exist
-
-            act_of_main = main_card.acts.last
-            expect(act_of_main).to eq Card["sub create card"].actions.last.act
-            expect(act_of_main).to eq Card["sub card"].actions.last.act
-          end
-        end
-      end
-    end
-  end
-end

data/tmpsets/set/mod002-core/all/actify.rb

@@ -1,77 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Actify)
-#
-module Actify;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/actify.rb"; end
-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
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/actify.rb ~~

data/tmpsets/set/mod002-core/all/cache.rb

@@ -1,118 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Cache)
-#
-module Cache;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/cache.rb"; end
-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
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/cache.rb ~~

data/tmpsets/set/mod002-core/all/event_conditions.rb

@@ -1,181 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (EventConditions)
-#
-module EventConditions;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/event_conditions.rb"; end
-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
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/event_conditions.rb ~~