rgeo 1.1.2 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (77) hide show
  1. checksums.yaml +4 -4
  2. data/ext/geos_c_impl/extconf.rb +5 -3
  3. data/ext/geos_c_impl/factory.c +4 -4
  4. data/ext/geos_c_impl/geometry.c +1 -1
  5. data/lib/rgeo.rb +2 -4
  6. data/lib/rgeo/cartesian.rb +6 -16
  7. data/lib/rgeo/cartesian/analysis.rb +22 -20
  8. data/lib/rgeo/cartesian/bounding_box.rb +83 -79
  9. data/lib/rgeo/cartesian/calculations.rb +40 -38
  10. data/lib/rgeo/cartesian/factory.rb +134 -169
  11. data/lib/rgeo/cartesian/feature_classes.rb +2 -18
  12. data/lib/rgeo/cartesian/feature_methods.rb +37 -39
  13. data/lib/rgeo/cartesian/interface.rb +11 -9
  14. data/lib/rgeo/coord_sys.rb +9 -8
  15. data/lib/rgeo/coord_sys/cs/entities.rb +345 -303
  16. data/lib/rgeo/coord_sys/cs/factories.rb +30 -28
  17. data/lib/rgeo/coord_sys/cs/wkt_parser.rb +128 -126
  18. data/lib/rgeo/coord_sys/srs_database/{interface.rb → entry.rb} +26 -32
  19. data/lib/rgeo/coord_sys/srs_database/sr_org.rb +19 -17
  20. data/lib/rgeo/coord_sys/srs_database/url_reader.rb +21 -19
  21. data/lib/rgeo/error.rb +3 -1
  22. data/lib/rgeo/feature.rb +23 -34
  23. data/lib/rgeo/feature/curve.rb +2 -0
  24. data/lib/rgeo/feature/factory.rb +15 -13
  25. data/lib/rgeo/feature/factory_generator.rb +7 -5
  26. data/lib/rgeo/feature/geometry.rb +31 -29
  27. data/lib/rgeo/feature/geometry_collection.rb +6 -4
  28. data/lib/rgeo/feature/line.rb +2 -0
  29. data/lib/rgeo/feature/line_string.rb +3 -1
  30. data/lib/rgeo/feature/linear_ring.rb +2 -0
  31. data/lib/rgeo/feature/multi_curve.rb +2 -0
  32. data/lib/rgeo/feature/multi_line_string.rb +2 -0
  33. data/lib/rgeo/feature/multi_point.rb +2 -0
  34. data/lib/rgeo/feature/multi_polygon.rb +2 -0
  35. data/lib/rgeo/feature/multi_surface.rb +2 -0
  36. data/lib/rgeo/feature/point.rb +2 -0
  37. data/lib/rgeo/feature/polygon.rb +3 -1
  38. data/lib/rgeo/feature/surface.rb +2 -0
  39. data/lib/rgeo/feature/types.rb +107 -103
  40. data/lib/rgeo/geographic.rb +17 -27
  41. data/lib/rgeo/geographic/factory.rb +154 -199
  42. data/lib/rgeo/geographic/interface.rb +141 -137
  43. data/lib/rgeo/geographic/proj4_projector.rb +28 -23
  44. data/lib/rgeo/geographic/projected_feature_classes.rb +2 -18
  45. data/lib/rgeo/geographic/projected_feature_methods.rb +59 -49
  46. data/lib/rgeo/geographic/projected_window.rb +4 -2
  47. data/lib/rgeo/geographic/simple_mercator_projector.rb +41 -39
  48. data/lib/rgeo/geographic/spherical_feature_classes.rb +2 -18
  49. data/lib/rgeo/geographic/spherical_feature_methods.rb +67 -67
  50. data/lib/rgeo/geographic/spherical_math.rb +81 -87
  51. data/lib/rgeo/geos.rb +23 -34
  52. data/lib/rgeo/geos/capi_factory.rb +106 -135
  53. data/lib/rgeo/geos/capi_feature_classes.rb +19 -37
  54. data/lib/rgeo/geos/ffi_factory.rb +276 -297
  55. data/lib/rgeo/geos/ffi_feature_classes.rb +2 -20
  56. data/lib/rgeo/geos/ffi_feature_methods.rb +170 -166
  57. data/lib/rgeo/geos/interface.rb +25 -23
  58. data/lib/rgeo/geos/utils.rb +47 -39
  59. data/lib/rgeo/geos/zm_factory.rb +171 -185
  60. data/lib/rgeo/geos/zm_feature_classes.rb +2 -20
  61. data/lib/rgeo/geos/zm_feature_methods.rb +76 -72
  62. data/lib/rgeo/impl_helper.rb +1 -11
  63. data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb +72 -75
  64. data/lib/rgeo/impl_helper/basic_geometry_methods.rb +21 -23
  65. data/lib/rgeo/impl_helper/basic_line_string_methods.rb +57 -49
  66. data/lib/rgeo/impl_helper/basic_point_methods.rb +29 -25
  67. data/lib/rgeo/impl_helper/basic_polygon_methods.rb +31 -27
  68. data/lib/rgeo/impl_helper/math.rb +2 -0
  69. data/lib/rgeo/impl_helper/utils.rb +9 -15
  70. data/lib/rgeo/version.rb +3 -1
  71. data/lib/rgeo/wkrep.rb +20 -30
  72. data/lib/rgeo/wkrep/wkb_generator.rb +87 -84
  73. data/lib/rgeo/wkrep/wkb_parser.rb +93 -93
  74. data/lib/rgeo/wkrep/wkt_generator.rb +67 -63
  75. data/lib/rgeo/wkrep/wkt_parser.rb +172 -168
  76. metadata +17 -32
  77. data/lib/rgeo/feature/mixins.rb +0 -143
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  # -----------------------------------------------------------------------------
2
4
  #
