card 1.18.6 → 1.19.0

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

@@ -0,0 +1,129 @@
+module ClassMethods
+  def empty_trash
+    Card.delete_trashed_files
+    Card.where(trash: true).delete_all
+    Card::Action.delete_cardless
+    Card::Reference.unmap_if_referee_missing
+    Card::Reference.delete_if_referer_missing
+    Card.delete_tmp_files_of_cached_uploads
+  end
+
+  # deletes any file not associated with a real card.
+  def delete_trashed_files
+    trashed_card_ids = all_trashed_card_ids
+    file_ids = all_file_ids
+    dir = Cardio.paths["files"].existent.first
+    file_ids.each do |file_id|
+      next unless trashed_card_ids.member?(file_id)
+      if Card.exists?(file_id) # double check!
+        raise Card::Error, "Narrowly averted deleting current file"
+      end
+      FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
+    end
+  end
+
+  def delete_tmp_files id=nil
+    dir = Cardio.paths["files"].existent.first + "/tmp"
+    dir += "/#{id}" if id
+    FileUtils.rm_rf dir, secure: true
+  rescue
+    Rails.logger.info "failed to remove tmp files"
+  end
+
+  def all_file_ids
+    dir = Card.paths["files"].existent.first
+    Dir.entries(dir)[2..-1].map(&:to_i)
+  end
+
+  def all_trashed_card_ids
+    trashed_card_sql = %( select id from cards where trash is true )
+    sql_results = Card.connection.select_all(trashed_card_sql)
+    sql_results.map(&:values).flatten.map(&:to_i)
+  end
+
+  def delete_tmp_files_of_cached_uploads
+    actions = Card::Action.find_by_sql "SELECT * FROM card_actions
+      INNER JOIN cards ON card_actions.card_id = cards.id
+      WHERE cards.type_id IN (#{Card::FileID}, #{Card::ImageID})
+      AND card_actions.draft = true"
+    actions.each do |action|
+      # we don't want to delete uploads in progress
+      if older_than_five_days?(action.created_at) && (card = action.card)
+        # we don't want to delete uploads in progress
+        card.delete_files_for_action action
+      end
+    end
+  end
+
+  def merge_list attribs, opts={}
+    unmerged = []
+    attribs.each do |row|
+      result = begin
+        merge row["name"], row, opts
+      end
+      unmerged.push row unless result == true
+    end
+
+    if unmerged.empty?
+      Rails.logger.info "successfully merged all!"
+    else
+      unmerged_json = JSON.pretty_generate unmerged
+      report_unmerged_json unmerged_json, opts[:output_file]
+    end
+    unmerged
+  end
+
+  def report_unmerged_json unmerged_json, output_file
+    if output_file
+      ::File.open output_file, "w" do |f|
+        f.write unmerged_json
+      end
+    else
+      Rails.logger.info "failed to merge:\n\n#{unmerged_json}"
+    end
+  end
+
+  def merge name, attribs={}, opts={}
+    # puts "merging #{name}"
+    card = fetch name, new: {}
+    [:image, :file].each do |attach|
+      next unless attribs[attach] && attribs[attach].is_a?(String)
+      attribs[attach] = ::File.open(attribs[attach])
+    end
+    if opts[:pristine] && !card.pristine?
+      false
+    else
+      card.update_attributes! attribs
+    end
+  end
+
+  def older_than_five_days? time
+    Time.now - time > 432_000
+  end
+
+  def seed_test_db
+    system "env RAILS_ENV=test bundle exec rake db:fixtures:load"
+  end
+end
+
+def debug_type
+  "#{type_code || ''}:#{type_id}"
+end
+
+def to_s
+  "#<#{self.class.name}[#{debug_type}]#{attributes['name']}>"
+end
+
+def inspect
+  tags = []
+  tags << "trash"    if trash
+  tags << "new"      if new_card?
+  tags << "frozen"   if frozen?
+  tags << "readonly" if readonly?
+  tags << "virtual"  if @virtual
+  tags << "set_mods_loaded" if @set_mods_loaded
+
+  error_messages = errors.any? ? "<E*#{errors.full_messages * ', '}*>" : ""
+
+  "#<Card##{id}[#{debug_type}](#{name})#{error_messages}{#{tags * ','}}"
+end

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

@@ -0,0 +1,9 @@
+event :clear_view_cache, :finalize do
+  Card::Cache::ViewCache.reset
+end
+
+format do
+  def view_caching?
+    false
+  end
+end

data/mod/core/set_pattern/01_all.rb

@@ -0,0 +1,11 @@
+def label _name
+  "All cards"
+end
+
+def prototype_args _anchor
+  {}
+end
+
+def follow_label _name
+  "everything"
+end

data/mod/core/set_pattern/02_all_plus.rb

@@ -0,0 +1,13 @@
+@@options = { junction_only: true }
+
+def label _name
+  'All "+" cards'
+end
+
+def prototype_args _anchor
+  { name: "+" }
+end
+
+def follow_label _name
+  'all "+" cards'
+end

data/mod/core/set_pattern/04_star.rb

@@ -0,0 +1,15 @@
+def label _name
+  'All "*" cards'
+end
+
+def prototype_args _anchor
+  { name: "*dummy" }
+end
+
+def pattern_applies? card
+  card.cardname.star?
+end
+
+def follow_label _name
+  'all "*" cards'
+end

data/mod/core/set_pattern/05_rstar.rb

@@ -0,0 +1,17 @@
+@@options = { junction_only: true }
+
+def label _name
+  'All "+*" cards'
+end
+
+def prototype_args _anchor
+  { name: "*dummy+*dummy" }
+end
+
+def pattern_applies? card
+  card.cardname.rstar?
+end
+
+def follow_label _name
+  'all "+*" cards'
+end

data/mod/core/set_pattern/07_type_plus_right.rb

@@ -0,0 +1,26 @@
+@@options = {
+  junction_only: true,
+  assigns_type: true,
+  anchor_parts_count: 2
+}
+
+def label name
+  %(All "+#{name.to_name.tag}" cards on "#{name.to_name.left_name}" cards)
+end
+
+def prototype_args anchor
+  {
+    name: "+#{anchor.tag}",
+    supercard: Card.new(name: "*dummy", type: anchor.trunk_name)
+  }
+end
+
+def anchor_name card
+  left = card.left
+  type_name = (left && left.type_name) || Card[Card.default_type_id].name
+  "#{type_name}+#{card.cardname.tag}"
+end
+
+def follow_label name
+  %(all "+#{name.to_name.tag}" on "#{name.to_name.left_name}s")
+end

data/mod/core/spec/chunk/literal_spec.rb

@@ -0,0 +1,13 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Content::Chunk::EscapedLiteral, "literal chunk tests" do
+  it "should handle escaped link" do
+    expect(render_content('write this: \[[text]]'))
+      .to eq("write this: <span>[</span>[text]]")
+  end
+
+  it "should handle escaped nest" do
+    expect(render_content('write this: \{{cardname}}'))
+      .to eq("write this: <span>{</span>{cardname}}")
+  end
+end

data/mod/core/spec/chunk/uri_spec.rb

@@ -0,0 +1,297 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Content::Chunk::URI, "URI chunk tests" do
+  it "should test_non_matches" do
+    no_match_uri "There is no URI here"
+    no_match_uri "One gemstone is the garnet:reddish in colour, like ruby"
+  end
+
+  it "works with simple uri" do
+    # Simplest case
+    match_http_uri "http://www.example.com",
+                   host: "www.example.com", path: ""
+  end
+  it "works with trailing slash" do
+    match_http_uri "http://www.example.com/",
+                   host: "www.example.com", path: "/"
+  end
+  it "works with trailing slash inside html tags" do
+    match_http_uri "<p>http://www.example.com/</p>",
+                   host: "www.example.com", path: "/",
+                   link_text: "http://www.example.com/"
+  end
+  it "works with trailing period (no longer suppressed .. spec?)" do
+    match_http_uri "http://www.example.com/. ",
+                   host: "www.example.com", path: "/",
+                   link_text: "http://www.example.com/"
+  end
+  it "works with trailing period inside html tags (dot change?)" do
+    match_http_uri "<p>http://www.example.com/.</p>",
+                   host: "www.example.com", path: "/",
+                   link_text: "http://www.example.com/"
+  end
+  it "works with trailing &nbsp;" do
+    match_http_uri "http://www.example.com/&nbsp;",
+                   host: "www.example.com", path: "/",
+                   link_text: "http://www.example.com/"
+  end
+  it "works without http://" do
+    match_http_uri "www.example.com",
+                   host: "www.example.com",
+                   text: "www.example.com",
+                   link_text: "http://www.example.com"
+    match_http_uri "example.com",
+                   host: "example.com",
+                   text: "example.com",
+                   link_text: "http://example.com"
+  end
+  it 'should match "unusual" base domain (was a bug in an early version)' do
+    match_http_uri "http://example.com.au/",
+                   host: "example.com.au"
+  end
+  it 'works with "unusual" base domain without http://' do
+    match_http_uri "example.com.au",
+                   host: "example.com.au",
+                   text: "example.com.au",
+                   link_text: "http://example.com.au"
+  end
+  it 'works with another "unusual" base domain' do
+    match_http_uri "http://www.example.co.uk/",
+                   host: "www.example.co.uk"
+    match_http_uri "example.co.uk",
+                   host: "example.co.uk",
+                   text: "example.co.uk",
+                   link_text: "http://example.co.uk"
+  end
+  it "works with some path at the end" do
+    match_http_uri "http://moinmoin.wikiwikiweb.de/HelpOnNavigation",
+                   host: "moinmoin.wikiwikiweb.de",
+                   path: "/HelpOnNavigation"
+  end
+  it "works with some path at the end, and without http:// prefix "\
+     "(@link_text has prefix added)" do
+    match_http_uri "moinmoin.wikiwikiweb.de/HelpOnNavigation",
+                   host: "moinmoin.wikiwikiweb.de",
+                   path: "/HelpOnNavigation",
+                   text: "moinmoin.wikiwikiweb.de/HelpOnNavigation",
+                   link_text: "http://moinmoin.wikiwikiweb.de/HelpOnNavigation"
+  end
+  it "works with a port number" do
+    match_http_uri "http://www.example.com:80",
+                   host: "www.example.com", port: 80,
+                   path: ""
+  end
+  it "works with a port number and a path" do
+    match_http_uri "http://www.example.com.tw:80/HelpOnNavigation",
+                   host: "www.example.com.tw", port: 80,
+                   path: "/HelpOnNavigation"
+  end
+  it "works with a query" do
+    match_http_uri "http://www.example.com.tw:80/HelpOnNavigation?arg=val",
+                   host: "www.example.com.tw", port: 80,
+                   path: "/HelpOnNavigation", query: "arg=val"
+  end
+  it "works on Query with two arguments" do
+    match_http_uri "http://www.example.com.tw:80/HelpOnNavigation"\
+                   "?arg=val&arg2=val2",
+                   host: "www.example.com.tw", port: 80,
+                   path: "/HelpOnNavigation", query: "arg=val&arg2=val2"
+  end
+  it "works with IRC" do
+    match_uri "irc://irc.freenode.net#recentchangescamp",
+              scheme: "irc", host: "irc.freenode.net",
+              fragment: "recentchangescamp",
+              link_text: "irc://irc.freenode.net#recentchangescamp"
+  end
+
+  it "should see HTTPS" do
+    match_uri "https://www.example.com",
+              scheme: "https", host: "www.example.com", port: 443,
+              path: "", query: nil
+  end
+  it "should see FTP" do
+    match_uri "ftp://www.example.com",
+              scheme: "ftp", host: "www.example.com", port: 21,
+              path: "", query: nil
+  end
+  it "should handle mailto:" do
+    match_uri "mailto:jdoe123@example.com",
+              scheme: "mailto", host: nil, port: nil,
+              path: nil, query: nil,
+              to: "jdoe123@example.com"
+  end
+
+  it "should run more basic cases" do
+    # from *css (with () around the URI)
+    # so, now this doesn't even match because I fixed the suspiciou* stuff
+    no_match_uri(
+      "background: url('http://dl.dropbox.com/u/4657397/wikirate/" \
+      "wikirate_files/wr-bg-menu-line.gif') repeat-x;"
+    )
+
+    # Soap opera (the most complex case imaginable... well, not really, there
+    # should be more evil)
+    match_http_uri(
+      "http://www.example.com.tw:80/~jdoe123/Help%20Me%20?arg=val&arg2=val2",
+      host: "www.example.com.tw", port: 80,
+      path: "/~jdoe123/Help%20Me%20", query: "arg=val&arg2=val2"
+    )
+
+    # from 0.9 bug reports
+    match_uri "http://www2.pos.to/~tosh/ruby/rdtool/en/doc/rd-draft.html",
+              scheme: "http", host: "www2.pos.to",
+              path: "/~tosh/ruby/rdtool/en/doc/rd-draft.html"
+
+    match_uri "http://support.microsoft.com/default.aspx?scid=kb;en-us;234562",
+              scheme: "http", host: "support.microsoft.com",
+              path: "/default.aspx", query: "scid=kb;en-us;234562"
+  end
+
+  it "should test_email_uri" do
+    match_uri "mail@example.com",
+              to: "mail@example.com", host: nil,
+              text: "mail@example.com",
+              link_text: "mailto:mail@example.com"
+  end
+
+  it "should test_non_email" do
+    # The @ is part of the normal text, but 'example.com' is marked up.
+    match_uri "Not an email: @example.com", uri: "http://example.com"
+  end
+
+  it "should test_textile_image" do
+    no_match_uri "This !http://hobix.com/sample.jpg! is a Textile image link."
+  end
+
+  it "should test_textile_link" do
+    no_match_uri(
+      'This "hobix (hobix)":http://hobix.com/sample.jpg is a Textile link.'
+    )
+    # just to be sure ...
+    match_uri "This http://hobix.com/sample.jpg should match",
+              link_text: "http://hobix.com/sample.jpg"
+  end
+
+  it "should test_inline_html" do
+    no_match_uri "<img src='http://hobix.com/sample.jpg'/>"
+    no_match_uri '<IMG SRC="http://hobix.com/sample.jpg">'
+  end
+
+  it "should test_non_uri" do
+    # "so" is a valid country code; "libproxy.so" is a valid url
+    match_uri "libproxy.so", host: "libproxy.so",
+                             text: "libproxy.so",
+                             link_text: "http://libproxy.so"
+
+    no_match_uri "httpd.conf"
+    # THIS ONE'S BUSTED.. Ethan fix??
+    # no_match_uri 'ld.so.conf'
+    no_match_uri "index.jpeg"
+    no_match_uri "index.jpg"
+    no_match_uri "file.txt"
+    no_match_uri "file.doc"
+    no_match_uri "file.pdf"
+    no_match_uri "file.png"
+    no_match_uri "file.ps"
+  end
+
+  it "should test_uri_in_text" do
+    match_uri "Go to: http://www.example.com/",
+              host: "www.example.com", path: "/"
+    match_uri "http://www.example.com/ is a link.", host: "www.example.com"
+    match_uri "Email david@loudthinking.com",
+              scheme: "mailto", to: "david@loudthinking.com", host: nil
+    # check that trailing punctuation is not included in the hostname
+    match_uri "Hey dude, http://fake.link.com.",
+              scheme: "http", host: "fake.link.com"
+    # this is a textile link, no match please.
+    no_match_uri '"link":http://fake.link.com.'
+  end
+
+  it "should test_uri_in_parentheses" do
+    match_uri "URI (http://brackets.com.de) in brackets",
+              host: "brackets.com.de"
+    match_uri "because (as shown at research.net) the results",
+              host: "research.net"
+    match_uri "A wiki (http://wiki.org/wiki.cgi?WhatIsWiki) card",
+              scheme: "http", host: "wiki.org", path: "/wiki.cgi",
+              query: "WhatIsWiki"
+  end
+
+  it "should test_uri_list_item" do
+    match_chunk(
+      Card::Content::Chunk::URI,
+      "* http://www.btinternet.com/~mail2minh/SonyEricssonP80xPlatform.sis",
+      path: "/~mail2minh/SonyEricssonP80xPlatform.sis"
+    )
+  end
+
+  it "should test_interesting_uri_with__comma" do
+    # Counter-intuitively, this URL matches, but the query part includes the
+    # trailing comma.
+    # It has no way to know that the query does not include the comma.
+    # The trailing , addition breaks this test, but is this test actually valid?
+    # It seems better to exclude the comma from the uri, YMMV
+    match_uri(
+      "This text contains a URL http://someplace.org:8080/~person/stuff.cgi" \
+      "?arg=val, doesn't it?",
+      scheme: "http", host: "someplace.org", port: 8080,
+      path: "/~person/stuff.cgi", query: "arg=val"
+    )
+  end
+
+  describe Card::Content::Chunk::URI, "URI chunk tests" do
+    it "should test_local_urls" do
+      # normal
+      match_http_uri "http://perforce:8001/toto.html",
+                     host: "perforce", port: 8001
+      # in parentheses
+      match_uri "URI (http://localhost:2500) in brackets",
+                host: "localhost", port: 2500
+      match_uri "because (as shown at http://perforce:8001) the results",
+                host: "perforce", port: 8001
+      match_uri "A wiki (http://localhost:2500/wiki.cgi?WhatIsWiki) card",
+                scheme: "http", host: "localhost", path: "/wiki.cgi",
+                port: 2500, query: "WhatIsWiki"
+    end
+  end
+
+  private
+
+  DUMMY_CARD = Card.new(name: "dummy")
+
+  # Asserts a number of tests for the given type and text.
+  def no_match type, test_text
+    expect(get_chunk(type, test_text)).to be_nil
+  end
+
+  def match_chunk type, test_text, expected
+    chunk = get_chunk(type, test_text)
+    expect(chunk).not_to be_nil
+
+    expected.each_pair do |method_sym, value|
+      # assert_respond_to(chunk, method_sym)
+      cvalue = chunk.method(method_sym).call
+      cvalue = cvalue.to_s if method_sym == :uri
+      assert_equal(value, cvalue, "Checking value of '#{method_sym}'")
+    end
+  end
+
+  def match_uri uri, opts
+    match_chunk Card::Content::Chunk::URI, uri, opts
+  end
+
+  def no_match_uri text
+    no_match Card::Content::Chunk::URI, text
+  end
+
+  def match_http_uri uri, opts
+    match_uri uri, opts.reverse_merge(link_text: uri, scheme: "http")
+  end
+
+  def get_chunk type, test_text
+    cont = Card::Content.new(test_text, DUMMY_CARD)
+    cont = [cont] unless cont.respond_to?(:each)
+    cont.find { |ck| ck.is_a? type }
+  end
+end