card 1.99.6 → 1.100.0

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

@@ -0,0 +1,44 @@
+# -*- 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
+
+def item_values
+  parse_content.values
+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 input_type
+    :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

@@ -0,0 +1,18 @@
+# -*- 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 input_type
+    :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

@@ -0,0 +1,202 @@
+# -*- 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: FileID
+card_accessor :machine_input, type: PointerID
+
+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.collection? ||
+    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

@@ -0,0 +1,25 @@
+# -*- 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

@@ -0,0 +1,77 @@
+# -*- 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
+    @updated_at = output_updated_at
+    moc.delete! if moc.real?
+    update_input_card
+    expire_if_source_file_changed @updated_at
+  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
+    expire_if_source_file_changed output_updated_at
+    run_machine
+  end
+end
+
+def ensure_machine_output
+  output = fetch :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
+
+def expire_if_source_file_changed output_updated_at
+  return unless output_updated_at
+  changed = input_cards_with_changed_source(output_updated_at)
+  return if changed.empty?
+  changed.each(&:expire_machine_cache)
+  true
+end
+
+# regenerates the machine output if a source file of a input card has been changed
+def update_if_source_file_changed
+  return unless expire_if_source_file_changed output_updated_at
+  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/{mod011-machines → mod014-machines}/abstract/machine_input.rb

@@ -1,6 +1,10 @@
 # -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module MachineInput; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/machines/set/abstract/machine_input.rb ~~
+class Card; module Set; class Abstract
+# Set: Abstract (MachineInput)
+#
+module MachineInput;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/machine_input.rb"; end
 module MachineInputClassMethods
   attr_accessor :machines_wql
 
@@ -66,18 +70,12 @@ def self.search_involved_machines name, host_class
 end
 
 def expire_machine_cache
-  Card.search(right_plus: [
-                { codename: "machine_input" },
-                { link_to: name }
-              ],
+  Card.search(right_plus: [{ codename: "machine_input" }, { link_to: name }],
               return: :name).each do |machine_name|
-    next unless (cache = Card.fetch(name, machine_name, :machine_cache))
-    Auth.as_bot do
-      cache.update_attributes! trash: true
-    end
+    cache_card = Card.fetch(name, machine_name, :machine_cache)
+    next unless cache_card&.content?
+    Auth.as_bot { cache_card.update! trash: true }
   end
 end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/machines/set/abstract/machine_input.rb ~~
 end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/machines/set/abstract/machine_input.rb ~~

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

@@ -0,0 +1,93 @@
+# -*- 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 input_type
+    :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 ~~