3
5
  # GEOS implementation additions written in Ruby
@@ -9,72 +11,52 @@ module RGeo
9
11
  class ZMPointImpl # :nodoc:
10
12
  include ZMGeometryMethods
11
13
  include ZMPointMethods
12
-
13
- Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
14
14
  end
15
15
 
16
16
  class ZMLineStringImpl # :nodoc:
17
17
  include ZMGeometryMethods
18
18
  include ZMLineStringMethods
19
-
20
- Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
21
19
  end
22
20
 
23
21
  class ZMLinearRingImpl # :nodoc:
24
22
  include ZMGeometryMethods
25
23
  include ZMLineStringMethods
26
-
27
- Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
28
24
  end
29
25
 
30
26
  class ZMLineImpl # :nodoc:
31
27
  include ZMGeometryMethods
32
28
  include ZMLineStringMethods
33
-
34
- Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
35
29
  end
36
30
 
37
31
  class ZMPolygonImpl # :nodoc:
38
32
  include ZMGeometryMethods
39
33
  include ZMPolygonMethods
40
-
41
- Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
42
34
  end
43
35
 
44
36
  class ZMGeometryCollectionImpl # :nodoc:
45
37
  include ZMGeometryMethods
46
38
  include ZMGeometryCollectionMethods
47
-
48
- Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
49
39
  end
50
40
 
51
41
  class ZMMultiPointImpl # :nodoc:
52
42
  include ZMGeometryMethods
53
43
  include ZMGeometryCollectionMethods
54
-
55
- Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
56
44
  end
57
45
 
58
46
  class ZMMultiLineStringImpl # :nodoc:
59
47
  include ZMGeometryMethods
60
48
  include ZMGeometryCollectionMethods
61
49
  include ZMMultiLineStringMethods
62
-
63
- Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
64
50
  end
65
51
 
66
52
  class ZMMultiPolygonImpl # :nodoc:
67
53
  include ZMGeometryMethods
