card 0.0.1 → 1.15.pre

data/lib/card/chunk.rb

@@ -0,0 +1,104 @@
+# -*- encoding : utf-8 -*-
+
+require 'uri/common'
+
+# A chunk is a pattern of text that can be protected
+# and interrogated by a format. Each Chunk class has a
+# +pattern+ that states what sort of text it matches.
+# Chunks are initalized by passing in the result of a
+# match by its pattern.
+
+class Card
+  module Chunk
+    mattr_accessor :raw_list, :prefix_regexp_by_list, :prefix_map
+    @@raw_list, @@prefix_regexp_by_list, @@prefix_map = {}, {}, {}
+  
+    class << self
+      def register_class klass, hash
+        klass.config = hash.merge :class => klass
+        prefix_index = hash[:idx_char] || :default  # this is gross and needs to be moved out.  
+        prefix_map[prefix_index] = klass.config
+      end
+    
+      def register_list key, list
+        raw_list[key] = list
+      end
+    
+      def find_class_by_prefix prefix
+        config = prefix_map[ prefix[0,1] ] || prefix_map[ prefix[-1,1] ] || prefix_map[:default]
+        #prefix identified by first character, last character, or default.  a little ugly...
+        config[:class]
+      end
+    
+      def get_prefix_regexp chunk_list_key
+        prefix_regexp_by_list[chunk_list_key] ||= begin
+          chunk_types = raw_list[chunk_list_key].map { |chunkname| const_get chunkname }
+          prefix_res = chunk_types.map do |chunk_class|
+            chunk_class.config[:prefix_re]
+          end
+          /(?:#{ prefix_res * '|' })/m
+        end
+      end
+
+    end
+  
+  
+    #not sure whether this is best place.  Could really happen almost anywhere (even before chunk classes are loaded).
+    register_list :default, [ :URI, :HostURI, :EmailURI, :EscapedLiteral, :Include, :Link ]
+    register_list :references,                         [ :EscapedLiteral, :Include, :Link ]
+    register_list :inclusion_only,                     [  :Include ]
+  
+    class Abstract
+      class_attribute :config
+      attr_reader :text, :process_chunk
+    
+      class << self
+        def full_match content, prefix=nil
+  #        warn "attempting full match on #{content}.  class = #{self}"
+          content.match full_re( prefix )
+        end
+
+        def full_re prefix
+          config[:full_re]
+        end
+      
+        def context_ok? content, chunk_start
+          true
+        end
+      end
+
+      def initialize match, content
+        @text = match[0]
+        @processed = nil
+        @content = content
+        interpret match, content
+        self
+      end
+    
+      def interpret match_string, content, params
+        Rails.logger.info "no #interpret method found for chunk class: #{self.class}"
+      end
+    
+      def format
+        @content.format
+      end
+    
+      def card
+        @content.card
+      end
+
+      def to_s
+        @process_chunk || @processed || @text
+      end
+
+      def inspect
+        "<##{self.class}##{to_s}>"
+      end
+
+      def as_json(options={})
+        @process_chunk || @processed|| "not rendered #{self.class}, #{card and card.name}"
+      end
+    end
+  end
+  Loader.load_chunks
+end

data/lib/card/codename.rb

@@ -0,0 +1,72 @@
+# -*- encoding : utf-8 -*-
+require_dependency 'card/cache'
+require_dependency 'card/name'
+
+class Card
+  class Codename
+
+    @@codehash=nil
+
+    class << self
+      # returns codename for id and vice versa.  not in love with this api --efm
+      def [] key
+        if !key.nil?
+          key = key.to_sym unless Integer===key
+          codehash[key]
+        end
+      end
+
+      def codehash
+        @@codehash || load_hash
+      end
+
+      def reset_cache
+        @@codehash = nil
+        cache.write 'CODEHASH', nil
+      end
+
+      #only used in migration
+      def bootdata hash
+        @@codehash = hash
+      end
+      
+  
+      private
+      
+      def cache
+        Card::Cache[Codename]
+      end
+
+      def load_hash
+        @@codehash = cache.read('CODEHASH') || begin
+          codehash = {}
+          sql = 'select id, codename from cards where codename is not NULL'
+          ActiveRecord::Base.connection.select_all(sql).each do |row|
+            #FIXME: remove duplicate checks, put them in other tools
+            code, cid = row['codename'].to_sym, row['id'].to_i
+            if codehash.has_key?(code) or codehash.has_key?(cid)
+              warn "dup code ID:#{cid} (#{codehash[code]}), CD:#{code} (#{codehash[cid]})"
+            end
+            codehash[code] = cid; codehash[cid] = code
+          end
+          cache.write 'CODEHASH', codehash
+        end
+      end
+    end
+    
+  end
+  
+  
+  def self.const_missing const
+    if const.to_s =~ /^([A-Z]\S*)ID$/ and code=$1.underscore.to_sym
+      if card_id = Codename[code]
+        const_set const, card_id
+      else
+        raise "Missing codename #{code} (#{const})"
+      end
+    else
+      super
+    end
+  end
+  
+end

data/lib/card/content.rb

@@ -0,0 +1,211 @@
+# -*- encoding : utf-8 -*-
+
+# TODO move Card::Chunk to Card::Content::Chunk...
+require_dependency 'card/chunk'
+
+class Card
+  class Content < SimpleDelegator
+    attr_reader :revision, :format, :chunks, :opts
+
+    def initialize content, format_or_card, opts={}
+      @format = if Card===format_or_card
+        Format.new format_or_card, :format=>nil
+      else
+        format_or_card
+      end
+      @opts = opts || {}
+      
+      unless Array === content
+        content = parse_content content  
+      end
+      super content
+    end
+
+    def card
+      format.card
+    end
+    
+    def chunk_list
+      @opts[:chunk_list] || @format.chunk_list
+    end
+
+    def to_s
+      case __getobj__
+      when Array;    map(&:to_s)*''
+      when String;   __getobj__
+      when NilClass; '' #raise "Nil Card::Content"
+      else           __getobj__.to_s
+      end
+    end
+
+    def inspect
+      "<#{__getobj__.class}:#{card}:#{self}>"
+    end
+
+    def each_chunk
+      return enum_for(:each_chunk) unless block_given?
+      case __getobj__
+        when Hash;   each { |k,v| yield v if Chunk::Abstract===v }
+        when Array;  each { |e|   yield e if Chunk::Abstract===e }
+        when String; # strings are all parsed in self, so no chunks in a String
+        else
+          Rails.logger.warn "error self is unrecognized type #{self.class} #{self.__getobj__.class}"
+      end
+    end
+
+    def find_chunks chunk_type
+      each_chunk.select { |chunk| chunk.kind_of?(chunk_type) }
+    end
+
+    def process_content_object &block
+      each_chunk { |chunk| chunk.process_chunk &block }
+      self
+    end
+
+    def parse_content content
+      @chunks = []
+
+      if String===content
+        position = last_position = 0
+        prefix_regexp = Chunk.get_prefix_regexp chunk_list
+        interval_string = ''
+
+        while prefix_match = content[position..-1].match( prefix_regexp )
+          prefix = prefix_match[0]                                                 # prefix of matched chunk
+          chunk_start = prefix_match.begin(0) + position                           # content index of beginning of chunk
+
+          if prefix_match.begin(0) > 0                                             # if matched chunk is not beginning of test string
+            interval_string += content[ position..chunk_start-1 ]                  # hold onto the non-chunk part of the string
+          end
+
+          chunk_class = Chunk.find_class_by_prefix prefix                          # get the chunk class from the prefix
+          match, offset = chunk_class.full_match content[chunk_start..-1], prefix  # see whether the full chunk actually matches (as opposed to bogus prefix)
+          context_ok = chunk_class.context_ok? content, chunk_start                # make sure there aren't contextual reasons for ignoring this chunk
+          position = chunk_start                                                   # move scanning position up to beginning of chunk
+
+          if match                                                                 # we have a chunk match
+            position += ( match.end(0) - offset.to_i )                             # move scanning position up to end of chunk
+            if context_ok                                                          #
+              @chunks << interval_string if interval_string.size > 0                # add the nonchunk string to the chunk list
+              @chunks << chunk_class.new( match, self )                             # add the chunk to the chunk list
+              interval_string = ''                                                 # reset interval string for next go-round
+              last_position = position                                             # note that the end of the chunk was the last place where a chunk was found (so far)
+            end
+          else
+            position += 1                                                          # no match.  look at the next character
+          end
+
+          if !match || !context_ok
+            interval_string += content[chunk_start..position-1]                    # moving beyond the alleged chunk.  append failed string to "nonchunk" string
+          end
+        end
+      end
+
+      if chunks.any?
+        if last_position < content.size
+          remainder = content[ last_position..-1]                                  # handle any leftover nonchunk string at the end of content
+          @chunks << remainder
+        end
+        chunks
+      else
+        content
+      end
+    end
+
+
+
+
+    ALLOWED_TAGS = {}
+    %w{
+      br i b pre cite caption strong em ins sup sub del ol hr ul li p
+      div h1 h2 h3 h4 h5 h6 span table tr td th tbody thead tfoot
+    }.each { |tag| ALLOWED_TAGS[tag] = [] }
+
+    # allowed attributes
+    ALLOWED_TAGS.merge!(
+      'a' => ['href', 'title', 'target' ],
+      'img' => ['src', 'alt', 'title'],
+      'code' => ['lang'],
+      'blockquote' => ['cite']
+    )
+
+    if Card.config.allow_inline_styles
+      ALLOWED_TAGS['table'] += %w[ cellpadding align border cellspacing ]
+    end
+
+    ALLOWED_TAGS.each_key {|k|
+      ALLOWED_TAGS[k] << 'class'
+      ALLOWED_TAGS[k] << 'style' if Card.config.allow_inline_styles
+      ALLOWED_TAGS[k]
+    }
+    ALLOWED_TAGS
+
+    ATTR_VALUE_RE = [ /(?<=^')[^']+(?=')/, /(?<=^")[^"]+(?=")/, /\S+/ ]
+
+    class << self
+
+      ## Method that cleans the String of HTML tags
+      ## and attributes outside of the allowed list.
+
+      # this has been hacked for card to allow classes if
+      # the class begins with "w-"
+      def clean!( string, tags = ALLOWED_TAGS )
+        string.gsub( /<(\/*)(\w+)([^>]*)>/ ) do
+          raw = $~
+          tag = raw[2].downcase
+          if attrs = tags[tag]
+            "<#{raw[1]}#{
+              attrs.inject([tag]) do |pcs, attr|
+                q='"'
+                rest_value=nil
+                if raw[3] =~ /\b#{attr}\s*=\s*(?=(.))/i
+                  rest_value = $'
+                  idx = %w{' "}.index($1) and q = $1
+                  re = ATTR_VALUE_RE[ idx || 2 ]
+                  if match = rest_value.match(re)
+                    rest_value = match[0]
+                    if attr == 'class'
+                      rest_value = rest_value.split(/\s+/).find_all {|s| s=~/^w-/i}*' '
+                    end
+                  end
+                end
+                pcs << "#{attr}=#{q}#{rest_value}#{q}" unless rest_value.blank?
+                pcs
+              end * ' '
+            }>"
+          else
+            " "
+          end
+        end.gsub(/<\!--.*?-->/, '')
+      end
+
+      def truncatewords_with_closing_tags(input, words = 25, truncate_string = "...")
+        if input.nil? then return end
+        wordlist = input.to_s.split
+        l = words.to_i - 1
+        l = 0 if l < 0
+        wordstring = wordlist.length > l ? wordlist[0..l].join(" ") : input.to_s
+        # nuke partial tags at end of snippet
+        wordstring.gsub!(/(<[^\>]+)$/,'')
+
+        tags = []
+
+        # match tags with or without self closing (ie. <foo />)
+        wordstring.scan(/\<([^\>\s\/]+)[^\>]*?\>/).each { |t| tags.unshift(t[0]) }
+        # match tags with self closing and mark them as closed
+        wordstring.scan(/\<([^\>\s\/]+)[^\>]*?\/\>/).each { |t| if !(x=tags.index(t[0])).nil? then tags.slice!(x) end }
+        # match close tags
+        wordstring.scan(/\<\/([^\>\s\/]+)[^\>]*?\>/).each { |t|  if !(x=tags.rindex(t[0])).nil? then tags.slice!(x) end  }
+
+        tags.each {|t| wordstring += "</#{t}>" }
+
+        wordstring +='<span class="closed-content-ellipses">...</span>' if wordlist.length > l
+    #    wordstring += '...' if wordlist.length > l
+        wordstring.gsub! /<[\/]?br[\s\/]*>/, ' ' ## Also a hack -- get rid of <br>'s -- they make line view ugly.
+        wordstring.gsub! /<[\/]?p[^>]*>/, ' ' ## Also a hack -- get rid of <br>'s -- they make line view ugly.
+        wordstring
+      end
+
+    end
+  end
+end

data/lib/card/core_ext.rb

@@ -0,0 +1,105 @@
+class Object
+  # FIXME: move this, mixin, don't extend Object
+  def deep_clone
+    case self
+    when Fixnum,Bignum,Float,NilClass,FalseClass,TrueClass,Symbol
+      klone = self
+    when Hash
+      klone = self.clone
+      self.each{|k,v| klone[k] = v.deep_clone}
+    when Array
+      klone = self.clone
+      klone.clear
+      self.each{|v| klone << v.deep_clone}
+    else
+      klone = self.clone
+    end
+    klone.instance_variables.each {|v|
+      klone.instance_variable_set(v,
+      klone.instance_variable_get(v).deep_clone)
+    }
+    klone
+  end
+
+  def send_unless method, *args, &block
+    ( block_given? ? yield : self ) or  send method, *args
+  end
+
+  def send_if     method, *args, &block
+    ( block_given? ? yield : self ) and send method, *args
+  end
+  
+  def to_name
+    Card::Name.new self
+  end
+end
+
+
+
+class Module
+  RUBY_VERSION_18 = !!(RUBY_VERSION =~ /^1\.8/)
+  
+  def const_get_if_defined const
+    args = RUBY_VERSION_18 ? [ const ] : [ const, false ]
+    if const_defined? *args
+      const_get *args
+    end
+  end
+  
+  def const_get_or_set const
+    const_get_if_defined const or const_set const, yield
+  end
+end
+
+
+
+class Hash
+  # FIXME: this is too ugly and narrow for a core extension.
+  class << self
+    def new_from_semicolon_attr_list(attr_string)
+      return {} if attr_string.blank?
+      attr_string.strip.split(';').inject({}) do |result, pair|
+        value, key = pair.split(':').reverse
+        key ||= 'view'
+        key.strip!; value.strip!
+        result[key.to_sym] = value
+        result
+      end
+    end
+  end
+
+end
+
+
+class Kaminari::Helpers::Tag
+  def page_url_for page
+    p = params_for(page)
+    p.delete :controller
+    p.delete :action
+    card = Card[p.delete('id')]
+    card.format.path  p
+  end
+  
+  private
+  
+  def params_for(page)
+    page_params = Rack::Utils.parse_nested_query("#{@param_name}=#{page}")
+    page_params = @params.with_indifferent_access.deep_merge(page_params)
+    
+    if Kaminari.config.respond_to?(:params_on_first_page) && !Kaminari.config.params_on_first_page && page <= 1
+      # This converts a hash:
+      #   from: {other: "params", page: 1}
+      #     to: {other: "params", page: nil}
+      #   (when @param_name == "page")
+      #
+      #   from: {other: "params", user: {name: "yuki", page: 1}}
+      #     to: {other: "params", user: {name: "yuki", page: nil}}
+      #   (when @param_name == "user[page]")
+      @param_name.to_s.scan(/\w+/)[0..-2].inject(page_params){|h, k| h[k] }[$&] = nil
+    end
+    
+    page_params
+  end
+end
+
+