card 1.18.6 → 1.19.0

data/lib/card/content/diff/result.rb

@@ -0,0 +1,145 @@
+class Card
+  class Content
+    class Diff
+      # Result object for Diff processing
+      class Result
+        attr_accessor :complete, :summary, :dels_cnt, :adds_cnt
+        def initialize summary_opts=nil
+          @dels_cnt = 0
+          @adds_cnt = 0
+          @complete = ""
+          @summary = Summary.new summary_opts
+        end
+
+        def summary
+          @summary.rendered
+        end
+
+        def write_added_chunk text
+          @adds_cnt += 1
+          @complete << Card::Content::Diff.render_added_chunk(text)
+          @summary.add text
+        end
+
+        def write_deleted_chunk text
+          @dels_cnt += 1
+          @complete << Card::Content::Diff.render_deleted_chunk(text)
+          @summary.delete text
+        end
+
+        def write_unchanged_chunk text
+          @complete << text
+          @summary.omit
+        end
+
+        def write_excluded_chunk text
+          @complete << text
+        end
+
+        # Summary object for Diff processing
+        class Summary
+          def initialize opts
+            opts ||= {}
+            @remaining_chars = opts[:length] || 50
+            @joint = opts[:joint] || "..."
+
+            @summary = nil
+            @chunks = []
+          end
+
+          def rendered
+            @summary ||=
+              begin
+                truncate_overlap
+                @chunks.map do |chunk|
+                  render_chunk chunk[:action], chunk[:text]
+                end.join
+              end
+          end
+
+          def add text
+            add_chunk text, :added
+          end
+
+          def delete text
+            add_chunk text, :deleted
+          end
+
+          def omit
+            if @chunks.empty? || @chunks.last[:action] != :ellipsis
+              add_chunk @joint, :ellipsis
+            end
+          end
+
+          private
+
+          def add_chunk text, action
+            if @remaining_chars > 0
+              @chunks << { action: action, text: text }
+              @remaining_chars -= text.size
+            end
+          end
+
+          def render_chunk action, text
+            case action
+            when "+", :added
+              Card::Content::Diff.render_added_chunk text
+            when "-", :deleted
+              Card::Content::Diff.render_deleted_chunk text
+            else text
+            end
+          end
+
+          def truncate_overlap
+            return unless @remaining_chars < 0
+            process_ellipsis
+
+            index = @chunks.size - 1
+            while @remaining_chars < @joint.size && index >= 0
+              overlap_size = @remaining_chars + @chunks[index][:text].size
+              break if process_overlap overlap_size, index
+              index -= 1
+            end
+          end
+
+          def process_ellipsis
+            return unless @chunks.last[:action] == :ellipsis
+            @chunks.pop
+            @remaining_chars += @joint.size
+          end
+
+          def process_overlap overlap_size, index
+            if overlap_size == @joint.size
+              replace_with_joint index
+              true
+            elsif overlap_size > @joint.size
+              cut_with_joint index
+              true
+            else
+              @remaining_chars += @chunks[index][:text].size
+              @chunks.delete_at(index)
+              false
+            end
+          end
+
+          def cut_with_joint index
+            @chunks[index][:text] =
+              @chunks[index][:text][0..(@remaining_chars - @joint.size - 1)]
+            @chunks[index][:text] += @joint
+          end
+
+          def replace_with_joint index
+            @chunks.pop
+            if index - 1 >= 0
+              if @chunks[index - 1][:action] == :added
+                @chunks << { action: :ellipsis, text: @joint }
+              elsif @chunks[index - 1][:action] == :deleted
+                @chunks << { action: :added, text: @joint }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/content/parser.rb

@@ -1,74 +1,102 @@
-require_dependency 'card/content/chunk'
+require_dependency "card/content/chunk"
 
 class Card
   class Content
+    # The Content::Parser breaks content strings into an Array of "chunks",
+    # each of which may be an instance of a {Chunk} class or a simple String.
     class Parser