68
54
  include ZMGeometryCollectionMethods
69
55
  include ZMMultiPolygonMethods
70
-
71
- Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
72
56
  end
73
57
 
74
58
  class ZMGeometryImpl # :nodoc:
75
59
  include ZMGeometryMethods
76
-
77
- Feature::MixinCollection::GLOBAL.for_type(Feature::Geometry).include_in_class(self, true)
78
60
  end
79
61
  end
80
62
  end
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  # -----------------------------------------------------------------------------
2
4
  #
3
5
  # GEOS implementation additions written in Ruby
@@ -9,10 +11,10 @@ module RGeo
9
11
  module ZMGeometryMethods # :nodoc:
10
12
  include Feature::Instance
11
13
 
12
- def initialize(factory_, zgeometry_, mgeometry_)
13
- @factory = factory_
14
- @zgeometry = zgeometry_
15
- @mgeometry = mgeometry_
14
+ def initialize(factory, zgeometry, mgeometry)
15
+ @factory = factory
16
+ @zgeometry = zgeometry
17
+ @mgeometry = mgeometry
16
18
  end
17
19
 
18
20
  def inspect # :nodoc:
@@ -52,7 +54,7 @@ module RGeo
52
54
  end
53
55
 
54
56
  def envelope
55
- @factory._create_feature(nil, @zgeometry.envelope, @mgeometry.envelope)
57
+ @factory.create_feature(nil, @zgeometry.envelope, @mgeometry.envelope)
56
58
  end
57
59
 
58
60
  def as_text
@@ -72,81 +74,81 @@ module RGeo
72
74
  end
73
75
 
74
76
  def boundary
75
- @factory._create_feature(nil, @zgeometry.boundary, @mgeometry.boundary)
77
+ @factory.create_feature(nil, @zgeometry.boundary, @mgeometry.boundary)
76
78
  end
77
79
 
78
- def equals?(rhs_)
79
- @zgeometry.equals?(RGeo::Feature.cast(rhs_, self).z_geometry)
80
+ def equals?(rhs)
81
+ @zgeometry.equals?(RGeo::Feature.cast(rhs, self).z_geometry)
80
82
  end
81
83
 
82
- def disjoint?(rhs_)
83
- @zgeometry.disjoint?(RGeo::Feature.cast(rhs_, self).z_geometry)
84
+ def disjoint?(rhs)
85
+ @zgeometry.disjoint?(RGeo::Feature.cast(rhs, self).z_geometry)
84
86
  end
85
87
 
86
- def intersects?(rhs_)
87
- @zgeometry.intersects?(RGeo::Feature.cast(rhs_, self).z_geometry)
88
+ def intersects?(rhs)
89
+ @zgeometry.intersects?(RGeo::Feature.cast(rhs, self).z_geometry)
88
90
  end
89
91
 
90
- def touches?(rhs_)
91
- @zgeometry.touches?(RGeo::Feature.cast(rhs_, self).z_geometry)
92
+ def touches?(rhs)
93
+ @zgeometry.touches?(RGeo::Feature.cast(rhs, self).z_geometry)
92
94
  end
93
95
 
94
- def crosses?(rhs_)
95
- @zgeometry.crosses?(RGeo::Feature.cast(rhs_, self).z_geometry)
96
+ def crosses?(rhs)
97
+ @zgeometry.crosses?(RGeo::Feature.cast(rhs, self).z_geometry)
96
98
  end
97
99
 
98
- def within?(rhs_)
99
- @zgeometry.within?(RGeo::Feature.cast(rhs_, self).z_geometry)
100
+ def within?(rhs)
101
+ @zgeometry.within?(RGeo::Feature.cast(rhs, self).z_geometry)
100
102
  end
101
103
 
102
- def contains?(rhs_)
103
- @zgeometry.contains?(RGeo::Feature.cast(rhs_, self).z_geometry)
104
+ def contains?(rhs)
105
+ @zgeometry.contains?(RGeo::Feature.cast(rhs, self).z_geometry)
104
106
  end
