card 1.99.4 → 1.99.5

data/tmpsets/set/mod013-basic_types/type/json.rb

@@ -1,40 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Type
-# Set: All "Json" cards
-#
-module Json;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/basic_types/set/type/json.rb"; end
-event :validate_json, :validate, on: :save, changed: :content do
-  check_json_syntax if content.present?
-end
-
-def check_json_syntax
-  parse_content
-rescue JSON::ParserError => e
-  errors.add tr(:invalid_json), e.message.sub(/^\d+: /, "").to_s
-end
-
-def parse_content
-  JSON.parse content
-end
-
-def item_names _args={}
-  parse_content.keys
-end
-
-module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
-  view :core do
-    process_content ::CodeRay.scan(_render_raw, :json).div
-  end
-
-  def editor
-    :ace_editor
-  end
-
-  def ace_mode
-    :json
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/basic_types/set/type/json.rb ~~

data/tmpsets/set/mod013-basic_types/type/plain_text.rb

@@ -1,18 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Type
-# Set: All "PlainText" cards
-#
-module PlainText;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/basic_types/set/type/plain_text.rb"; end
-module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
-  def editor
-    :text_area
-  end
-
-  view :core do
-    process_content CGI.escapeHTML(_render_raw)
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/basic_types/set/type/plain_text.rb ~~

data/tmpsets/set/mod014-machines/abstract/machine.rb

@@ -1,202 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract
-# Set: Abstract (Machine)
-#
-# ## What are Machines?
-# {Machine} and {MachineInput} together implement a kind of observer pattern.
-# {Machine} processes a collection of input cards to generate an output card
-# (a {Set::Type::File} card by default). If one of the input cards is changed
-# the output card will be updated.
-#
-# The classic example: A style card observes a collection of css and sccs card
-# to generate a file card with a css file that contains the assembled
-# compressed  css.
-#
-# ## Using Machines
-# Include the Machine module in the card set that is supposed to produce the
-# output card. If the output card should be automatically updated when a input
-# card is changed the input card has to be in a set that includes the
-# MachineInput module.
-#
-# The default machine:
-module Machine;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/machine.rb"; end
-#
-#  -  uses its item cards as input cards or the card itself if there are no
-# item cards;
-#  -  can be changed by passing a block to collect_input_cards
-#  -  takes the raw view of the input cards to generate the output;
-#  -  can be changed by passing a block to machine_input (in the input card
-# set)
-#  -  stores the output as a .txt file in the '+machine output' card;
-#  -  can be changed by passing a filetype and/or a block to
-#     store_machine_output
-#
-#
-# ## How does it work?
-# Machine cards have a '+machine input' and a '+machine output' card. The
-# '+machine input' card is a pointer to all input cards. Including the
-# MachineInput module creates an 'on: save' event that runs the machines of
-# all cards that are linked to that card via the +machine input pointer.
-module MachineClassMethods
-  attr_accessor :output_config
-
-  def collect_input_cards &block
-    define_method :engine_input, &block
-  end
-
-  def prepare_machine_input &block
-    define_method :before_engine, &block
-  end
-
-  def machine_engine &block
-    define_method :engine, &block
-  end
-
-  def store_machine_output args={}, &block
-    output_config.merge!(args)
-    return unless block_given?
-    define_method :after_engine, &block
-  end
-end
-
-card_accessor :machine_output, type: :file
-card_accessor :machine_input, type: :pointer
-
-def before_engine
-end
-
-def engine_input
-  # TODO: replace with call of extended_item_cards
-  # traverse through all levels of pointers and
-  # collect all item cards as input
-  items = [self]
-  new_input = []
-  already_extended = {} # avoid loops
-  loop_limit = 5
-  until items.empty?
-    item = items.shift
-    next if item.trash || already_extended[item.id].to_i > loop_limit
-    if item.item_cards == [item] # no pointer card
-      new_input << item
-    else
-      # item_cards instantiates non-existing cards
-      # we don't want those
-      items.insert(0, item.item_cards.reject(&:unknown?))
-      items.flatten!
-
-      new_input << item if item != self && item.known?
-      already_extended[item] = already_extended[item].to_i + 1
-    end
-  end
-  new_input
-end
-
-def engine input
-  input
-end
-
-def after_engine output
-  filetype = output_config[:filetype]
-  file = Tempfile.new [id.to_s, ".#{filetype}"]
-  file.write output
-  file.rewind
-  Card::Auth.as_bot do
-    p = machine_output_card
-    p.file = file
-    p.save!
-  end
-  file.close
-  file.unlink
-end
-
-view :machine_output_url do
-  machine_output_url
-end
-
-class << self
-  def included host_class
-    host_class.extend(MachineClassMethods)
-    host_class.mattr_accessor :output_config
-    host_class.output_config = { filetype: "txt" }
-
-    define_machine_events host_class
-  end
-
-  def define_machine_events host_class
-    event_suffix = host_class.name.tr ":", "_"
-    event_name = "reset_machine_output_#{event_suffix}".to_sym
-    host_class.event event_name, after: :expire_related, changed: :content, on: :save do
-      reset_machine_output
-    end
-  end
-end
-
-include_set Abstract::Lock
-
-def run_machine joint="\n"
-  before_engine
-  output =
-    input_item_cards.map do |input_card|
-      run_engine input_card
-    end.select(&:present?).join(joint)
-  after_engine output
-end
-
-def direct_machine_input? input_card
-  !input_card.is_a?(Card::Set::Type::Pointer) ||
-    input_card.respond_to?(:machine_input)
-end
-
-def run_engine input_card
-  return unless direct_machine_input? input_card
-  if (cached = fetch_cache_card(input_card)) && cached.content?
-    return cached.content
-  end
-
-  engine(input_from_card(input_card)).tap do |output|
-    cache_output_part input_card, output
-  end
-end
-
-def input_from_card input_card
-  if input_card.respond_to? :machine_input
-    input_card.machine_input
-  else
-    input_card.format._render_raw
-  end
-end
-
-def make_machine_output_coded mod=:machines
-  update_machine_output
-  Card::Auth.as_bot do
-    ENV["STORE_CODED_FILES"] = "true"
-    machine_output_card.update! storage_type: :coded, mod: mod,
-                                           codename: machine_output_codename
-    ENV["STORE_CODED_FILES"] = nil
-  end
-end
-
-def machine_output_codename
-  machine_output_card.name.parts.map do |part|
-    Card[part].codename&.to_s || Card[part].name.safe_key
-  end.join "_"
-end
-
-def input_item_cards
-  machine_input_card.item_cards
-end
-
-def machine_output_url
-  ensure_machine_output
-  machine_output_card.file.url # (:default, timestamp: false)
-  # to get rid of additional number in url
-end
-
-def machine_output_path
-  ensure_machine_output
-  machine_output_card.file.path
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/machine.rb ~~