-      def initialize chunk_list
+      # @param chunk_list [Symbol] name of registered list of chunk classes
+      # to be used in parsing
+      # @see Card::Chunk.register_list
+      # @param content_object [Card::Content]
+      def initialize chunk_list, content_object
+        @content_object = content_object
         @chunk_list = chunk_list
       end
-      def parse content, content_object
-        chunks = []
-        return chunks unless content.is_a? String
 
-        position = last_position = 0
+      # break content string into an array of chunk objects and strings
+      # @param content [String]
+      # @return [Array]
+      def parse content
+        @content = content
+        @chunks = []
+        return @chunks unless content.is_a? String
+        @position = @last_position = 0
+        @interval_string = ""
+        parse_chunks
+        @chunks
+      end
+
+      private
+
+      def parse_chunks
         prefix_regexp = Chunk.get_prefix_regexp @chunk_list
-        interval_string = ''
+        match_prefices prefix_regexp
+        handle_remainder
+      end
+
+      def match_prefices prefix_regexp
+        while match_prefix prefix_regexp
+          @chunk_class = Chunk.find_class_by_prefix @prefix, @chunk_list
+          # get the chunk class from the prefix
+          content_slice = @content[@position..-1]
+          @match, @offset = @chunk_class.full_match content_slice, @prefix
+          # see whether the full chunk actually matches
+          # (as opposed to bogus prefix)
+          if @match # we have a chunk match
+            next if record_chunk
+          else # no match.  look at the next character
+            @position += 1
+          end
+          @interval_string += @content[@chunk_start..@position - 1]
+          # moving beyond the alleged chunk.
+          # append failed string to "nonchunk" string
+        end
+      end
 
-        while (prefix_match = content[position..-1].match(prefix_regexp))
-          prefix = prefix_match[0]
+      def match_prefix prefix_regexp
+        prefix_match = @content[@position..-1].match(prefix_regexp)
+        if prefix_match
+          @prefix = prefix_match[0]
           # prefix of matched chunk
-          chunk_start = prefix_match.begin(0) + position
+          @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]
+            @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
+          @position = @chunk_start
           # move scanning position up to beginning of chunk
+          true
+        end
+      end
 
-          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 unless interval_string.empty?
-              # add the nonchunk string to the chunk list
-              chunks << chunk_class.new(match, content_object)
-              # 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
-
-          next unless !match || !context_ok
-          interval_string += content[chunk_start..position - 1]
-          # moving beyond the alleged chunk.
-          # append failed string to "nonchunk" string
+      def record_chunk
+        @position += (@match.end(0) - @offset.to_i)
+        # move scanning position up to end of chunk
+        if !@chunk_class.context_ok? @content, @chunk_start
+          # make sure there aren't contextual reasons for ignoring this chunk
+          false
+        else
+          @chunks << @interval_string unless @interval_string.empty?
+          @interval_string = ""
+          # add the nonchunk string to the chunk list and
+          # reset interval string for next go-round
+          @chunks << @chunk_class.new(@match, @content_object)
+          # add the chunk to the chunk list
+          @last_position = @position
+          # note that the end of the chunk was the last place where a
+          # chunk was found (so far)
+          true
         end
+      end
 
-        if chunks.any? && last_position < content.size
-          remainder = content[last_position..-1]
+      def handle_remainder
+        if @chunks.any? && @last_position < @content.size
           # handle any leftover nonchunk string at the end of content
-          chunks << remainder
+          @chunks << @content[@last_position..-1]
         end
-
-        chunks
       end
     end
   end

data/lib/card/content/truncate.rb