105
107
 
106
- def overlaps?(rhs_)
107
- @zgeometry.overlaps?(RGeo::Feature.cast(rhs_, self).z_geometry)
108
+ def overlaps?(rhs)
109
+ @zgeometry.overlaps?(RGeo::Feature.cast(rhs, self).z_geometry)
108
110
  end
109
111
 
110
- def relate?(rhs_, pattern_)
111
- @zgeometry.relate?(RGeo::Feature.cast(rhs_, self).z_geometry, pattern_)
112
+ def relate?(rhs, pattern)
113
+ @zgeometry.relate?(RGeo::Feature.cast(rhs, self).z_geometry, pattern)
112
114
  end
113
115
  alias relate relate? # DEPRECATED
114
116
 
115
- def distance(rhs_)
116
- @zgeometry.distance(RGeo::Feature.cast(rhs_, self).z_geometry)
117
+ def distance(rhs)
118
+ @zgeometry.distance(RGeo::Feature.cast(rhs, self).z_geometry)
117
119
  end
118
120
 
119
121
  def buffer(distance_)
120
- @factory._create_feature(nil, @zgeometry.buffer(distance_), @mgeometry.buffer(distance_))
122
+ @factory.create_feature(nil, @zgeometry.buffer(distance_), @mgeometry.buffer(distance_))
121
123
  end
122
124
 
123
125
  def convex_hull
124
- @factory._create_feature(nil, @zgeometry.convex_hull, @mgeometry.convex_hull)
126
+ @factory.create_feature(nil, @zgeometry.convex_hull, @mgeometry.convex_hull)
125
127
  end
126
128
 
127
- def intersection(rhs_)
128
- rhs_ = RGeo::Feature.cast(rhs_, self)
129
- @factory._create_feature(nil, @zgeometry.intersection(rhs_.z_geometry), @mgeometry.intersection(rhs_.m_geometry))
129
+ def intersection(rhs)
130
+ rhs = RGeo::Feature.cast(rhs, self)
131
+ @factory.create_feature(nil, @zgeometry.intersection(rhs.z_geometry), @mgeometry.intersection(rhs.m_geometry))
130
132
  end
131
133
 
132
- def union(rhs_)
133
- rhs_ = RGeo::Feature.cast(rhs_, self)
134
- @factory._create_feature(nil, @zgeometry.union(rhs_.z_geometry), @mgeometry.union(rhs_.m_geometry))
134
+ def union(rhs)
135
+ rhs = RGeo::Feature.cast(rhs, self)
136
+ @factory.create_feature(nil, @zgeometry.union(rhs.z_geometry), @mgeometry.union(rhs.m_geometry))
135
137
  end
136
138
 
137
- def difference(rhs_)
138
- rhs_ = RGeo::Feature.cast(rhs_, self)
139
- @factory._create_feature(nil, @zgeometry.difference(rhs_.z_geometry), @mgeometry.difference(rhs_.m_geometry))
139
+ def difference(rhs)
140
+ rhs = RGeo::Feature.cast(rhs, self)
141
+ @factory.create_feature(nil, @zgeometry.difference(rhs.z_geometry), @mgeometry.difference(rhs.m_geometry))
140
142
  end
141
143
 
142
- def sym_difference(rhs_)
143
- rhs_ = RGeo::Feature.cast(rhs_, self)
144
- @factory._create_feature(nil, @zgeometry.sym_difference(rhs_.z_geometry), @mgeometry.sym_difference(rhs_.m_geometry))
144
+ def sym_difference(rhs)
145
+ rhs = RGeo::Feature.cast(rhs, self)
146
+ @factory.create_feature(nil, @zgeometry.sym_difference(rhs.z_geometry), @mgeometry.sym_difference(rhs.m_geometry))
145
147
  end