data/tmpsets/set/mod014-machines/abstract/machine/output_cache.rb

@@ -1,25 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Machine;
-# Set: Abstract (Machine, OutputCache)
-#
-module OutputCache;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/machine/output_cache.rb"; end
-def fetch_cache_card input_card, new=nil
-  new &&= { type_id: PlainTextID }
-  Card.fetch input_card.name, name, :machine_cache, new: new
-end
-
-def cache_output_part input_card, output
-  Auth.as_bot do
-    # save virtual cards first
-    # otherwise the cache card will save it to get the left_id
-    # and trigger the cache update again
-    input_card.save! if input_card.new_card?
-
-    cache_card = fetch_cache_card(input_card, true)
-    cache_card.update! content: output
-  end
-end
-end;end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/machine/output_cache.rb ~~

data/tmpsets/set/mod014-machines/abstract/machine/output_update.rb

@@ -1,68 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Machine;
-# Set: Abstract (Machine, OutputUpdate)
-#
-module OutputUpdate;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/machine/output_update.rb"; end
-def reset_machine_output
-  Auth.as_bot do
-    (moc = machine_output_card) && moc.real? && moc.delete!
-    update_input_card
-  end
-end
-
-def regenerate_machine_output
-  return unless ok?(:read)
-  lock { run_machine }
-end
-
-def update_machine_output
-  return unless ok?(:read)
-  lock do
-    update_input_card
-    run_machine
-  end
-end
-
-def ensure_machine_output
-  output = fetch trait: :machine_output
-  return if output&.selected_content_action_id
-  update_machine_output
-end
-
-def update_input_card
-  if Card::ActManager.running_act?
-    input_card = attach_subcard! machine_input_card
-    input_card.content = ""
-    engine_input.each { |input| input_card << input }
-  else
-    machine_input_card.items = engine_input
-  end
-end
-
-def input_cards_with_changed_source output_updated
-  machine_input_card.extended_item_cards.select do |i_card|
-    i_card.try(:source_changed?, since: output_updated)
-  end
-end
-
-# regenerates the machine output if a source file of a input card has been changed
-def update_if_source_file_changed
-  return unless (output_updated = output_updated_at)
-  changed = input_cards_with_changed_source(output_updated)
-  return if changed.empty?
-  changed.each(&:expire_machine_cache)
-  regenerate_machine_output
-end
-
-def output_updated_at
-  return unless (output_card = machine_output_card)
-  if output_card.coded?
-    File.mtime output_card.file.path
-  else
-    output_card.updated_at
-  end
-end
-end;end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/machine/output_update.rb ~~

data/tmpsets/set/mod014-machines/abstract/script.rb

@@ -1,93 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract
-# Set: Abstract (Script)
-#
-# -*- encoding : utf-8 -*-
-module Script;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/script.rb"; end
-
-require "uglifier"
-
-def self.included host_class
-  host_class.include_set Abstract::Machine
-  host_class.include_set Abstract::MachineInput
-
-  host_class.machine_input { standard_machine_input }
-  host_class.store_machine_output filetype: "js"
-end
-
-def standard_machine_input
-  js = format(:js)._render_core
-  js = compress_js js if compress_js?
-  comment_with_source js
-end
-
-def comment_with_source js
-  "//#{name}\n#{js}"
-end
-
-def compress_js input
-  Uglifier.compile input
-rescue => e
-  # CoffeeScript is compiled in a view
-  # If there is a CoffeeScript syntax error we get the rescued view here
-  # and the error that the rescued view is no valid Javascript
-  # To get the original error we have to refer to Card::Error.current
-  raise Card::Error, compression_error_message(e)
-end
-
-def compression_error_message e
-  if Card::Error.current
-    Card::Error.current.message
-  else
-    "JavaScript::SyntaxError (#{name}): #{e.message}"
-  end
-end
-
-def compress_js?
-  Cardio.config.compress_javascript
-end
-
-def clean_html?
-  false
-end
-
-module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  def chunk_list  # turn off autodetection of uri's
-    :nest_only
-  end
-
-  # def default_nest_view
-  #   :raw
-  # end
-end
-
-module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
-  def editor
-    :ace_editor
-  end
-
-  def ace_mode
-    :javascript
-  end
-
-  def content_changes action, diff_type, hide_diff=false
-    wrap_with(:pre) { super }
-  end
-
-  view :core do
-    script = card.format(:js).render_core
-    process_content highlight(script)
-  end
-
-  def highlight script
-    ::CodeRay.scan(script, :js).div
-  end
-end
-
-def diff_args
-  { diff_format: :text }
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/script.rb ~~