card 0.0.1 → 1.15.pre

data/mod/01_core/chunk/uri.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+require 'uri'
+
+# This wiki chunk matches arbitrary URIs, using patterns from the Ruby URI modules.
+# It parses out a variety of fields that could be used by formats to format
+# the links in various ways (shortening domain names, hiding email addresses)
+# It matches email addresses and host.com.au domains without schemes (http://)
+# but adds these on as required.
+#
+# The heuristic used to match a URI is designed to err on the side of caution.
+# That is, it is more likely to not autolink a URI than it is to accidently
+# autolink something that is not a URI. The reason behind this is it is easier
+# to force a URI link by prefixing 'http://' to it than it is to escape and
+# incorrectly marked up non-URI.
+#
+# I'm using a part of the [ISO 3166-1 Standard][iso3166] for country name suffixes.
+# The generic names are from www.bnoack.com/data/countrycode2.html)
+#   [iso3166]: http://geotags.com/iso3166/
+module Card::Chunk
+  class URI < Abstract
+
+    SCHEMES = %w{irc http https ftp ssh git sftp file ldap ldaps mailto}
+
+    REJECTED_PREFIX_RE = %w{ ! ": " ' ]( }.map{|s|Regexp.escape s} * '|'
+
+    attr_reader :uri, :link_text
+    delegate :to, :scheme, :host, :port, :path, :query, :fragment, :to => :uri
+
+    Card::Chunk.register_class self, {
+      :prefix_re => "(?:(?!#{REJECTED_PREFIX_RE})(?:#{SCHEMES * '|'})\\:)",
+      :full_re    => /^#{::URI.regexp( SCHEMES )}/,
+      :idx_char  => ':'
+    }
+    
+    class << self
+      def full_match content, prefix
+        prepend_str = if prefix[-1,1] != ':' && config[:prepend_str]
+          config[:prepend_str]
+        else
+          ''
+        end
+        content = prepend_str + content
+        match = super content, prefix
+        [ match, prepend_str.length ]
+      end
+
+      def context_ok? content, chunk_start
+        preceding_string = content[chunk_start-2..chunk_start-1]
+        !( preceding_string =~ /(?:#{REJECTED_PREFIX_RE})$/ )
+      end
+    end
+    
+    def interpret match, content
+      chunk = match[0]
+      last_char = chunk[-1,1]
+      chunk.gsub!(/(?:&nbsp;)+/, '')
+
+      @trailing_punctuation = if %w{ , . ) ! ? : }.member?(last_char)
+        @text.chop!
+        chunk.chop!
+        last_char
+      end
+      chunk.sub!(/\.$/, '')
+
+      @link_text = chunk
+
+      #warn "uri parse[#{match.inspect}]"
+      @uri = ::URI.parse( chunk )
+      @process_chunk = "#{format.web_link(@link_text)}#{@trailing_punctuation}"
+    rescue ::URI::Error=>e
+      #warn "rescue parse #{chunk_class}: '#{m}' #{e.inspect} #{e.backtrace*"\n"}"
+      Rails.logger.warn "rescue parse #{self.class}: #{e.inspect}"
+    end
+
+
+  end
+
+  # FIXME: DRY, merge these two into one class
+  class EmailURI < URI
+
+    PREPEND_STR = 'mailto:'
+    EMAIL = "[a-zA-Z\d](?:[-a-zA-Z\d]*[a-zA-Z\d])?\\@"
+        
+    Card::Chunk.register_class self, {
+      :prefix_re => "(?:(?!#{REJECTED_PREFIX_RE})#{EMAIL})\\b",
+      :full_re    => /^#{::URI.regexp( SCHEMES )}/,
+      :prepend_str => PREPEND_STR,
+      :idx_char  => '@'
+    }
+
+    def interpret match, content
+      super
+      @text = @text.sub(/^mailto:/,'')  # this removes the prepended string from the unchanged match text
+      @process_chunk = "#{format.web_link(@link_text, :text=> @text)}#{@trailing_punctuation}"
+    end
+  end
+
+  class HostURI < URI
+
+    GENERIC = 'aero|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org'
+
+    COUNTRY = 'ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|az|ba|bb|bd|be|' +
+      'bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cf|cd|cg|ch|ci|ck|cl|' +
+      'cm|cn|co|cr|cs|cu|cv|cx|cy|cz|de|dj|dk|dm|do|dz|ec|ee|eg|eh|er|es|et|fi|' +
+      'fj|fk|fm|fo|fr|fx|ga|gb|gd|ge|gf|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|' +
+      'hk|hm|hn|hr|ht|hu|id|ie|il|in|io|iq|ir|is|it|jm|jo|jp|ke|kg|kh|ki|km|kn|' +
+      'kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|mg|mh|mk|ml|mm|' +
+      'mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nt|' +
+      'nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|pt|pw|py|qa|re|ro|ru|rw|sa|sb|sc|' +
+      'sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|st|su|sv|sy|sz|tc|td|tf|tg|th|tj|tk|' +
+      'tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|um|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|' +
+      'ws|ye|yt|yu|za|zm|zr|zw|' +
+      'eu' # made this separate, since it's not technically a country -efm
+      # These are needed otherwise HOST will match almost anything
+
+    TLDS = "(?:#{GENERIC}|#{COUNTRY})"
+    #TLDS = "(?:#{GENERIC})"
+
+    PREPEND_STR = 'http://'
+    HOST = "(?:[a-zA-Z\d](?:[-a-zA-Z\d]*[a-zA-Z\d])?\\.)+#{TLDS}"
+    
+    Card::Chunk.register_class self, {
+      :prefix_re => "(?:(?!#{REJECTED_PREFIX_RE})#{HOST})\\b",
+      :full_re    => /^#{::URI.regexp( SCHEMES )}/,
+      :prepend_str => PREPEND_STR
+    }
+
+    def interpret match, content
+      super
+      @text = @text.sub(/^http:\/\//,'')  # this removes the prepended string from the unchanged match text
+      #warn "huri t:#{@text}, #{match}, #{params.inspect}"
+      @process_chunk = "#{format.web_link(@link_text, :text=>@text)}#{@trailing_punctuation}"
+    end
+  end
+end

data/mod/01_core/format/data_format.rb

@@ -0,0 +1,2 @@
+class Card::DataFormat < Card::Format
+end

data/mod/01_core/format/html_format.rb

@@ -0,0 +1,129 @@
+# -*- encoding : utf-8 -*-
+
+require_dependency 'card/diff'
+
+class Card
+  Format.register :html
+  class HtmlFormat < Format
+    include Diff
+  
+    attr_accessor  :options_need_save, :start_time, :skip_autosave
+
+    # builtin layouts allow for rescue / testing
+    LAYOUTS = Loader.load_layouts.merge 'none' => '{{_main}}'
+
+    INCLUSION_DEFAULTS = {
+      :layout => { :view => :core },
+      :normal => { :view => :content }
+    }
+  
+    # helper methods for layout view
+    def get_layout_content
+      Auth.as_bot do
+        if requested_layout = params[:layout]
+          layout_from_card_or_code requested_layout
+        else
+          layout_from_rule
+        end
+      end
+    end
+
+    def layout_from_rule
+      if rule = card.rule_card(:layout) and rule.type_id==Card::PointerID and layout_name=rule.item_names.first
+        layout_from_card_or_code layout_name
+      end
+    end
+
+    def layout_from_card_or_code name
+      layout_card = Card.fetch name.to_s, :skip_virtual=>true, :skip_modules=>true
+      if layout_card and layout_card.ok? :read
+        layout_card.content
+      elsif hardcoded_layout = LAYOUTS[name]
+        hardcoded_layout
+      else
+        "<h1>Unknown layout: #{name}</h1>Built-in Layouts: #{LAYOUTS.keys.join(', ')}"
+      end
+    end
+    
+    
+    def get_inclusion_defaults
+      INCLUSION_DEFAULTS[@mode] || {}
+    end
+  
+    def default_item_view
+      :closed
+    end
+
+    def output content
+      case content
+      when String; content
+      when Array ; content.compact.join "\n"
+      end
+    end  
+
+    def html_escape_except_quotes s
+      # to be used inside single quotes (makes for readable json attributes)
+      s.to_s.gsub(/&/, "&amp;").gsub(/\'/, "&apos;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+    end
+    
+    #### --------------------  additional helpers ---------------- ###
+
+    # session history helpers: we keep a history stack so that in the case of
+    # card removal we can crawl back up to the last un-removed location
+
+    module Location
+      def location_history
+        #warn "sess #{session.class}, #{session.object_id}"
+        session[:history] ||= [card_path('')]
+        if session[:history]
+          session[:history].shift if session[:history].size > 5
+          session[:history]
+        end
+      end
+
+      def save_location
+        return if ajax? || !html? || !@card.known? || (@card.codename == 'signin')
+        discard_locations_for @card
+        @previous_location = card_path @card.cardname.url_key
+        location_history.push @previous_location
+      end
+
+      def previous_location
+        @previous_location ||= location_history.last if location_history
+      end
+
+      def discard_locations_for(card)
+        # quoting necessary because cards have things like "+*" in the names..
+        session[:history] = location_history.reject do |loc|
+          if url_key = url_key_for_location(loc)
+            url_key.to_name.key == card.key
+          end
+        end.compact
+        @previous_location = nil
+      end
+
+      def save_interrupted_action uri
+        uri = path(uri) if Hash === uri
+        session[:interrupted_action] = uri
+      end
+  
+      def interrupted_action
+        session.delete :interrupted_action
+      end
+
+      def url_key_for_location(location)
+        location.match( /\/([^\/]*$)/ ) ? $1 : nil
+      end
+    end
+    include Location
+
+
+    def main?
+      if Env.ajax?
+        @depth == 0 && params[:is_main]
+      else
+        @depth == 1 && @mainline #assumes layout includes {{_main}}
+      end
+    end
+  end
+end

data/mod/01_core/format/text_format.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  Format.register :text
+  Format.register :txt
+  
+  class TextFormat < Format
+    @@aliases['txt'] = 'text'
+  end
+end

data/mod/01_core/layout/blank.html

@@ -0,0 +1,5 @@
+<!DOCTYPE HTML>
+<html>
+  <head> {{*head}} </head>
+  <body id="wagn"> {{_main}} </body>
+</html>

data/mod/01_core/layout/default.html

@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    {{*head}}
+  </head>
+  
+  <body id="wagn">
+    <div id="menu">
+      [[/ | Home]]   [[/recent | Recent]]   {{*navbox}} {{*account links}}
+    </div>
+    
+    <div id="primary">
+      {{_main}}
+    </div>
+    
+    <div id="secondary">
+      {{*sidebar}}
+    </div>
+  </body>
+</html>

data/mod/01_core/layout/noside.html

@@ -0,0 +1,16 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    {{*head}}
+  </head>
+
+  <body id="wagn" class="noside">
+    <div id="menu">
+      [[/ | Home]]   [[/recent | Recent]]   {{*navbox}} {{*account links}}
+    </div>
+
+    <div>
+      {{_main}}
+    </div>
+  </body>
+</html>

data/mod/01_core/layout/pre.html

@@ -0,0 +1,2 @@
+<!DOCTYPE HTML>
+<html> <body><pre>{{_main|raw}}</pre></body> </html>

data/mod/01_core/layout/simple.html

@@ -0,0 +1,5 @@
+<!DOCTYPE HTML>
+<html>
+  <head> {{*head}} </head>
+  <body> {{_main}} </body>
+</html>

data/mod/01_core/set/all/active_card.rb

@@ -0,0 +1,35 @@
+=begin
+
+# following may be useful, but is neither tested nor in use
+
+def card_attributes
+  if Card::Set.traits
+    set_modules.each do |mod|
+      if mod_traits = Card::Set.traits[mod]
+        return mod_traits
+      end
+    end
+  end
+  nil
+end
+
+def trait_var? var_name
+  !instance_variable_get( var_name ).nil?
+end
+
+=end
+
+def trait_var var_name, &block
+  # FIXME - following optimization attempt needs to handle cache clearing!
+#  instance_variable_get var_name or begin
+#    instance_variable_set var_name, block_given? ? yield : raise("no block?")
+#  end
+  yield
+end
+
+#fixme -this needs a better home!
+def format opts={}
+  opts = { :format=>opts.to_sym } if [Symbol, String].member? opts.class
+   
+  Card::Format.new self, opts
+end

data/mod/01_core/set/all/collection.rb

@@ -0,0 +1,142 @@
+
+module ClassMethods
+  def search spec
+    query = ::Card::Query.new(spec)
+    Card.with_logging :search, :message=>spec, :details=>query.sql.strip do
+      results = query.run
+      if block_given? and Array===results
+        results.each { |result| yield result }
+      end
+      results
+    end
+  end
+
+  def count_by_wql(spec)
+    spec.delete(:offset)
+    search spec.merge(:return=>'count')
+  end
+
+  def find_each(options = {}) 
+    #this is a copy from rails (3.2.16) and is needed because this is performed by a relation (ActiveRecord::Relation)
+    find_in_batches(options) do |records|
+      records.each { |record| yield record }
+    end
+  end
+
+  def find_in_batches(options = {})
+    if block_given?
+      super(options) do |records|
+        yield(records)
+        puts "resetting local cache"
+        Card.cache.reset_local
+      end
+    else
+      super(options)
+    end
+  end
+end
+
+def item_names(args={})
+  format._render_raw.split /[,\n]/
+end
+
+def item_cards(args={})  ## FIXME this is inconsistent with item_names
+  [self]
+end
+
+def item_type
+  nil
+end
+
+def include_item? item
+  key = if Card === item
+    item.cardname.key
+  else
+    item.to_name.key
+  end
+  item_names.map{|name| name.to_name.key}.member? key
+end
+
+def extended_item_cards context = nil
+  context = (context ? context.cardname : self.cardname)
+  args={ :limit=>'' }
+  items = self.item_cards(args.merge(:context=>context))
+  extended_list = []
+  already_extended = ::Set.new # avoid loops
+  
+  while items.size > 0
+    item = items.shift
+    if already_extended.include? item 
+      next
+    elsif item.item_cards == [item]  # no further level of items
+      extended_list << item
+      already_extended << item
+    else
+      items.unshift(*item.item_cards) # keep items in order
+      already_extended << item
+    end
+  end
+  extended_list
+end
+
+def extended_item_contents context = nil
+  extended_item_cards(context).map(&:item_names).flatten
+end
+
+def extended_list context = nil
+  context = (context ? context.cardname : self.cardname)
+  args={ :limit=>'' }
+  self.item_cards(args.merge(:context=>context)).map do |x|
+    x.item_cards(args)
+  end.flatten.map do |x|
+    x.item_cards(args)
+  end.flatten.map do |y|
+    y.item_names(args)
+  end.flatten
+  # this could go on and on.  more elegant to recurse until you don't have a collection
+end
+
+def contextual_content context_card, format_args={}, view_args={}
+  context_card.format(format_args).process_content(
+    self.format(format_args)._render_raw(view_args), view_args
+  )
+end
+
+format do
+  
+  def search_params
+    @search_params ||= begin
+      p = default_search_params.clone
+    
+      if focal? 
+        p[:offset] = params[:offset] if params[:offset]
+        p[:limit]  = params[:limit]  if params[:limit]
+        p.merge! params[:wql]        if params[:wql]
+      end
+      p
+    end
+  end
+
+  def default_search_params # wahh?
+    set_default_search_params
+  end
+
+  def set_default_search_params overrides={}
+    @default_search_params ||= begin
+      p = { :default_limit=> 100 }.merge overrides
+      set_search_params_variables! p
+      p
+    end
+  end
+
+  def set_search_params_variables! hash
+    hash[:vars] = params[:vars] || {}
+    params.each do |key,val|
+      case key.to_s
+      when '_wql'      ;  hash.merge! val
+      when /^\_(\w+)$/ ;  hash[:vars][$1.to_sym] = val
+      end
+    end
+  end
+end
+