kingpin 0.5.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  rspec (~> 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jan Roesner
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= kingpin
+
+Description goes here.
+
+== Contributing to kingpin
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Jan Roesner. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "kingpin"
+  gem.homepage = "http://railspotting.de"
+  gem.license = "MIT"
+  gem.summary = %Q{Kingpin makes your ActiveRecord model a Pincaster pin and thus geosearcheable. Fast!}
+  gem.description = %Q{Kingpin extends every ActiveRecord model to become a Pincaster pin automatically. Thus the model automatically creates a Pincaster pin everytime it is saved. Kingpin afterwards provides methods at class and instance level that make geolocation easy and thanks to Pincaster amazingly fast.}
+  gem.email = "jan@roesner.it"
+  gem.authors = ["Jan Roesner"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "kingpin #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/kingpin.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{kingpin}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jan Roesner"]
+  s.date = %q{2011-03-11}
+  s.description = %q{Kingpin extends every ActiveRecord model to become a Pincaster pin automatically. Thus the model automatically creates a Pincaster pin everytime it is saved. Kingpin afterwards provides methods at class and instance level that make geolocation easy and thanks to Pincaster amazingly fast.}
+  s.email = %q{jan@roesner.it}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "kingpin.gemspec",
+    "lib/http_client.rb",
+    "lib/kingpin.rb",
+    "lib/pin_caster.rb",
+    "lib/pincaster.rb",
+    "lib/pincaster_layer.rb",
+    "lib/pincaster_pin.rb",
+    "spec/pincaster_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://railspotting.de}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Kingpin makes your ActiveRecord model a Pincaster pin and thus geosearcheable. Fast!}
+  s.test_files = [
+    "spec/pincaster_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/http_client.rb

@@ -0,0 +1,62 @@
+class HttpClient
+
+  require 'net/http'
+  require "cgi"
+  require "benchmark"
+
+  def initialize(protocol, host, port, namespace=nil)
+    @http = Net::HTTP.new(host, port)
+    @protocol = protocol
+    @host = host
+    @port = port
+    @namespace = namespace
+  end
+
+  def send_request(method, resource, headers=nil, data=nil, params=nil)
+    return self.send(method.to_s.downcase, headers, resource, data, params)
+  end
+
+  protected
+
+  # sends GET request and returns response
+  def get(headers, resource, data, params)
+    request = Net::HTTP::Get.new(build_uri(resource, params).request_uri, headers)
+    @http.request(request)
+  end
+
+  # sends PUT request and returns response
+  def put(headers, resource, data, params)
+    request = Net::HTTP::Put.new(resource_path(resource), headers)
+    request.body = params.nil? ? data.to_json : params.to_query
+    @http.request(request)
+  end
+
+  # sends POST request and returns response
+  def post(headers, resource, data, params)
+    request = Net::HTTP::Post.new(resource_path(resource), headers)
+    request.body = params.nil? ? data.to_json : params.to_query
+    @http.request(request)
+  end
+
+  # sends DELETE request and returns response
+  def delete(headers, resource, data, params)
+    request = Net::HTTP::Delete.new(resource_path(resource), headers)
+    @http.request(request)
+  end
+
+  # redefines the resource path including the namespace
+  def resource_path(resource)
+    @namespace.nil? ? resource : "/" + @namespace + resource
+  end
+
+  # rebuild a uri in details, so that another protocol, host, port and GET params can be specified, after Net::HTTP was created
+  def build_uri(resource, params=nil)
+    uri = URI.parse(@protocol + "://" + @host + ((@port.nil? || @port != "80") ? ":#{@port}" : ""))
+    uri.scheme = @protocol
+    uri.host = @host
+    uri.port = @port
+    uri.query = params.collect{ |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.reverse.join('&') if not params.nil?
+    uri.path = resource_path(resource)
+    uri
+  end
+end

data/lib/kingpin.rb

@@ -0,0 +1,103 @@
+###
+# Kingpin - makes models pinnable
+###
+
+module Kingpin
+  class << self.class.superclass
+    def pinnable(*args)
+      include KingpinInstanceMethods
+      self.kingpin_args = args
+      named_scope :nearby, lambda { |point, radius| { :conditions => ["id in (?)", point.nearby_ids(radius)] } }
+      after_save :autopin if !!args.first[:autopin]
+    end
+  end
+end
+
+###
+# PinInstanceMethods - provides models new instance methods
+###
+
+module KingpinInstanceMethods
+  def self.included(base)
+    base.extend KingpinClassMethods
+  end
+
+  # add a Pincaster record for self with in layer: self.class
+  def add_pin
+    Pincaster.add_record(self)
+  end
+
+  # returns the Pincaster pin for self
+  def pin
+    Pincaster.get_record(self)
+  end
+
+  # deletes the Pincaster pin for self
+  def delete_pin!
+    Pincaster.delete_record(self)
+  end
+
+  # returns nearby found record_ids in same layer as self, radius meters away, number of results limited to limit
+  def nearby_ids(radius, limit=nil)
+    JSON.parse(Pincaster.nearby(self, radius, limit))["matches"].map{|p| p["key"]}
+  end
+
+  # returns nearby found records in same layer as self, radius metera away, number of results limited to limit
+  def nearby(radius, limit=nil)
+    self.class.find(nearby_ids(radius, limit))
+  end
+
+  # returns objects longitude depending on configured method name for access as well as DEG or RAD configuration
+  def pin_lng
+    if self.class.kingpin_args.nil?
+      [:longitude, :long, :lng, :lgt, :lgdt].each do |l|
+        return self.send(l) if self.respond_to?(l)
+      end
+      return nil
+    else
+      if !!self.class.kingpin_args[:methods]
+        return !!self.class.kingpin_args[:rad] ? self.send(self.class.kingpin_args[:methods][:lng]).to_f * 180.0 / Math::PI : self.send(self.class.kingpin_args[:methods][:lng])
+      else
+        return self.send(self.class.kingpin_args[:methods][:lng])
+      end
+    end
+  end
+
+  # returns objects latitude depending on configured method name for access as well as DEG or RAD configuration
+  def pin_lat
+    if self.class.kingpin_args.nil?
+      [:latitude, :lati, :ltt, :ltd, :lat].each do |l|
+        return self.send(l) if self.respond_to?(l)
+      end
+      return nil
+    else
+      if !!self.class.kingpin_args[:methods]
+        return !!self.class.kingpin_args[:rad] ? self.send(self.class.kingpin_args[:methods][:lat]).to_f * 180.0 / Math::PI : self.send(self.class.kingpin_args[:methods][:lat])
+      else
+        return self.send(self.class.kingpin_args[:methods][:lat])
+      end
+    end
+  end
+
+  # automatically adds a pin for self in case autopin option was set to true for self's AR model
+  def autopin
+    self.add_pin
+  end
+
+end
+
+###
+# PinClassMethods - provides models new class methods
+###
+
+module KingpinClassMethods
+
+  def kingpin_args=(args)
+    @@kingpin_args = args
+  end
+
+  def kingpin_args
+    @@kingpin_args.first
+  end
+
+end

data/lib/pin_caster.rb

@@ -0,0 +1,89 @@
+require 'json'
+require 'pincaster_layer'
+require 'pincaster_pin'
+
+class Pincaster
+
+  @@http_client = HttpClient.new('http','localhost',4269)
+
+  # Pincaster server is still alive?
+  def self.is_alive?
+    @@http_client.send_request('GET', '/api/1.0/system/ping.json').code == "200" ? true : false rescue false
+  end
+
+  # shutdown Pincaster server immediately
+  def self.shutdown!
+    begin
+      @@http_client.send_request('POST', '/api/1.0/system/shutdown.json')
+    rescue Exception => e
+      case e.message
+      when "end of file reached"
+        return true
+      else
+        return false
+      end
+    end
+  end
+
+  # returns all known layers
+  def self.layers
+    JSON.parse(@@http_client.send_request('GET', '/api/1.0/layers/index.json').body)["layers"]
+  end
+
+  # returns true if Pincaster already has the given layer
+  def self.has_layer?(layer)
+    raise "Layer has to be a string" if not layer.is_a?(String)
+    self.layers.detect{|l| l["name"] == layer}.nil? ? false : true rescue false
+  end
+
+  # adds a new layer with name of the given string
+  def self.add_layer(layer)
+    raise "Layer has to be a string" if not layer.is_a?(String)
+    @@http_client.send_request('POST', "/api/1.0/layers/#{layer}.json").code == "200" ? true : false rescue false
+  end
+
+  # deletes the layer with the given name
+  def self.delete_layer!(layer)
+    raise "Layer has to be a string" if not layer.is_a?(String)
+    @@http_client.send_request('DELETE', "/api/1.0/layers/#{layer}.json").code == "200" ? true : false rescue false
+  end
+
+  # return a layer object for the layer that was searched for
+  def self.layer(layer)
+    raise "Layer has to be a string" if not layer.is_a?(String)
+    PincasterLayer.new(self.layers.select{|l| l["name"] == layer})
+  end
+
+  # adds a new record as well as creates a layer for it if the latter does not exist already
+  def self.add_record(record)
+    raise "Can't add a record without geocoordinates lng, lat" if record.pin_lng.nil? or record.pin_lat.nil?
+    Pincaster.add_layer(record.class.to_s) if not Pincaster.has_layer?(record.class.to_s)
+    @@http_client.send_request('PUT',
+                               "/api/1.0/records/#{record.class.to_s}/#{record.id}.json",
+                               nil,
+                               nil,
+                               {:_loc => "#{record.pin_lat},#{record.pin_lng}"}).code == "200" ? true : false
+  end
+
+  # returns a pin object for the given ActiveRecord object
+  def self.get_record(record)
+    PincasterPin.new(JSON.parse(@@http_client.send_request('GET', "/api/1.0/records/#{record.class.to_s}/#{record.id}.json").body)) rescue nil
+  end
+
+  # deletes the Pincaster record for the given ActiveRecord object
+  def self.delete_record(record)
+    @@http_client.send_request('DELETE', "/api/1.0/records/#{record.class.to_s}/#{record.id}.json").code == "200" ? true : false
+  end
+
+  # returns all pins nearby given record, maximum radius meters away, returns limit number of pins
+  def self.nearby(record, radius, limit)
+    limit ||= 2000
+    raise "Given #{record.class.to_s} has not lng or lat." if record.pin_lng.nil? or record.pin_lat.nil?
+    @@http_client.send_request('GET',
+                               "/api/1.0/search/#{record.class.to_s}/nearby/#{record.pin_lat.to_s},#{record.pin_lng.to_s}.json",
+                               nil,
+                               nil,
+                               {:radius => radius.to_s, :limit => limit}).body
+  end
+
+end

data/lib/pincaster.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/*.rb"].each          { |file| require file }

data/lib/pincaster_layer.rb

@@ -0,0 +1,9 @@
+class PincasterLayer
+
+  attr_accessor :layer_hash
+
+  def initialize(layer_hash)
+    @layer_hash = layer_hash
+  end
+
+end

data/lib/pincaster_pin.rb

@@ -0,0 +1,13 @@
+class PincasterPin
+
+  attr_accessor :pin_hash
+
+  def initialize(pin_hash)
+    @pin_hash = pin_hash
+  end
+
+  # returns the ActiveRecord:id of this pin's matching ActiveRecord object
+  def id
+    @pin_hash["key"]
+  end
+end

data/spec/pincaster_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Pincaster" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'pincaster'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification 
+name: kingpin
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Jan Roesner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  name: rspec
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+description: Kingpin extends every ActiveRecord model to become a Pincaster pin automatically. Thus the model automatically creates a Pincaster pin everytime it is saved. Kingpin afterwards provides methods at class and instance level that make geolocation easy and thanks to Pincaster amazingly fast.
+email: jan@roesner.it
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- kingpin.gemspec
+- lib/http_client.rb
+- lib/kingpin.rb
+- lib/pin_caster.rb
+- lib/pincaster.rb
+- lib/pincaster_layer.rb
+- lib/pincaster_pin.rb
+- spec/pincaster_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://railspotting.de
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Kingpin makes your ActiveRecord model a Pincaster pin and thus geosearcheable. Fast!
+test_files: 
+- spec/pincaster_spec.rb
+- spec/spec_helper.rb