clumpy 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c54e552fb799c83627510c3743f36d36682a955f
-  data.tar.gz: b153298fb72ae0ad278fce078aa85a52c9b18f5a
+  metadata.gz: 08e7eff2f7ea8e5cbfdfaeaf08844d831bb331d0
+  data.tar.gz: 906992f3fb8f0807b8f8e4a7637c5704ff56615e
 SHA512:
-  metadata.gz: 41ce0b359bdef855b1674e50eebb1798be6f5245446b8686a4bb8f7deb1e9a4311a33fbb3892b060297698591059686cd34bf465ea761c783d0e6797402a5fb3
-  data.tar.gz: afa4c35a0d83673e7de4daa6bd7025d257c9707b40a94356236d890b3084baa43f1bb9580f3e741911cefcaa2ca20ac9dab6aaa526b7e86ce66b7a25b6445434
+  metadata.gz: 1dd17137418eebd0270b3f8f8f97b99c2b98b6d574d50b54462c37b952f070c6a085a63e69337187736d07f3febe846955d3223a7f01e306c890591ccd3cc6af
+  data.tar.gz: 72ed5212c54be152b171a9067a57c3df44f8b8c1c3af54a6ac49aa22adc472dc0c89a727d32d9680ea1a7e4249d4c2becd1f4bcf5fcb57b6fe485371ce876ac9

data/.ruby-version

@@ -1 +1 @@
-2.1.4
+2.2.3

data/.travis.yml

@@ -0,0 +1,13 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.5
+  - 2.2.0
+
+script: "bundle exec rake spec"
+
+notifications:
+  disabled: false
+  recipients:
+    - johannes.opper@gmail.com

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 1.1.0
+## 2015-10-08
+- Respect map aspect ratio
+- Shrink cluster bounds to improve zooming behavior
+
 # 1.0.0
 ## 2014-10-30
 - Remove hit extensions, please provide a matching interface for hits by your own.

data/lib/clumpy/bounds.rb

@@ -1,9 +1,10 @@
 module Clumpy
   class Bounds
-    def initialize(latitude, longitude, side_length)
-      side_length ||= 10
-      @latitude  = (latitude - side_length)..(latitude + side_length)
-      @longitude = (longitude - side_length*2)..(longitude + side_length*2)
+    def initialize(latitude, longitude, width, length)
+      l = length / 2
+      w = width / 2
+      @latitude  = (latitude - l)..(latitude + l)
+      @longitude = (longitude - w)..(longitude + w)
     end
 
     attr_reader :latitude

data/lib/clumpy/builder.rb

@@ -42,15 +42,20 @@ module Clumpy
       clusters.find { |c| c.contains?(point) }
     end
 
-    def cluster_side_length
-      @cluster_size ||= (latitude_distance + longitude_distance) / @distance_modifier
+    def cluster_width
+      @cluster_width ||= longitude_distance / @distance_modifier
+    end
+
+    def cluster_length
+      @cluster_length ||= latitude_distance / @distance_modifier
     end
 
     def cluster_options
       {
         values_threshold: options[:values_threshold],
         include_values: options[:include_values],
-        side_length: cluster_side_length
+        width: cluster_width,
+        length: cluster_length,
       }
     end
 

data/lib/clumpy/cluster_behavior.rb

@@ -8,7 +8,7 @@ module Clumpy
       @points    = [point]
       @options   = options
 
-      @bounds    = Bounds.new(@latitude, @longitude, options[:side_length])
+      @bounds    = Bounds.new(@latitude, @longitude, options[:width], options[:length])
     end
 
     def contains?(point)
@@ -22,11 +22,22 @@ module Clumpy
     end
 
     def as_json(*)
+      bounds =  {
+        northeast: {
+          latitude: @points.map(&:latitude).max,
+          longitude: @points.map(&:longitude).max,
+        },
+        southwest: {
+          latitude: @points.map(&:latitude).min,
+          longitude: @points.map(&:longitude).min,
+        }
+      }
+
       {
         latitude:  latitude,
         longitude: longitude,
         size:      @points.size,
-        bounds:    @bounds.as_json,
+        bounds:    bounds,
         values:    value_list,
       }
     end