146
148
 
147
- def rep_equals?(rhs_)
148
- rhs_ = RGeo::Feature.cast(rhs_, self)
149
- rhs_.is_a?(self.class) && @factory.eql?(rhs_.factory) && @zgeometry.rep_equals?(rhs_.z_geometry) && @mgeometry.rep_equals?(rhs_.m_geometry)
149
+ def rep_equals?(rhs)
150
+ rhs = RGeo::Feature.cast(rhs, self)
151
+ rhs.is_a?(self.class) && @factory.eql?(rhs.factory) && @zgeometry.rep_equals?(rhs.z_geometry) && @mgeometry.rep_equals?(rhs.m_geometry)
150
152
  end
151
153
 
152
154
  alias eql? rep_equals?
@@ -156,27 +158,29 @@ module RGeo
156
158
  alias + union
157
159
  alias * intersection
158
160
 
159
- def _copy_state_from(obj_) # :nodoc:
160
- @factory = obj_.factory
161
- @zgeometry = obj_.z_geometry
162
- @mgeometry = obj_.m_geometry
161
+ def marshal_dump # :nodoc:
162
+ [@factory, @factory.marshal_wkb_generator.generate(self)]
163
163
  end
164
164
 
165
- def marshal_dump # :nodoc:
166
- [@factory, @factory._marshal_wkb_generator.generate(self)]
165
+ def marshal_load(data) # :nodoc:
166
+ copy_state_from(data[0].marshal_wkb_parser.parse(data[1]))
167
167
  end
168
168
 
169
- def marshal_load(data_) # :nodoc:
170
- _copy_state_from(data_[0]._marshal_wkb_parser.parse(data_[1]))
169
+ def encode_with(coder) # :nodoc:
170
+ coder["factory"] = @factory
171
+ coder["wkt"] = @factory.psych_wkt_generator.generate(self)
171
172
  end
172
173
 
173
- def encode_with(coder_) # :nodoc:
174
- coder_["factory"] = @factory
175
- coder_["wkt"] = @factory._psych_wkt_generator.generate(self)
174
+ def init_with(coder) # :nodoc:
175
+ copy_state_from(coder["factory"].psych_wkt_parser.parse(coder["wkt"]))
176
176
  end
177
177
 
178
- def init_with(coder_) # :nodoc:
179
- _copy_state_from(coder_["factory"]._psych_wkt_parser.parse(coder_["wkt"]))
178
+ private
179
+
180
+ def copy_state_from(obj)
181
+ @factory = obj.factory
182
+ @zgeometry = obj.z_geometry
183
+ @mgeometry = obj.m_geometry
180
184
  end
181
185
  end
182
186
 
@@ -230,8 +234,8 @@ module RGeo
230
234
  @zgeometry.num_points
231
235
  end
232
236
 
233
- def point_n(n_)
234
- @factory._create_feature(ZMPointImpl, @zgeometry.point_n(n_), @mgeometry.point_n(n_))
237
+ def point_n(n)
238
+ @factory.create_feature(ZMPointImpl, @zgeometry.point_n(n), @mgeometry.point_n(n))
235
239
  end
236
240
 
237
241
  def points
@@ -239,7 +243,7 @@ module RGeo
239
243
  zpoints_ = @zgeometry.points
240
244
  mpoints_ = @mgeometry.points
241
245
  zpoints_.size.times do |i_|
242
- result_ << @factory._create_feature(ZMPointImpl, zpoints_[i_], mpoints_[i_])
246
+ result_ << @factory.create_feature(ZMPointImpl, zpoints_[i_], mpoints_[i_])
243
247
  end
244
248
  result_
245
249
  end
@@ -255,23 +259,23 @@ module RGeo
255
259
  end
256
260
 
257
261
  def centroid
258
- @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
262
+ @factory.create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
259
263
  end
260
264
 
261
265
  def point_on_surface
