Class: LinkParser::Linkage

Inherits:
Object show all
Defined in:
lib/linkparser/linkage.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(words = [], connections = []) ⇒ Linkage

Returns a new instance of Linkage.



32
33
34
35
 
# File 'lib/linkparser/linkage.rb', line 32

def initialize( words=[], connections=[] )
  @connections = connections
  @words = words
end

Instance Attribute Details

#connections ⇒ Object (readonly)

the connections of this linkage



38
39
40
 
# File 'lib/linkparser/linkage.rb', line 38

def connections
  @connections
end

#words ⇒ Object (readonly)

the words in this linkage



41
42
43
 
# File 'lib/linkparser/linkage.rb', line 41

def words
  @words
end

Instance Method Details

#add_connections(*connections) ⇒ Object Also known as: addConnections

add new connections to the list of connections



51
52
53
54
 
# File 'lib/linkparser/linkage.rb', line 51

def add_connections(*connections)
  @connections += connections
  self
end

#combine(other) ⇒ Object Also known as: +

Combine two linkages together.



44
45
46
47
 
# File 'lib/linkparser/linkage.rb', line 44

def combine(other)
  Linkage::new( @words.superimpose(other.words),
          @connections + other.connections )
end

#connected? ⇒ Boolean

returns whether the linkage is connected

Returns:

  • (Boolean) 


80
81
82
 
# File 'lib/linkparser/linkage.rb', line 80

def connected? 
  @words.length == @words.compact.length
end

#eql?(o) ⇒ Boolean

Equality based only on the “important” parts.

Returns:

  • (Boolean) 


90
91
92
 
# File 'lib/linkparser/linkage.rb', line 90

def eql?(o)
  @connections.sort.eql?(o.connections.sort)
end

#hash ⇒ Object

Hash on the only important part - the connections.



85
86
87
 
# File 'lib/linkparser/linkage.rb', line 85

def hash 
  @connections.sort.hash
end

#insert(connection, left, right, left_word, right_word) ⇒ Object

Inserts into this linkage the connection and words found in the supplied arguments.



59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/linkparser/linkage.rb', line 59

def insert(connection, left, right, left_word, right_word)
  @connections << connection
  if @words[left]
    @words[left].combine!(left_word)
  else
    @words[left] = left_word
  end
  if @words[right]
    @words[right].combine!(right_word)
  else
    @words[right] = right_word
  end
  self
end

#inspect ⇒ Object

string display



95
96
97
98
99
 
# File 'lib/linkparser/linkage.rb', line 95

def inspect
  result = @words.collect {|word| word.to_s}.join(" ") +
    " --- " + @connections.join(" ")
  #:TODO: ?
end

#to_s ⇒ Object

pretty string display



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/linkparser/linkage.rb', line 102

def to_s
  rows = [] # the diagram
  rows.unshift(@words.join(' ').split('')) # insert the words
  pos = 0
  starts = @words.map {|word| # the starting position of each word
    start = pos
    pos += word.to_s.length + 1
    start
  }
  offsets = @words.map {|word| word.to_s.length / 2}
  centers = (starts.zip(offsets)).map {|c| c[0]+c[1]} # where to attach connections to each word
  pos = 0
  spaces = [] # where there are spaces between words
  @words.each {|word|
    spaces << ((pos - 1)..(pos - 1)) if pos.nonzero?
    pos += word.to_s.length + 1
  }
  rows.unshift(Array.new(rows[0].length, " "))
  centers.each {|i| rows[0][i] = "|"}
  conns = @connections.dup
  until conns.empty?
    row = Array.new(rows[0].length, " ")
    these = []
    conns.delete_if {|conn| conn.length == (rows.length - 1) and these << conn}
    #:TODO: loops infinitely - need to use counter instead of rows.length
    #next if these.empty?
    these.each {|conn|
      first = centers[conn.lword.position]
      last = centers[conn.rword.position]
      span = (first..last)
      dist = span.to_a.length
      disp = "+" + conn.to_s + "+" # minimum display string
      if disp.length > dist
        #:TODO: *ack*
        # i will need to expand the spaces inbetween the words,
        # as well as between the connection arcs, and then
        # update the centers and spaces array.  this could be
        # done one space at a time, cycling through the possible
        # word gaps.
        space_affect = (spaces.index(spaces.find {|r| first <= r.first}))..(spaces.length - 1)
        cent_affect = (centers.index(centers.find {|i| first <= i}))..(centers.length - 1)
        until dist >= disp.length
          #:?:
          dist += 1
#               centers.map! {|i|
#                 cent_affect.member?(centers.index(i)) ? i + 1 : i
#               }
#               first = centers[conn.lword.position]
#               last = centers[conn.rword.position]
#               span = (first..last)
#               dist = span.to_a.length
        end
      elsif disp.length < dist
        side = true
        until disp.length >= dist
          if side
            disp[0] = "+-"
          else
            disp[-1] = "-+"
          end
          side = ! side
        end
      end
      first.upto(last) do |i|
        row[i] = disp.slice!(0).chr
      end
    }
    centers.each_with_index {|i,w|
      row[i] = "|" if row[i] == " " and
        conns.find {|conn| [conn.rword, conn.lword].include?(@words[w])}
    }
    rows.unshift(row)
  end
  return (rows.map {|row| row.join('')}).join("\n")
end

#to_str ⇒ Object

string conversion



179
180
181
 
# File 'lib/linkparser/linkage.rb', line 179

def to_str 
  @words.join(' ')
end

#valid? ⇒ Boolean

returns whether or not the linkage is valid

Returns:

  • (Boolean) 


75
76
77
 
# File 'lib/linkparser/linkage.rb', line 75

def valid? 
  (@connections.length + 1) >= @words.length
end