data/lib/clumpy/version.rb

@@ -1,3 +1,3 @@
 module Clumpy
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/spec/builder_spec.rb

@@ -10,66 +10,66 @@ describe Clumpy::Builder do
 
   it "takes points and options" do
     builder = Clumpy::Builder.new(points, { foo: :bar })
-    builder.points.should eq points
-    builder.options.should eq({ foo: :bar })
+    expect(builder.points).to eq points
+    expect(builder.options).to eq({ foo: :bar })
   end
 
   it "initializes the distance_modifier is none was given" do
     builder = Clumpy::Builder.new([])
-    builder.instance_variable_get(:@distance_modifier).should_not be_nil
+    expect(builder.instance_variable_get(:@distance_modifier)).not_to be_nil
   end
 
   it 'takes the given distance modifier' do
     builder = Clumpy::Builder.new([], distance_modifier: 12)
-    builder.instance_variable_get(:@distance_modifier).should eq 12
+    expect(builder.instance_variable_get(:@distance_modifier)).to eq 12
   end
 
   context "#cluster" do
     it "creates clusters from points" do
       clusters = builder.cluster
-      clusters.size.should eq 2
-      clusters.first.points.should eq [point1, point2]
-      clusters.last.points.should eq [point3]
+      expect(clusters.size).to eq 2
+      expect(clusters.first.points).to eq [point1, point2]
+      expect(clusters.last.points).to eq [point3]
     end
   end
 
   it "passes the values threshold through to the cluster" do
     builder = Clumpy::Builder.new([point1], values_threshold: 100, include_values: true)
-    builder.cluster_options.should eq({ values_threshold: 100, include_values: true, side_length: 33.128196875 })
+    expect(builder.cluster_options).to eq({ values_threshold: 100, include_values: true, width: 22, length: 10.628196875 })
     clusters = builder.cluster
-    clusters.first.instance_variable_get(:@options).should eq builder.cluster_options
+    expect(clusters.first.instance_variable_get(:@options)).to eq builder.cluster_options
   end
 
   context "#add_to_cluster" do
     it "creates a new cluster if there is no matching" do
-      builder.clusters.should be_empty
+      expect(builder.clusters).to be_empty
       builder.add_to_cluster(point1)
-      builder.clusters.size.should eq 1
+      expect(builder.clusters.size).to eq 1
     end
 
     it "will not create a cluster if the given value is not a true point" do
-      builder.clusters.should be_empty
+      expect(builder.clusters).to be_empty
       builder.add_to_cluster(:foo)
-      builder.clusters.should be_empty
+      expect(builder.clusters).to be_empty
     end
 
     it "appends markers to a existing cluster if they match" do
       builder.clusters << Clumpy::Cluster.new(point1, builder.cluster_options)
-      builder.clusters.size.should eq 1
-      builder.clusters.first.points.size.should eq 1
+      expect(builder.clusters.size).to eq 1
+      expect(builder.clusters.first.points.size).to eq 1
       builder.add_to_cluster(point2)
-      builder.clusters.size.should eq 1
-      builder.clusters.first.points.size.should eq 2
+      expect(builder.clusters.size).to eq 1
+      expect(builder.clusters.first.points.size).to eq 2
     end
   end
 
   it "calculates the latitude distance" do
-    builder.latitude_distance.should eq Clumpy::Builder::MAX_LATITUDE_DISTANCE
+    expect(builder.latitude_distance).to eq Clumpy::Builder::MAX_LATITUDE_DISTANCE
     builder.options = { nelat: -30, swlat: 40 }
-    builder.latitude_distance.should eq 70
+    expect(builder.latitude_distance).to eq 70
     builder.options = { nelat: -30, swlat: -35 }
