cocoapods-dependency-html 0.0.1

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/cached_result.rb

@@ -0,0 +1,79 @@
+require 'active_record_inline_schema'
+
+class FuzzyMatch
+  class CachedResult < ::ActiveRecord::Base
+    if ::ActiveRecord::VERSION::STRING >= '3.2'
+      self.table_name = :fuzzy_match_cached_results
+    else
+      set_table_name :fuzzy_match_cached_results
+    end
+
+    class << self
+      def setup(from_scratch = false)
+        if from_scratch
+          connection.drop_table :fuzzy_match_cached_results rescue nil
+        end
+        auto_upgrade!
+      end
+    end
+
+    col :a_class
+    col :a
+    col :b_class
+    col :b
+    add_index [:a_class, :b_class, :a], :name => 'aba'
+    add_index [:a_class, :b_class, :b], :name => 'abb'
+    add_index [:a_class, :b_class, :a, :b], :name => 'abab'
+    
+    module ActiveRecordBaseExtension
+      # required options:
+      # :primary_key - what to call on this class
+      # :foreign_key - what to call on the other class
+      def cache_fuzzy_match_with(other_active_record_class, options)
+        other = other_active_record_class.to_s.singularize.camelcase
+        me = name
+        if me < other
+          a = me
+          b = other
+          primary_key = :a
+          foreign_key = :b
+        else
+          a = other
+          b = me
+          primary_key = :b
+          foreign_key = :a
+        end
+
+        # def aircraft
+        define_method other.underscore.pluralize do
+          other.constantize.where options[:foreign_key] => send("#{other.underscore.pluralize}_foreign_keys")
+        end
+  
+        # def flight_segments_foreign_keys
+        define_method "#{other.underscore.pluralize}_foreign_keys" do
+          fz = ::FuzzyMatch::CachedResult.arel_table
+          sql = fz.project(fz[foreign_key]).where(fz["#{primary_key}_class".to_sym].eq(self.class.name).and(fz["#{foreign_key}_class".to_sym].eq(other)).and(fz[primary_key].eq(send(options[:primary_key])))).to_sql
+          connection.select_values sql
+        end
+  
+        # def cache_aircraft!
+        define_method "cache_#{other.underscore.pluralize}!" do
+          other_class = other.constantize
+          primary_key_value = send options[:primary_key]
+          other_class.fuzzy_match.find_all(primary_key_value).each do |other_instance|
+            attrs = {}
+            attrs[primary_key] = primary_key_value
+            attrs["#{primary_key}_class"] = self.class.name
+            attrs[foreign_key] = other_instance.send options[:foreign_key]
+            attrs["#{foreign_key}_class"] = other
+            unless ::FuzzyMatch::CachedResult.exists? attrs
+              ::FuzzyMatch::CachedResult.create! attrs
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+::ActiveRecord::Base.extend ::FuzzyMatch::CachedResult::ActiveRecordBaseExtension

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/record.rb

@@ -0,0 +1,58 @@
+class FuzzyMatch
+  # Records are the tokens that are passed around when doing scoring and optimizing.
+  class Record #:nodoc: all
+    # "Foo's" is one word
+    # "North-west" is just one word
+    # "Bolivia," is just Bolivia
+    WORD_BOUNDARY = %r{\W*(?:\s+|$)}
+    EMPTY = [].freeze
+    BLANK = ''.freeze
+
+    attr_reader :original
+    attr_reader :read
+    attr_reader :stop_words
+
+    def initialize(original, options = {})
+      @original = original
+      @read = options[:read]
+      @stop_words = options.fetch(:stop_words, EMPTY)
+    end
+
+    def inspect
+      "w(#{clean.inspect})"
+    end
+
+    def clean
+      @clean ||= begin
+        memo = whole.dup
+        stop_words.each do |stop_word|
+          memo.gsub! stop_word, BLANK
+        end
+        memo.strip.freeze
+      end
+    end
+
+    def words
+      @words ||= clean.downcase.split(WORD_BOUNDARY).freeze
+    end
+
+    def similarity(other)
+      Similarity.new self, other
+    end
+
+    def whole
+      @whole ||= case read
+      when ::NilClass
+        original
+      when ::Numeric, ::String
+        original[read]
+      when ::Proc
+        read.call original
+      when ::Symbol
+        original.respond_to?(read) ? original.send(read) : original[read]
+      else
+        raise "Expected nil, a proc, or a symbol, got #{read.inspect}"
+      end.to_s.strip.freeze
+    end
+  end
+end

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/result.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require 'erb'
+require 'pp'
+
+class FuzzyMatch
+  class Result #:nodoc: all
+    EXPLANATION = <<-ERB
+#####################################################
+# SUMMARY
+#####################################################
+
+Needle: <%= needle.inspect %>
+Match:  <%= winner.inspect %>
+
+#####################################################
+# OPTIONS
+#####################################################
+
+<%= PP.pp(options, '') %>
+
+<% timeline.each_with_index do |event, index| %>
+(<%= index+1 %>) <%= event %>
+<% end %>
+ERB
+
+    attr_accessor :needle
+    attr_accessor :read
+    attr_accessor :haystack
+    attr_accessor :options
+    attr_accessor :groupings
+    attr_accessor :identities
+    attr_accessor :stop_words
+    attr_accessor :winner
+    attr_accessor :score
+    attr_reader :timeline
+
+    def initialize
+      @timeline = []
+    end
+    
+    def explain
+      $stdout.puts ::ERB.new(EXPLANATION, 0, '%<').result(binding)
+    end
+  end
+end

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/rule.rb

@@ -0,0 +1,17 @@
+class FuzzyMatch
+  # A rule characterized by a regexp. Abstract.
+  class Rule
+    attr_reader :regexp
+    
+    def initialize(regexp)
+      unless regexp.is_a?(::Regexp)
+        raise ArgumentError, "[FuzzyMatch] Rules must be set with Regexp objects, but got #{regexp.inspect} (#{regexp.class.name})"
+      end
+      @regexp = regexp
+    end
+    
+    def ==(other)
+      other.class == self.class and regexp == other.regexp
+    end
+  end
+end

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/rule/grouping.rb

@@ -0,0 +1,90 @@
+# require 'pry'
+class FuzzyMatch
+  class Rule
+    # "Record linkage typically involves two main steps: grouping and scoring..."
+    # http://en.wikipedia.org/wiki/Record_linkage
+    #
+    # Groupings effectively divide up the haystack into groups that match a pattern
+    #
+    # A grouping (formerly known as a blocking) comes into effect when a str matches.
+    # Then the needle must also match the grouping's regexp.
+    class Grouping < Rule
+      class << self
+        def make(regexps)
+          case regexps
+          when ::Regexp
+            new regexps
+          when ::Array
+            chain = regexps.flatten.map { |regexp| new regexp }
+            if chain.length == 1
+              chain[0] # not really a chain after all
+            else
+              chain.each { |grouping| grouping.chain = chain }
+              chain
+            end
+          else
+            raise ArgumentError, "[fuzzy_match] Groupings should be specified as single regexps or an array of regexps (got #{regexps.inspect})"
+          end
+        end
+      end
+
+      attr_accessor :chain
+
+      def inspect
+        memo = []
+        memo << "#{regexp.inspect}"
+        if chain
+          memo << "(#{chain.find_index(self)} of #{chain.length})"
+        end
+        memo.join ' '
+      end
+
+      def xmatch?(record)
+        if primary?
+          match?(record) and subs.none? { |sub| sub.match?(record) }
+        else
+          match?(record) and primary.match?(record)
+        end
+      end
+
+      def xjoin?(needle, straw)
+        if primary?
+          join?(needle, straw) and subs.none? { |sub| sub.match?(straw) } # maybe xmatch here?
+        else
+          join?(needle, straw) and primary.match?(straw)
+        end
+      end
+
+      protected
+
+      def primary?
+        chain ? (primary == self) : true
+        # not chain or primary == self
+      end
+
+      def primary
+        chain ? chain[0] : self
+      end
+
+      def subs
+        chain ? chain[1..-1] : []
+      end
+
+      def match?(record)
+        !!(regexp.match(record.whole))
+      end
+
+      def join?(needle, straw)
+        if straw_match_data = regexp.match(straw.whole)
+          if needle_match_data = regexp.match(needle.whole)
+            straw_match_data.captures.join.downcase == needle_match_data.captures.join.downcase
+          else
+            false
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/rule/identity.rb

@@ -0,0 +1,40 @@
+class FuzzyMatch
+  class Rule
+    # Identities take effect when needle and haystack both match a regexp
+    # Then the captured part of the regexp has to match exactly
+    class Identity < Rule
+      attr_reader :proc
+
+      def initialize(regexp_or_proc)
+        case regexp_or_proc
+        when Regexp
+          @regexp = regexp_or_proc
+        when Proc
+          @proc = regexp_or_proc
+        else
+          raise ArgumentError, "[FuzzyMatch] Identity must be set with either Regexp objects or Procs, but got #{regexp_or_proc.inspect} (#{regexp_or_proc.class.name})"
+        end
+      end
+
+      def ==(other)
+        other.class == self.class and (regexp ? regexp == other.regexp : proc == other.proc)
+      end
+
+      # Two strings are "identical" if they both match this identity and the captures are equal.
+      #
+      # Only returns true/false if both strings match the regexp.
+      # Otherwise returns nil.
+      def identical?(record1, record2)
+        if regexp
+          if (str1_match_data = regexp.match(record1.whole)) and (str2_match_data = regexp.match(record2.whole))
+            str1_match_data.captures.join.downcase == str2_match_data.captures.join.downcase
+          else
+            nil
+          end
+        else
+          proc.call record1.original, record2.original
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/score.rb

@@ -0,0 +1,30 @@
+require 'fuzzy_match/score/pure_ruby'
+require 'fuzzy_match/score/amatch'
+
+class FuzzyMatch
+  class Score
+    include Comparable
+    
+    attr_reader :str1
+    attr_reader :str2
+
+    def initialize(str1, str2)
+      @str1 = str1.downcase
+      @str2 = str2.downcase
+    end
+
+    def inspect
+      %{(dice=#{"%0.5f" % dices_coefficient_similar},lev=#{"%0.5f" % levenshtein_similar})}
+    end
+
+    def <=>(other)
+      a = dices_coefficient_similar
+      b = other.dices_coefficient_similar
+      if a.nan? or b.nan? or (by_dices_coefficient = (a <=> b)) == 0
+        levenshtein_similar <=> other.levenshtein_similar
+      else
+        by_dices_coefficient
+      end
+    end
+  end
+end

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/score/amatch.rb

@@ -0,0 +1,21 @@
+class FuzzyMatch
+  class Score
+    # be sure to `require 'amatch'` before you use this class
+    class Amatch < Score
+
+      def dices_coefficient_similar
+        @dices_coefficient_similar ||= if str1 == str2
+          1.0
+        elsif str1.length == 1 and str2.length == 1
+          0.0
+        else
+          str1.pair_distance_similar str2
+        end
+      end
+
+      def levenshtein_similar
+        @levenshtein_similar ||= str1.levenshtein_similar str2
+      end
+    end
+  end
+end

data/vendor/bundle/gems/fuzzy_match-2.0.4/lib/fuzzy_match/score/pure_ruby.rb

@@ -0,0 +1,94 @@
+class FuzzyMatch
+  class Score
+    class PureRuby < Score
+
+      SPACE = ' '
+
+      # http://stackoverflow.com/questions/653157/a-better-similarity-ranking-algorithm-for-variable-length-strings
+      def dices_coefficient_similar
+        @dices_coefficient_similar ||= begin
+          if str1 == str2
+            1.0
+          elsif str1.length == 1 and str2.length == 1
+            0.0
+          else
+            pairs1 = (0..str1.length-2).map do |i|
+              str1[i,2]
+            end.reject do |pair|
+              pair.include? SPACE
+            end
+            pairs2 = (0..str2.length-2).map do |i|
+              str2[i,2]
+            end.reject do |pair|
+              pair.include? SPACE
+            end
+            union = pairs1.size + pairs2.size
+            intersection = 0
+            pairs1.each do |p1|
+              0.upto(pairs2.size-1) do |i|
+                if p1 == pairs2[i]
+                  intersection += 1
+                  pairs2.slice!(i)
+                  break
+                end
+              end
+            end
+            (2.0 * intersection) / union
+          end
+        end
+      end
+
+      # extracted/adapted from the text gem version 1.0.2
+      # normalization added for utf-8 strings
+      # lib/text/levenshtein.rb
+      def levenshtein_similar
+        @levenshtein_similar ||= begin
+          if utf8?
+            unpack_rule = 'U*'
+          else
+            unpack_rule = 'C*'
+          end
+          s = str1.unpack(unpack_rule)
+          t = str2.unpack(unpack_rule)
+          n = s.length
+          m = t.length
+        
+          if n == 0 or m == 0
+            0.0
+          else
+            d = (0..m).to_a
+            x = nil
+            (0...n).each do |i|
+              e = i+1
+              (0...m).each do |j|
+                cost = (s[i] == t[j]) ? 0 : 1
+                x = [
+                  d[j+1] + 1, # insertion
+                  e + 1,      # deletion
+                  d[j] + cost # substitution
+                ].min
+                d[j] = e
+                e = x
+              end
+              d[m] = x
+            end
+            # normalization logic from https://github.com/flori/amatch/blob/master/ext/amatch_ext.c#L301
+            # if (b_len > a_len) {
+            #     result = rb_float_new(1.0 - ((double) v[p][b_len]) / b_len);
+            # } else {
+            #     result = rb_float_new(1.0 - ((double) v[p][b_len]) / a_len);
+            # }
+            1.0 - x.to_f / [n, m].max
+          end
+        end
+      end
+
+      private
+    
+      def utf8?
+        return @utf8_query if defined?(@utf8_query)
+        @utf8_query = (defined?(::Encoding) ? str1.encoding.to_s : $KCODE).downcase.start_with?('u')
+      end
+    end
+  end
+end