262
- @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
266
+ @factory.create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
263
267
  end
264
268
 
265
269
  def exterior_ring
266
- @factory._create_feature(ZMLineStringImpl, @zgeometry.exterior_ring, @mgeometry.exterior_ring)
270
+ @factory.create_feature(ZMLineStringImpl, @zgeometry.exterior_ring, @mgeometry.exterior_ring)
267
271
  end
268
272
 
269
273
  def num_interior_rings
270
274
  @zgeometry.num_interior_rings
271
275
  end
272
276
 
273
- def interior_ring_n(n_)
274
- @factory._create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(n_), @mgeometry.interior_ring_n(n_))
277
+ def interior_ring_n(n)
278
+ @factory.create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(n), @mgeometry.interior_ring_n(n))
275
279
  end
276
280
 
277
281
  def interior_rings
@@ -279,7 +283,7 @@ module RGeo
279
283
  zrings_ = @zgeometry.interior_rings
280
284
  mrings_ = @mgeometry.interior_rings
281
285
  zrings_.size.times do |i_|
282
- result_ << @factory._create_feature(ZMLineStringImpl, zrings_[i_], mrings_[i_])
286
+ result_ << @factory.create_feature(ZMLineStringImpl, zrings_[i_], mrings_[i_])
283
287
  end
284
288
  result_
285
289
  end
@@ -295,15 +299,15 @@ module RGeo
295
299
  end
296
300
  alias size num_geometries
297
301
 
298
- def geometry_n(n_)
299
- @factory._create_feature(nil, @zgeometry.geometry_n(n_), @mgeometry.geometry_n(n_))
302
+ def geometry_n(n)
303
+ @factory.create_feature(nil, @zgeometry.geometry_n(n), @mgeometry.geometry_n(n))
300
304
  end
301
305
  alias [] geometry_n
302
306
 
303
307
  def each
304
308
  if block_given?
305
- num_geometries.times do |i_|
306
- yield geometry_n(i_)
309
+ num_geometries.times do |i|
310
+ yield geometry_n(i)
307
311
  end
308
312
  self
309
313
  else
@@ -311,7 +315,7 @@ module RGeo
311
315
  end
312
316
  end
313
317
 
314
- include ::Enumerable
318
+ include Enumerable
315
319
  end
316
320
 
317
321
  module ZMMultiLineStringMethods # :nodoc:
@@ -334,11 +338,11 @@ module RGeo
334
338
  end
335
339
 
336
340
  def centroid
337
- @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
341
+ @factory.create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
338
342
  end
339
343
 
340
344
  def point_on_surface
341
- @factory._create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
345
+ @factory.create_feature(ZMPointImpl, @zgeometry.centroid, @mgeometry.centroid)
342
346
  end
343
347
 
344
348
  def coordinates
@@ -1,15 +1,5 @@
1
- # -----------------------------------------------------------------------------
2
- #
3
- # Implementation helpers namespace for RGeo
4
- #
5
- # -----------------------------------------------------------------------------
1
+ # frozen_string_literal: true
6
2
 
7
- module RGeo
8
- module ImplHelper # :nodoc:
9
- end
10
- end
11
-
12
- # Implementation files
13
3
  require "rgeo/impl_helper/utils"
14
4
  require "rgeo/impl_helper/math"
15
5
  require "rgeo/impl_helper/basic_geometry_methods"
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  # -----------------------------------------------------------------------------
2
4
  #
3
5
  # Common methods for GeometryCollection features
@@ -7,41 +9,36 @@
7
9
  module RGeo
8
10
  module ImplHelper # :nodoc:
9
11
  module BasicGeometryCollectionMethods # :nodoc:
10
- def initialize(factory_, elements_)
11
- _set_factory(factory_)
12
- @elements = elements_.map do |elem_|
13
- elem_ = Feature.cast(elem_, factory_)
14
- raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
15
- elem_
12
+ attr_reader :elements
13
+
14
+ def initialize(factory, elements)
15
+ self.factory = factory
16
+ @elements = elements.map do |elem|
17
+ elem = Feature.cast(elem, factory)
18
+ raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
19
+ elem
16
20
  end