-    builder.latitude_distance.should eq 5
+    expect(builder.latitude_distance).to eq 5
     builder.options = { nelat: 20, swlat: 35 }
-    builder.latitude_distance.should eq 15
+    expect(builder.latitude_distance).to eq 15
   end
 end

data/spec/cluster_behavior_spec.rb

@@ -3,58 +3,58 @@ require 'spec_helper'
 describe Clumpy::ClusterBehavior do
   let(:point)       { OpenStruct.new(latitude: 15, longitude: 20) }
   let(:other_point) { OpenStruct.new(latitude: 40, longitude: 40) }
-  let(:cluster)     { Clumpy::Cluster.new(point, side_length: 10) }
+  let(:cluster)     { Clumpy::Cluster.new(point, width: 20, length: 10) }
 
   it "has a nicish to_s representation" do
-    cluster.to_s.should include '# size: 1'
+    expect(cluster.to_s).to include '# size: 1'
   end
 
   it "has a json represtation as well" do
-    cluster.as_json.should have_key :size
-    cluster.as_json.should have_key :latitude
-    cluster.as_json.should have_key :longitude
-    cluster.as_json.should have_key :bounds
+    expect(cluster.as_json).to have_key :size
+    expect(cluster.as_json).to have_key :latitude
+    expect(cluster.as_json).to have_key :longitude
+    expect(cluster.as_json).to have_key :bounds
   end
 
   context "#reposition" do
     it "calculates new latitude and longitude values" do
       cluster.points << other_point
       cluster.reposition
-      cluster.latitude.should eq (15.0+40.0)/2.0
-      cluster.longitude.should eq (20.0+40.0)/2.0
+      expect(cluster.latitude).to eq (15.0+40.0)/2.0
+      expect(cluster.longitude).to eq (20.0+40.0)/2.0
     end
   end
 
   context "#value_list" do
     it "returns an empty array if threshold isn't reached" do
-      cluster = Clumpy::Cluster.new(point, values_threshold: 1)
+      cluster = Clumpy::Cluster.new(point, values_threshold: 1, width: 20, length: 10)
       cluster.points << other_point
-      cluster.value_list.should eq []
+      expect(cluster.value_list).to eq []
     end
 
     it "returns an array of json points if under threshold" do
-      cluster = Clumpy::Cluster.new(point, values_threshold: 1)
-      cluster.value_list.should eq [point]
+      cluster = Clumpy::Cluster.new(point, values_threshold: 1, width: 20, length: 10)
+      expect(cluster.value_list).to eq [point]
     end
 
     it "returns a list of values if include_values is true" do
-      cluster = Clumpy::Cluster.new(point, values_threshold: 0, include_values: true)
-      cluster.value_list.should eq [point]
+      cluster = Clumpy::Cluster.new(point, values_threshold: 0, include_values: true, width: 20, length: 10)
+      expect(cluster.value_list).to eq [point]
     end
 
     it "returns a empty list if include_values is false" do
-      cluster = Clumpy::Cluster.new(point, values_threshold: 10, include_values: false)
-      cluster.value_list.should eq []
+      cluster = Clumpy::Cluster.new(point, values_threshold: 10, include_values: false, width: 20, length: 10)
+      expect(cluster.value_list).to eq []
     end
   end
 
   context "#contains" do
     it "returns true if the given point is within the bounds" do
-      cluster.contains?(point).should eq true
+      expect(cluster.contains?(point)).to eq true
     end
 
     it "returns false for a points that isn't contained" do
-      cluster.contains?(other_point).should eq false
+      expect(cluster.contains?(other_point)).to eq false
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clumpy
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Johannes Opper
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-30 00:00:00.000000000 Z
+date: 2015-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,6 +77,7 @@ files:
 - ".rspec"
 - ".ruby-gemset"
 - ".ruby-version"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -112,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Cluster a bunch of points
@@ -120,3 +121,4 @@ test_files:
 - spec/builder_spec.rb
 - spec/cluster_behavior_spec.rb
 - spec/spec_helper.rb
+has_rdoc: