card 1.18.6 → 1.19.0

data/lib/card/diff/lcs.rb

@@ -1,247 +0,0 @@
-class Card
-  class Diff
-    # Use LCS algorithm to create a Diff::Result
-    class LCS
-      def initialize opts
-        # regex; remove matches completely from diff
-        @reject_pattern = opts[:reject]
-        # regex; put matches back to the result after diff
-        @exclude_pattern = opts[:exclude]
-
-        @preprocess   = opts[:preprocess]  # block; called with every word
-        @postprocess  = opts[:postprocess] # block; called with complete diff
-
-        @splitters = %w( <[^>]+>  \[\[[^\]]+\]\]  \{\{[^}]+\}\}  \s+ )
-        @disjunction_pattern = /^\s/
-      end
-
-      def run old_text, new_text, result
-        @result = result
-        compare old_text, new_text
-        @result.complete = postprocess @result.complete
-      end
-
-      private
-
-      def compare old_text, new_text
-        if old_text
-          old_words, old_ex = separate_comparables_from_excludees old_text
-          new_words, new_ex = separate_comparables_from_excludees new_text
-          ChunkProcessor.new(old_words, new_words, old_ex, new_ex).run(@result)
-        else
-          list = split_and_preprocess(new_text)
-          if @exclude_pattern
-            list = list.reject { |word| word.match @exclude_pattern }
-          end
-          # CAUTION: postproces and added_chunk changed order
-          # and no longer postprocess for summary
-          @result.write_added_chunk list.join
-        end
-      end
-
-      def separate_comparables_from_excludees text
-        # return two arrays, one with all words, one with pairs
-        # (index in word list, html_tag)
-        list = split_and_preprocess text
-        if @exclude_pattern
-          check_exclude_and_disjunction_pattern list
-        else
-          [list, []]
-        end
-      end
-
-      def check_exclude_and_disjunction_pattern list
-        list.each_with_index.each_with_object([[], []]) do |pair, res|
-          element, index = pair
-          if element.match @disjunction_pattern
-            res[1] << { chunk_index: index, element: element,
-                        type: :disjunction }
-          elsif element.match @exclude_pattern
-            res[1] << { chunk_index: index, element: element, type:
-              :excludee }
-          else
-            res[0] << element
-          end
-        end
-      end
-
-      def split_and_preprocess text
-        splitted = split_to_list_of_words(text).select do |s|
-          !s.empty? && (!@reject_pattern || !s.match(@reject_pattern))
-        end
-        @preprocess ? splitted.map { |s| @preprocess.call(s) } : splitted
-      end
-
-      def split_to_list_of_words text
-        split_regex = /(#{@splitters.join '|'})/
-        text.split(split_regex)
-      end
-
-      def preprocess text
-        @preprocess ? @preprocess.call(text) : text
-      end
-
-      def postprocess text
-        @postprocess ? @postprocess.call(text) : text
-      end
-
-      # Compares two lists of chunks and generates a diff
-      class ChunkProcessor
-        attr_reader :result, :summary, :dels_cnt, :adds_cnt
-        def initialize old_words, new_words, old_excludees, new_excludees
-          @adds = []
-          @dels = []
-          @words = {
-            old: old_words,
-            new: new_words
-          }
-          @excludees = {
-            old: ExcludeeIterator.new(old_excludees),
-            new: ExcludeeIterator.new(new_excludees)
-          }
-        end
-
-        def run result
-          @result = result
-          prev_action = nil
-          ::Diff::LCS.traverse_balanced(@words[:old], @words[:new]) do |word|
-            if prev_action
-              if prev_action != word.action &&
-                 !(prev_action == '-' && word.action == '!') &&
-                 !(prev_action == '!' && word.action == '+')
-
-                # delete and/or add section stops here; write changes to result
-                write_dels
-                write_adds
-
-                # new neutral section starts
-                # we can just write excludees to result
-                write_excludees
-
-              else # current word belongs to edit of previous word
-                case word.action
-                when '-'
-                  del_old_excludees
-                when '+'
-                  add_new_excludees
-                when '!'
-                  del_old_excludees
-                  add_new_excludees
-                else
-                  write_excludees
-                end
-              end
-            else
-              write_excludees
-            end
-
-            process_word word
-            prev_action = word.action
-          end
-          write_dels
-          write_adds
-          write_excludees
-
-          @result
-        end
-
-        private
-
-        def write_unchanged text
-          @result.write_unchanged_chunk text
-        end
-
-        def write_dels
-          return if @dels.empty?
-          @result.write_deleted_chunk @dels.join
-          @dels = []
-        end
-
-        def write_adds
-          return if @adds.empty?
-          @result.write_added_chunk @adds.join
-          @adds = []
-        end
-
-        def write_excludees
-          while (ex = @excludees[:new].next)
-            @result.write_excluded_chunk ex[:element]
-          end
-        end
-
-        def del_old_excludees
-          while (ex = @excludees[:old].next)
-            if ex[:type] == :disjunction
-              @dels << ex[:element]
-            else
-              write_dels
-              @result.write_excluded_chunk ex[:element]
-            end
-          end
-        end
-
-        def add_new_excludees
-          while (ex = @excludees[:new].next)
-            if ex[:type] == :disjunction
-              @adds << ex[:element]
-            else
-              write_adds
-              @result.complete << ex[:element]
-            end
-          end
-        end
-
-        def process_word word
-          process_element word.old_element, word.new_element, word.action
-        end
-
-        def process_element old_element, new_element, action
-          case action
-          when '-'
-            minus old_element
-          when '+'
-            plus new_element
-          when '!'
-            minus old_element
-            plus new_element
-          else
-            write_unchanged new_element
-            @excludees[:new].word_step
-          end
-        end
-
-        def plus new_element
-          @adds << new_element
-          @excludees[:new].word_step
-        end
-
-        def minus old_element
-          @dels << old_element
-          @excludees[:old].word_step
-        end
-      end
-
-      class ExcludeeIterator
-        def initialize list
-          @list = list
-          @index = 0
-          @chunk_index = 0
-        end
-
-        def word_step
-          @chunk_index += 1
-        end
-
-        def next
-          if @index < @list.size &&
-             @list[@index][:chunk_index] == @chunk_index
-            res = @list[@index]
-            @index += 1
-            @chunk_index += 1
-            res
-          end
-        end
-      end
-    end
-  end
-end

data/lib/card/diff/result.rb

@@ -1,131 +0,0 @@
-class Card
-  class Diff
-    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::Diff.render_added_chunk(text)
-        @summary.add text
-      end
-
-      def write_deleted_chunk text
-        @dels_cnt += 1
-        @complete << Card::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
-
-      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 then Card::Diff.render_added_chunk text
-          when '-', :deleted then Card::Diff.render_deleted_chunk text
-          else text
-          end
-        end
-
-        def truncate_overlap
-          if @remaining_chars < 0
-            if @chunks.last[:action] == :ellipsis
-              @chunks.pop
-              @remaining_chars += @joint.size
-            end
-
-            index = @chunks.size - 1
-            while @remaining_chars < @joint.size && index >= 0
-              if @remaining_chars + @chunks[index][:text].size == @joint.size
-                replace_with_joint index
-                break
-              elsif @remaining_chars + @chunks[index][:text].size > @joint.size
-                cut_with_joint index
-                break
-              else
-                @remaining_chars += @chunks[index][:text].size
-                @chunks.delete_at(index)
-              end
-              index -= 1
-            end
-          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

data/lib/card/exceptions.rb

@@ -1,42 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-class Card
-  class Error < StandardError # code problem
-    cattr_accessor :current
-  end
-
-  class Oops < Error # wagneer problem (rename!)
-  end
-
-  class BadQuery < Error
-  end
-
-  class NotFound < StandardError
-  end
-
-  class PermissionDenied < Error
-    attr_reader :card
-
-    def initialize card
-      @card = card
-      super build_message
-    end
-
-    def build_message
-      if msg = @card.errors[:permission_denied]
-        "for card #{@card.name}: #{msg}"
-      else
-        super
-      end
-    end
-  end
-
-  class Abort < StandardError
-    attr_reader :status
-
-    def initialize status, msg=''
-      @status = status
-      super msg
-    end
-  end
-end

data/lib/card/loader.rb

@@ -1,181 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require_dependency 'card/set'
-require_dependency 'card/set_pattern'
-
-class Card
-  class << self
-    def config
-      Cardio.config
-    end
-
-    def paths
-      Cardio.paths
-    end
-  end
-
-  module Loader
-    class << self
-      def load_mods
-        load_set_patterns
-        load_formats
-        load_sets
-
-        refresh_script_and_style if ENV['RAILS_ENV'] == 'development'
-      end
-
-      def load_chunks
-        mod_dirs.each do |mod|
-          load_dir "#{mod}/chunk/*.rb"
-        end
-      end
-
-      def load_layouts
-        mod_dirs.inject({}) do |hash, mod|
-          dirname = "#{mod}/layout"
-          if File.exist? dirname
-            Dir.foreach(dirname) do |filename|
-              next if filename =~ /^\./
-              hash[filename.gsub /\.html$/, ''] =
-                File.read([dirname, filename].join('/'))
-            end
-          end
-          hash
-        end
-      end
-
-      def mod_dirs
-        @@mod_dirs ||= begin
-          Card.paths['mod'].existent.map do |dirname|
-            Dir.entries(dirname).sort.map do |filename|
-              "#{dirname}/#{filename}" if filename !~ /^\./
-            end.compact
-          end.flatten.compact
-        end
-      end
-
-      private
-
-      def refresh_script_and_style
-        update_if_source_file_changed Card[:all, :script]
-        update_if_source_file_changed Card[:all, :style]
-      end
-
-      # regenerates the machine output if a source file of a input card
-      # has been changed
-      def update_if_source_file_changed machine_card
-        mtime_output = machine_card.machine_output_card.updated_at
-        return unless mtime_output
-        source_files(machine_card).each do |path|
-          if File.mtime(path) > mtime_output
-            machine_card.update_machine_output
-            break
-          end
-        end
-      end
-
-      def source_files card
-        files = []
-        card.machine_input_card.extended_item_cards.each do |i_card|
-          next unless i_card.codename
-          next unless i_card.respond_to?(:existing_source_paths)
-          files << i_card.existing_source_paths
-        end
-        files.flatten
-      end
-
-      def load_set_patterns
-        generate_set_pattern_tmp_files if rewrite_tmp_files?
-        load_dir "#{Card.paths['tmp/set_pattern'].first}/*.rb"
-      end
-
-      def generate_set_pattern_tmp_files
-        prepare_tmp_dir 'tmp/set_pattern'
-        seq = 100
-        mod_dirs.each do |mod|
-          dirname = "#{mod}/set_pattern"
-          next unless Dir.exist? dirname
-          Dir.entries(dirname).sort.each do |filename|
-            m = filename.match(/^(\d+_)?([^\.]*).rb/)
-            key = m && m[2]
-            next unless key
-            filename = [dirname, filename].join('/')
-            SetPattern.write_tmp_file key, filename, seq
-            seq += 1
-          end
-        end
-      end
-
-      def load_formats
-        # cheating on load issues now by putting all inherited-from formats in
-        # core mod.
-        mod_dirs.each do |mod|
-          load_dir "#{mod}/format/*.rb"
-        end
-      end
-
-      def load_sets
-        generate_tmp_set_modules
-        load_tmp_set_modules
-        Set.process_base_modules
-        Set.clean_empty_modules
-      end
-
-      def generate_tmp_set_modules
-        return unless prepare_tmp_dir 'tmp/set'
-        seq = 1
-        mod_dirs.each do |mod_dir|
-          mod_tmp_dir = make_set_module_tmp_dir mod_dir, seq
-          Dir.glob("#{mod_dir}/set/**/*.rb").each do |abs_filename|
-            rel_filename = abs_filename.gsub "#{mod_dir}/set/", ''
-            tmp_filename = "#{mod_tmp_dir}/#{rel_filename}"
-            Set.write_tmp_file abs_filename, tmp_filename, rel_filename
-          end
-          seq += 1
-        end
-      end
-
-      def load_tmp_set_modules
-        patterns = Card.set_patterns.reverse.map(&:pattern_code)
-                       .unshift 'abstract'
-        Dir.glob("#{Card.paths['tmp/set'].first}/*").sort.each do |tmp_mod|
-          patterns.each do |pattern|
-            pattern_dir = "#{tmp_mod}/#{pattern}"
-            load_dir "#{pattern_dir}/**/*.rb" if Dir.exist? pattern_dir
-          end
-        end
-      end
-
-      def make_set_module_tmp_dir mod_dir, seq
-        modname = mod_dir.match(%r{[^/]+$})[0]
-        mod_tmp_dir = "#{Card.paths['tmp/set'].first}/mod#{'%03d' % seq}-#{modname}"
-        Dir.mkdir mod_tmp_dir
-        mod_tmp_dir
-      end
-
-      def prepare_tmp_dir path
-        return unless rewrite_tmp_files?
-        p = Card.paths[path]
-        FileUtils.rm_rf p.first, secure: true if p.existent.first
-        Dir.mkdir p.first
-      end
-
-      def rewrite_tmp_files?
-        if defined?(@@rewrite)
-          @@rewrite
-        else
-          @@rewrite = !(Rails.env.production? &&
-                      Card.paths['tmp/set'].existent.first)
-        end
-      end
-
-      def load_dir dir
-        Dir[dir].sort.each do |file|
-          # puts Benchmark.measure("from #load_dir: rd: #{file}") {
-          require_dependency file
-          # }.format('%n: %t %r')
-        end
-      end
-    end
-  end
-end