17
- _validate_geometry
21
+ validate_geometry
18
22
  end
19
23
 
20
24
  def num_geometries
21
25
  @elements.size
22
26
  end
23
27
 
24
- def geometry_n(n_)
25
- n_ < 0 ? nil : @elements[n_]
28
+ def geometry_n(n)
29
+ n < 0 ? nil : @elements[n]
26
30
  end
27
31
 
28
- def [](n_)
29
- @elements[n_]
32
+ def [](n)
33
+ @elements[n]
30
34
  end
31
35
 
32
- def each(&block_)
33
- @elements.each(&block_)
36
+ def each(&block)
37
+ @elements.each(&block)
34
38
  end
35
39
 
36
40
  def dimension
37
- unless defined?(@dimension)
38
- @dimension = -1
39
- @elements.each do |elem_|
40
- dim_ = elem_.dimension
41
- @dimension = dim_ if @dimension < dim_
42
- end
43
- end
44
- @dimension
41
+ @dimension ||= @elements.map(&:dimension).max || -1
45
42
  end
46
43
 
47
44
  def geometry_type
@@ -52,9 +49,9 @@ module RGeo
52
49
  @elements.size == 0
53
50
  end
54
51
 
55
- def rep_equals?(rhs_)
56
- if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @elements.size == rhs_.num_geometries
57
- rhs_.each_with_index { |p_, i_| return false unless @elements[i_].rep_equals?(p_) }
52
+ def rep_equals?(rhs)
53
+ if rhs.is_a?(self.class) && rhs.factory.eql?(@factory) && @elements.size == rhs.num_geometries
54
+ rhs.each_with_index { |p, i| return false unless @elements[i].rep_equals?(p) }
58
55
  else
59
56
  false
60
57
  end
@@ -62,30 +59,28 @@ module RGeo
62
59
 
63
60
  def hash
64
61
  @hash ||= begin
65
- hash_ = [factory, geometry_type].hash
66
- @elements.inject(hash_) { |h_, g_| (1_664_525 * h_ + g_.hash).hash }
62
+ hash = [factory, geometry_type].hash
63
+ @elements.inject(hash) { |h, g| (1_664_525 * h + g.hash).hash }
67
64
  end
68
65
  end
69
66
 
70
- def _copy_state_from(obj_) # :nodoc:
71
- super
72
- @elements = obj_._elements
73
- end
67
+ private
74
68
 
75
- def _elements # :nodoc:
76
- @elements
69
+ def copy_state_from(obj)
70
+ super
71
+ @elements = obj.elements
77
72
  end
78
73
  end
79
74
 
80
- module BasicMultiLineStringMethods # :nodoc:
81
- def initialize(factory_, elements_)
82
- _set_factory(factory_)
83
- @elements = elements_.map do |elem_|
84
- elem_ = Feature.cast(elem_, factory_, Feature::LineString, :keep_subtype)
85
- raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
86
- elem_
75
+ module BasicMultiLineStringMethods # :nodoc:
76
+ def initialize(factory, elements)
77
+ self.factory = factory
78
+ @elements = elements.map do |elem|
79
+ elem = Feature.cast(elem, factory, Feature::LineString, :keep_subtype)
80
+ raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
81
+ elem
87
82
  end
88
- _validate_geometry
83
+ validate_geometry
89
84
  end
90
85
 
91
86
  def geometry_type
@@ -97,43 +92,45 @@ module RGeo
97
92
  end
98
93
 
99
94
  def length