@@ -0,0 +1,62 @@
+class Card
+  class Content
+    # tools for truncating content
+    module Truncate
+      ELLISPES_HTML = '<span class="closed-content-ellipses">...</span>'.freeze
+
+      def smart_truncate input, words=25
+        return if input.nil?
+        truncated, wordstring = truncate input, words
+        # nuke partial tags at end of snippet
+        wordstring.gsub!(/(<[^\>]+)$/, "")
+        wordstring = close_tags wordstring
+        wordstring += ELLISPES_HTML if truncated
+        # wordstring += '...' if wordlist.length > l
+        polish wordstring
+      end
+
+      def truncate input, words
+        wordlist = input.to_s.split
+        l = words.to_i - 1
+        l = 0 if l < 0
+        truncating = wordlist.length > l
+        wordstring = truncating ? wordlist[0..l].join(" ") : input.to_s
+        [truncating, wordstring]
+      end
+
+      def close_tags wordstring
+        tags = find_tags wordstring
+        tags.each { |t| wordstring += "</#{t}>" }
+        wordstring
+      end
+
+      def polish wordstring
+        wordstring.gsub! %r{<[/]?br[\s/]*>}, " "
+        # Also a hack -- get rid of <br>'s -- they make line view ugly.
+        wordstring.gsub! %r{<[/]?p[^>]*>}, " "
+        ## Also a hack -- get rid of <br>'s -- they make line view ugly.
+        wordstring
+      end
+
+      def find_tags wordstring
+        tags = []
+
+        # match tags with or without self closing (ie. <foo />)
+        wordstring.scan(%r{\<([^\>\s/]+)[^\>]*?\>}).each do |t|
+          tags.unshift(t[0])
+        end
+        # match tags with self closing and mark them as closed
+        wordstring.scan(%r{\<([^\>\s/]+)[^\>]*?/\>}).each do |t|
+          next unless (x = tags.index(t[0]))
+          tags.slice!(x)
+        end
+        # match close tags
+        wordstring.scan(%r{\</([^\>\s/]+)[^\>]*?\>}).each do |t|
+          next unless (x = tags.rindex(t[0]))
+          tags.slice!(x)
+        end
+        tags
+      end
+    end
+  end
+end

data/lib/card/director_register.rb

@@ -1,15 +1,25 @@
 class Card
   def act opts={}
-    if !DirectorRegister.act_card
+    if DirectorRegister.act_card
+      if DirectorRegister.act_card != self && !only_storage_phase
+        director.reset_stage
+        if opts && opts[:trash]
+          @action = :delete
+        else
+          identify_action
+        end
+        director.update_card self
+        self.only_storage_phase = true
+      end
+      main_act_block = false
+    else
       DirectorRegister.clear
       self.director = nil
       DirectorRegister.act_card = self
       main_act_block = true
-      if opts[:success]
-        Env[:success] = Success.new(cardname, Env.params[:success])
+      if opts && opts[:success]
+        Env[:success] = Env::Success.new(cardname, Env.params[:success])
       end
-    else
-      main_act_block = false
     end
     yield
   ensure
@@ -50,13 +60,22 @@ class Card
       end
 
       def fetch card, opts={}
-        directors[card] ||= Card.new_director card, opts
+        return directors[card] if directors[card]
+        directors.each_key do |dir_card|
+          return dir_card.director if dir_card.name == card.name
+        end
+        directors[card] = Card.new_director card, opts
       end
 
       def add director
         directors[director.card] = director
       end
 
+      def card_changed old_card
+        return unless (director = @directors.delete old_card)
+        add director
+      end
+
       def delete director
         return unless @directors
         @directors.delete director.card
@@ -70,6 +89,10 @@ class Card
         delete director
       end
 
+      def running_act?
+        (dir = DirectorRegister.act_director) && dir.running?
+      end
+
       def to_s
         directors.values.map(&:to_s).join "\n"
       end

data/lib/card/env.rb

@@ -1,32 +1,39 @@
-class Card
-  require 'card/location'
+require_dependency "card/env/location"
+require_dependency "card/env/location_history"
 
-  # Card::Env can differ for each request; Card.config should not
+class Card
+  # Card::Env is a module for containing the variable details of the environment
+  # in which Card operates.
+  #
+  # Env can differ for each request; Card.config should not.
   module Env
