kingpin 0.5.1 → 0.6.0

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.6.0

data/config/kingpin.yml

@@ -0,0 +1,5 @@
+---
+protocol: http
+host: localhost
+port: 4269
+namespace: '/api/1.0'

data/kingpin.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{kingpin}
-  s.version = "0.5.1"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jan Roesner"]
@@ -25,11 +25,13 @@ Gem::Specification.new do |s|
     "README.rdoc",
     "Rakefile",
     "VERSION",
+    "config/kingpin.yml",
     "kingpin.gemspec",
     "lib/http_client.rb",
+    "lib/king_pin.rb",
     "lib/kingpin.rb",
-    "lib/pin_caster.rb",
     "lib/pincaster.rb",
+    "lib/pincaster_config.rb",
     "lib/pincaster_layer.rb",
     "lib/pincaster_pin.rb",
     "spec/pincaster_spec.rb",

data/lib/http_client.rb

@@ -2,7 +2,6 @@ class HttpClient
 
   require 'net/http'
   require "cgi"
-  require "benchmark"
 
   def initialize(protocol, host, port, namespace=nil)
     @http = Net::HTTP.new(host, port)
@@ -46,7 +45,7 @@ class HttpClient
 
   # redefines the resource path including the namespace
   def resource_path(resource)
-    @namespace.nil? ? resource : "/" + @namespace + 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

data/lib/king_pin.rb

@@ -0,0 +1,99 @@
+###
+# 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] rescue false)
+    end
+  end
+end
+
+###
+# KingpinInstanceMethods - 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 not !!self.class.kingpin_args[:methods]
+      [:longitude, :long, :lng, :lgt, :lgdt].each do |l|
+        if self.respond_to?(l)
+          return !!self.class.kingpin_args[:rad] ? self.send(l).to_f * 180 / Math::PI : self.send(l)
+        end
+      end
+      return nil
+    else
+      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])
+    end
+  end
+
+  # returns objects latitude depending on configured method name for access as well as DEG or RAD configuration
+  def pin_lat
+    if not !!self.class.kingpin_args[:methods]
+      [:latitude, :lati, :ltt, :ltd, :lat].each do |l|
+        if self.respond_to?(l)
+          return !!self.class.kingpin_args[:rad] ? self.send(l).to_f * 180 / Math::PI : self.send(l)
+        end
+      end
+      return nil
+    else
+      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])
+    end
+  end
+
+  # automatically adds a pin via after_save hook for self in case autopin option was set to true for self's AR model
+  def autopin
+    self.add_pin
+  end
+
+end
+
+###
+# KingpinClassMethods - provides models new class methods
+###
+
+module KingpinClassMethods
+
+  def kingpin_args=(args)
+    @@kingpin_args = args.empty? ? nil : args
+  end
+
+  def kingpin_args
+    @@kingpin_args.first rescue {:methods => nil, :rad => false, :autopin => false}
+  end
+
+end

data/lib/kingpin.rb

@@ -1,103 +1 @@
-###
-# 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
+Dir[File.dirname(__FILE__) + "/*.rb"].each          { |file| require file }

data/lib/pincaster.rb

@@ -1 +1,109 @@
-Dir[File.dirname(__FILE__) + "/*.rb"].each          { |file| require file }
+require 'json'
+require 'yaml'
+require 'pincaster_layer'
+require 'pincaster_pin'
+require 'pincaster_config'
+
+class Pincaster
+
+  # returns an existing http client properly configured or creates a new one once
+  def self.client
+    @@http_client ||= HttpClient.new(self.config.protocol, self.config.host, self.config.port, self.config.namespace)
+  end
+
+  # Pincaster server is still alive?
+  def self.is_alive?
+    self.client.send_request('GET', '/system/ping.json').code == "200" ? true : false rescue false
+  end
+
+  # shutdown Pincaster server immediately
+  def self.shutdown!
+    begin
+      self.client.send_request('POST', '/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(self.client.send_request('GET', '/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)
+    self.client.send_request('POST', "/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)
+    self.client.send_request('DELETE', "/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)
+    self.client.send_request('PUT',
+                               "/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(self.client.send_request('GET', "/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)
+    self.client.send_request('DELETE', "/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?
+    self.client.send_request('GET',
+                               "/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
+
+  # loads local config, or users one if he provided any
+  def self.load_config
+    begin
+      config = YAML.load_file(Rails.root.to_s + "/config/kingpin.yml")
+    rescue
+      config = YAML.load_file(File.dirname(__FILE__).to_s + "/../config/kingpin.yml")
+    end
+    PincasterConfig.new(config)
+  end
+
+  # returns config
+  def self.config
+    @@config ||= self.load_config
+  end
+
+end

data/lib/pincaster_config.rb

@@ -0,0 +1,17 @@
+class PincasterConfig
+
+  attr_accessor :raw_config
+
+  def initialize(config_hash)
+    @raw_config = config_hash
+    splat_config
+  end
+
+  def splat_config
+    @raw_config.each_pair do |key, value|
+      self.class.send(:attr_accessor, key.to_sym)
+      self.send(key.to_s+"=", value)
+    end
+  end
+
+end

data/lib/pincaster_layer.rb

@@ -1,9 +1,18 @@
 class PincasterLayer
 
-  attr_accessor :layer_hash
+  attr_reader :layer_hash
 
-  def initialize(layer_hash)
-    @layer_hash = layer_hash
+  def initialize(layer_array)
+    @layer_hash = layer_array.first
+    splat_layer
+  end
+
+  # provides an accessor for every pin value that came back from Pincaster
+  def splat_layer
+    @layer_hash.each_pair do |key, value|
+      self.class.send(:attr_accessor, key.to_sym)
+      self.send(key.to_s + "=", value)
+    end
   end
 
 end

data/lib/pincaster_pin.rb

@@ -1,13 +1,22 @@
 class PincasterPin
 
-  attr_accessor :pin_hash
+  attr_reader :pin_hash
 
   def initialize(pin_hash)
     @pin_hash = pin_hash
+    splat_pin
+  end
+
+  # provides an accessor for every pin value that came back from Pincaster
+  def splat_pin
+    @pin_hash.each_pair do |key, value|
+      self.class.send(:attr_accessor, key.to_sym)
+      self.send(key.to_s + "=", value)
+    end
   end
 
   # returns the ActiveRecord:id of this pin's matching ActiveRecord object
   def id
-    @pin_hash["key"]
+    key
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kingpin
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 7
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 1
-  version: 0.5.1
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Jan Roesner
@@ -98,11 +98,13 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- config/kingpin.yml
 - kingpin.gemspec
 - lib/http_client.rb
+- lib/king_pin.rb
 - lib/kingpin.rb
-- lib/pin_caster.rb
 - lib/pincaster.rb
+- lib/pincaster_config.rb
 - lib/pincaster_layer.rb
 - lib/pincaster_pin.rb
 - spec/pincaster_spec.rb

data/lib/pin_caster.rb

@@ -1,89 +0,0 @@
-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