100
- @elements.inject(0.0) { |sum_, obj_| sum_ + obj_.length }
101
- end
102
-
103
- def _add_boundary(hash_, point_) # :nodoc:
104
- hval_ = [point_.x, point_.y].hash
105
- (hash_[hval_] ||= [point_, 0])[1] += 1
95
+ @elements.inject(0.0) { |sum, obj| sum + obj.length }
106
96
  end
107
97
 
108
98
  def boundary
109
- hash_ = {}
110
- @elements.each do |line_|
111
- if !line_.is_empty? && !line_.is_closed?
112
- _add_boundary(hash_, line_.start_point)
113
- _add_boundary(hash_, line_.end_point)
99
+ hash = {}
100
+ @elements.each do |line|
101
+ if !line.is_empty? && !line.is_closed?
102
+ add_boundary(hash, line.start_point)
103
+ add_boundary(hash, line.end_point)
114
104
  end
115
105
  end
116
- array_ = []
117
- hash_.each do |_hval_, data_|
118
- array_ << data_[0] if data_[1].odd?
106
+ array = []
107
+ hash.each do |_hval, data_|
108
+ array << data_[0] if data_[1].odd?
119
109
  end
120
- factory.multi_point([array_])
110
+ factory.multipoint([array])
121
111
  end
122
112
 
123
113
  def coordinates
124
114
  @elements.map(&:coordinates)
125
115
  end
116
+
117
+ private
118
+
119
+ def add_boundary(hash, point)
120
+ hval = [point.x, point.y].hash
121
+ (hash[hval] ||= [point, 0])[1] += 1
122
+ end
126
123
  end
127
124
 
128
125
  module BasicMultiPointMethods # :nodoc:
129
- def initialize(factory_, elements_)
130
- _set_factory(factory_)
131
- @elements = elements_.map do |elem_|
132
- elem_ = Feature.cast(elem_, factory_, Feature::Point, :keep_subtype)
133
- raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
134
- elem_
126
+ def initialize(factory, elements)
127
+ self.factory = factory
128
+ @elements = elements.map do |elem|
129
+ elem = Feature.cast(elem, factory, Feature::Point, :keep_subtype)
130
+ raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
131
+ elem
135
132
  end
136
- _validate_geometry
133
+ validate_geometry
137
134
  end
138
135
 
139
136
  def geometry_type
@@ -150,14 +147,14 @@ module RGeo
150
147
  end
151
148
 
152
149
  module BasicMultiPolygonMethods # :nodoc:
153
- def initialize(factory_, elements_)
154
- _set_factory(factory_)
155
- @elements = elements_.map do |elem_|
156
- elem_ = Feature.cast(elem_, factory_, Feature::Polygon, :keep_subtype)
157
- raise Error::InvalidGeometry, "Could not cast #{elem_}" unless elem_
158
- elem_
150
+ def initialize(factory, elements)
151
+ self.factory = factory
152
+ @elements = elements.map do |elem|
153
+ elem = Feature.cast(elem, factory, Feature::Polygon, :keep_subtype)
154
+ raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
155
+ elem
159
156
  end
160
- _validate_geometry
157
+ validate_geometry
161
158
  end
162
159
 
163
160
  def geometry_type
@@ -165,16 +162,16 @@ module RGeo
165
162
  end
166
163
 
167
164
  def area
168
- @elements.inject(0.0) { |sum_, obj_| sum_ + obj_.area }
165
+ @elements.inject(0.0) { |sum, obj| sum + obj.area }
169
166
  end
170
167
 
171
168
  def boundary
172
- array_ = []
173
- @elements.each do |poly_|
174
- array_ << poly_.exterior_ring unless poly_.is_empty?
175
- array_.concat(poly_.interior_rings)
169
+ array = []
170
+ @elements.each do |poly|
171
+ array << poly.exterior_ring unless poly.is_empty?
172
+ array.concat(poly.interior_rings)
176
173
  end
177
- factory.multi_line_string(array_)
174
+ factory.multilinestring(array)
178
175
  end
179
176
 
180
177
  def coordinates