+    extend LocationHistory
+
+    SERIALIZABLE_ATTRIBUTES = ::Set.new [
+      :main_name, :params, :ip, :ajax, :html, :host, :protocol, :salt
+    ]
+
     class << self
       def reset args={}
-        @@env = { main_name: nil }
-
-        if (c = args[:controller])
-          self[:controller] = c
-          self[:session]    = c.request.session
-          self[:params]     = c.params
-          self[:ip]         = c.request.remote_ip
-          self[:ajax]       = c.request.xhr? || c.request.params[:simulate_xhr]
-          self[:html]       = [nil, 'html'].member?(c.params[:format])
-          self[:host]       = Card.config.override_host ||
-                              c.request.env['HTTP_HOST']
-          self[:protocol]   = Card.config.override_protocol ||
-                              c.request.protocol
-        end
+        @env = { main_name: nil }
+        return self unless (c = args[:controller])
+        self[:controller] = c
+        self[:session]    = c.request.session
+        self[:params]     = c.params
+        self[:ip]         = c.request.remote_ip
+        self[:ajax]       = assign_ajax(c)
+        self[:html]       = assign_html(c)
+        self[:host]       = assign_host(c)
+        self[:protocol]   = assign_protocol(c)
+        self
       end
 
       def [] key
-        @@env[key.to_sym]
+        @env[key.to_sym]
       end
 
       def []= key, value
-        @@env[key.to_sym] = value
+        @env[key.to_sym] = value
       end
 
       def params
@@ -38,7 +45,7 @@ class Card
       end
 
       def success cardname=nil
-        self[:success] ||= Card::Success.new(cardname, params[:success])
+        self[:success] ||= Env::Success.new(cardname, params[:success])
       end
 
       def localhost?
@@ -53,66 +60,42 @@ class Card
         !self[:controller] || self[:html]
       end
 
-      def method_missing method_id, *args
-        case args.length
-        when 0 then self[method_id]
-        when 1 then self[method_id] = args[0]
-        else super
-        end
-      end
-    end
-
-    # 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 LocationHistory
-      def location_history
-        session[:history] ||= [Card::Location.card_path('')]
-        session[:history].shift if session[:history].size > 5
-        session[:history]
+      def serialize
+        @env.select { |k, _v| SERIALIZABLE_ATTRIBUTES.include?(k) }
       end
 
-      def save_location card
-        return unless save_location?(card)
-        discard_locations_for card
-        session[:previous_location] =
-          Card::Location.card_path card.cardname.url_key
-        location_history.push previous_location
+      def deserialize! data
+        @env ||= {}
+        @env.update data
       end
 
-      def save_location? card
-        !Env.ajax? && Env.html? && card.known? && (card.codename != 'signin')
-      end
+      private
 
-      def previous_location
-        return unless location_history
-        session[:previous_location] ||= location_history.last
+      def assign_ajax c
+        c.request.xhr? || c.request.params[:simulate_xhr]
       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
-        session[:previous_location] = nil
+      def assign_html c
+        [nil, "html"].member?(c.params[:format])
       end
 
-      def save_interrupted_action uri
-        session[:interrupted_action] = uri
+      def assign_host c
+        Card.config.override_host || c.request.env["HTTP_HOST"]
       end
 
-      def interrupted_action
-        session.delete :interrupted_action
+      def assign_protocol c
+        Card.config.override_protocol || c.request.protocol
       end
 
-      def url_key_for_location location
-        (%r{/([^/]*$)} =~ location) ? Regexp.last_match[1] : nil
+      def method_missing method_id, *args
+        case args.length
+        when 0 then self[method_id]
+        when 1 then self[method_id] = args[0]
+        else super
+        end
       end
     end
-
-    extend LocationHistory
   end
-
-  Env.reset
 end
+
+Card::Env.reset