Pr0d1r2-geokit-cache 1.0.0

data/.document

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

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Marcin Nowicki
+
+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,18 @@
+= geokit-cache
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Marcin Nowicki. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "geokit-cache"
+    gem.summary = %Q{Geokit caching support }
+    gem.description = %Q{Caching support in database for locations geocoded by andre/geokit-gem}
+    gem.email = "pr0d1r2@ragnarson.com"
+    gem.homepage = "http://github.com/Pr0d1r2/geokit-cache"
+    gem.authors = ["Marcin Nowicki"]
+    gem.add_development_dependency "rspec"
+    gem.add_development_dependency "Pr0d1r2-active_record_connectionless"
+    gem.add_development_dependency "Pr0d1r2-active_record_geocodable"
+    gem.add_development_dependency "htmlentities"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "geokit-cache #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/generators/geokit_cache/geokit_cache_generator.rb

@@ -0,0 +1,27 @@
+class GeokitCachedGenerator < RspecModelGenerator
+
+  def initialize(runtime_args, runtime_options = {})
+    runtime_args = [
+      'GeokitCache',
+
+      'complete_address:string',
+
+      'provider:string',
+      'lng:float',
+      'lat:float',
+      'full_address:string',
+      'state:string',
+      'success:boolean',
+      'accuracy:integer',
+      'city:string',
+      'country_code:string',
+      'precision:string',
+      'street_address:string',
+      'zip:string',
+
+      'complete:boolean'
+    ]
+    super
+  end
+
+end

data/generators/geokit_cache/templates/model.rb

@@ -0,0 +1,5 @@
+class <%= class_name %> < ActiveRecord::Base
+
+  acts_as_geokit_cache
+
+end

data/generators/geokit_cache/templates/model_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../spec_helper')
+
+describe <%= class_name %> do
+
+  before(:each) do
+    @valid_attributes = {
+<% attributes.each_with_index do |attribute, attribute_index| -%>
+      :<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == attributes.length - 1 ? '' : ','%>
+<% end -%>
+    }
+  end
+
+  it "should create a new instance given valid attributes" do
+    <%= class_name %>.create!(@valid_attributes)
+  end
+
+end

data/lib/geokit-cache.rb

@@ -0,0 +1,2 @@
+require 'geokit/cache/model'
+require 'geokit/cache/active_record'

data/lib/geokit/cache/active_record.rb

@@ -0,0 +1,26 @@
+require 'active_record_geocodable'
+
+module Geokit
+  module Cache
+    module ActiveRecord
+
+      def acts_as_geokit_cache
+        include Geokit::Cache::Model
+        extend Geokit::Cache::Model::ClassMethods
+        is_geocodable :require => true
+      end
+
+      def is_geocodable(options = {})
+        super
+        if options[:cache]
+          define_method(:geocoder) do
+            options[:cache].to_s.singularize.camelize.constantize
+          end
+        end
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.extend(Geokit::Cache::ActiveRecord)

data/lib/geokit/cache/model.rb

@@ -0,0 +1,108 @@
+require 'rubygems'
+require 'htmlentities'
+require 'active_record_geocodable'
+
+module Geokit
+  module Cache
+    module Model
+
+      GEO_ATTRIBUTES = [
+        :provider,
+        :lng,
+        :lat,
+        :full_address,
+        :state,
+        :success,
+        :accuracy,
+        :city,
+        :country_code,
+        :precision,
+        :street_address,
+        :zip
+      ]
+      TEXT_ATTRIBUTES = [:city, :state, :full_address, :street_address]
+
+      def self.included(base)
+        base.class_eval do
+          before_save :decode_html_entities_in_text_attributes
+          is_geocodable :require => true
+          base.extend(ClassMethods)
+        end
+      end
+
+      def cache!(attributes)
+        self.attributes = attributes
+        save if new_record? || changed?
+      end
+
+      def set_instance_variables_from_geo!
+        GEO_ATTRIBUTES.each do |geo_attribute|
+          instance_variable_set(geo_attribute, geo.send(geo_attribute))
+        end
+      end
+
+      def update_action!
+        set_instance_variables_from_geo!
+        save if changed?
+      end
+
+      def needs_update?
+        !by_google? && geocoding_successful?
+      end
+
+      def update!
+        update_action! if needs_update?
+      end
+
+      def update_and_return!
+        update!
+        geoloc
+      end
+
+      def fake_geoloc
+        geoloc = Geokit::GeoLoc.new
+        GEO_ATTRIBUTES.each do |geo_attribute|
+          geoloc.instance_variable_set(geo_attribute, instance_variable_get(geo_attribute))
+        end
+        geoloc.success = success?
+        geoloc
+      end
+
+      def successful_geoloc
+        geo if geocoding_successful?
+      end
+
+      def geoloc
+        successful_geoloc || fake_geoloc
+      end
+
+      def by_google?
+        provider == 'google'
+      end
+
+      def changed_to_google?
+        by_google? && provider_changed?
+      end
+
+      def changed?
+        lat_changed? || lng_changed? || changed_to_google?
+      end
+
+      def decode_html_entities_in_text_attributes
+        TEXT_ATTRIBUTES.each {|a| self.send("#{a}=", HTMLEntities.new.decode(self.send(a)))} if geocoding_successful?
+      end
+
+      module ClassMethods
+        def geocode(complete_address)
+          record = find_or_create(complete_address)
+          record.update_and_return!
+        end
+
+        def find_or_create(complete_address)
+          find_by_complete_address(complete_address) || new(:complete_address => complete_address)
+        end
+      end
+
+    end
+  end
+end

data/spec/geokit-cache_spec.rb

@@ -0,0 +1,267 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'active_record_connectionless'
+
+class GeokitCache < ActiveRecord::Base
+  acts_as_geokit_cache
+  emulate_attribute :complete_address
+end
+
+class Example < ActiveRecord::Base
+  is_geocodable :cache => :geokit_cache
+  attr_accessor :complete_address
+end
+
+
+describe GeokitCache do
+
+  before(:each) do
+    @geokit_cache = GeokitCache.new
+    @geo = mock(Geokit::GeoLoc)
+  end
+
+  describe 'cache!' do
+    before(:each) do
+      @attributes = {:lat => 47, :lng => 47}
+      @geokit_cache.should_receive(:attributes=).with(@attributes)
+    end
+
+    it 'should save given attributes when record is new' do
+      @geokit_cache.should_receive(:save).and_return(true)
+      @geokit_cache.should_receive(:new_record?).and_return(true)
+      @geokit_cache.cache!(@attributes)
+    end
+
+    it 'should save given attributes when record changed' do
+      @geokit_cache.should_receive(:save).and_return(true)
+      @geokit_cache.should_receive(:new_record?).and_return(false)
+      @geokit_cache.should_receive(:changed?).and_return(true)
+      @geokit_cache.cache!(@attributes)
+    end
+
+    it 'should not save given attributes when record is new nor changed' do
+      @geokit_cache.should_not_receive(:save)
+      @geokit_cache.should_receive(:new_record?).and_return(false)
+      @geokit_cache.should_receive(:changed?).and_return(false)
+      @geokit_cache.cache!(@attributes)
+    end
+  end
+
+  it 'set_instance_variables_from_geo! should set instance variables located in geo' do
+    @geokit_cache.stub!(:geo).and_return(@geo)
+    GeokitCache::GEO_ATTRIBUTES.each do |geo_attribute|
+      @geo.should_receive(:send).with(geo_attribute).and_return(geo_attribute)
+      @geokit_cache.should_receive(:instance_variable_set).with(geo_attribute, geo_attribute)
+    end
+    @geokit_cache.set_instance_variables_from_geo!
+  end
+
+  describe 'update_action!' do
+    before(:each) do
+      @geokit_cache.stub!(:set_instance_variables_from_geo!)
+      @geokit_cache.stub!(:changed? => false)
+      @geokit_cache.update_action!
+    end
+
+    it 'should set instance variables located in geo' do
+      @geokit_cache.should_receive(:set_instance_variables_from_geo!)
+      @geokit_cache.update_action!
+    end
+
+    it 'should save when record changed' do
+      @geokit_cache.should_receive(:changed?).and_return(true)
+      @geokit_cache.should_receive(:save).and_return(true)
+      @geokit_cache.update_action!
+    end
+
+    it 'should not save when record not changed' do
+      @geokit_cache.should_receive(:changed?).and_return(false)
+      @geokit_cache.should_not_receive(:save)
+      @geokit_cache.update_action!
+    end
+  end
+
+  describe 'needs_update?' do
+    it 'should be true when record not from google and geo was successful' do
+      @geokit_cache.should_receive(:by_google?).and_return(false)
+      @geokit_cache.should_receive(:geocoding_successful?).and_return(true)
+      @geokit_cache.needs_update?.should be_true
+    end
+
+    it 'should be false when record already from google' do
+      @geokit_cache.should_receive(:by_google?).and_return(true)
+      @geokit_cache.needs_update?.should be_false
+    end
+
+    it 'should be false when record not from google and geo was not successful' do
+      @geokit_cache.should_receive(:by_google?).and_return(false)
+      @geokit_cache.should_receive(:geocoding_successful?).and_return(false)
+      @geokit_cache.needs_update?.should be_false
+    end
+  end
+
+  describe 'update!' do
+    it 'should update when needed' do
+      @geokit_cache.should_receive(:needs_update?).and_return(true)
+      @geokit_cache.should_receive(:update_action!).and_return(true)
+      @geokit_cache.update!.should be_true
+    end
+
+    it 'should not update when not needed' do
+      @geokit_cache.should_receive(:needs_update?).and_return(false)
+      @geokit_cache.should_not_receive(:update_action!)
+      @geokit_cache.update!.should be_nil
+    end
+  end
+
+  it 'update_and_return! should update record and return geoloc' do
+    @geokit_cache.should_receive(:update!).and_return(true)
+    @geokit_cache.should_receive(:geoloc).and_return(:geoloc)
+    @geokit_cache.update_and_return!.should == :geoloc
+  end
+
+  it 'fake_geoloc should return geoloc with attributes from record' do
+    GeokitCache::GEO_ATTRIBUTES.each do |geo_attribute|
+      @geokit_cache.should_receive(:instance_variable_get).with(geo_attribute).and_return(geo_attribute)
+      @geo.should_receive(:instance_variable_set).with(geo_attribute, geo_attribute)
+    end
+    @geokit_cache.should_receive(:success?).and_return(true)
+    @geo.should_receive(:success=).with(true)
+    Geokit::GeoLoc.should_receive(:new).and_return(@geo)
+    @geokit_cache.fake_geoloc.should == @geo
+  end
+
+  describe 'successful_geoloc' do
+    it 'should return geo when it is successful' do
+      @geokit_cache.should_receive(:geocoding_successful?).and_return(true)
+      @geokit_cache.should_receive(:geo).and_return(:geo)
+      @geokit_cache.successful_geoloc.should == :geo
+    end
+
+    it 'should return nil when geo is not successful' do
+      @geokit_cache.should_receive(:geocoding_successful?).and_return(false)
+      @geokit_cache.successful_geoloc.should be_nil
+    end
+  end
+
+  describe 'geoloc' do
+    it 'should return successful geoloc' do
+      @geokit_cache.should_receive(:successful_geoloc).and_return(:successful_geoloc)
+      @geokit_cache.geoloc.should == :successful_geoloc
+    end
+
+    it 'should return fake geoloc when there was no successful geoloc' do
+      @geokit_cache.should_receive(:successful_geoloc).and_return(nil)
+      @geokit_cache.should_receive(:fake_geoloc).and_return(:fake_geoloc)
+      @geokit_cache.geoloc.should == :fake_geoloc
+    end
+  end
+
+  describe 'by_google?' do
+    it 'should be true when provider is google' do
+      @geokit_cache.should_receive(:provider).and_return('google')
+      @geokit_cache.by_google?.should be_true
+    end
+
+    it 'should be true when provider is not google' do
+      @geokit_cache.should_receive(:provider).and_return('yahoo')
+      @geokit_cache.by_google?.should be_false
+    end
+  end
+
+  describe 'changed_to_google?' do
+    it 'should be true when geocoded by google and provider have been changed' do
+      @geokit_cache.should_receive(:by_google?).and_return(true)
+      @geokit_cache.should_receive(:provider_changed?).and_return(true)
+      @geokit_cache.changed_to_google?.should be_true
+    end
+
+    it 'should be false when geocoded by google but provider have not been changed' do
+      @geokit_cache.should_receive(:by_google?).and_return(true)
+      @geokit_cache.should_receive(:provider_changed?).and_return(false)
+      @geokit_cache.changed_to_google?.should be_false
+    end
+
+    it 'should be false when not geocoded by google' do
+      @geokit_cache.should_receive(:by_google?).and_return(false)
+      @geokit_cache.changed_to_google?.should be_false
+    end
+  end
+
+  describe 'changed?' do
+    before(:each) do
+      @geokit_cache.stub!(:lat_changed? => false, :lng_changed? => false, :changed_to_google? => false)
+    end
+
+    it 'should be true when lat changed' do
+      @geokit_cache.should_receive(:lat_changed?).and_return(true)
+      @geokit_cache.changed?.should be_true
+    end
+
+    it 'should be true when lng changed' do
+      @geokit_cache.should_receive(:lng_changed?).and_return(true)
+      @geokit_cache.changed?.should be_true
+    end
+
+    it 'should be true when changed to google' do
+      @geokit_cache.should_receive(:changed_to_google?).and_return(true)
+      @geokit_cache.changed?.should be_true
+    end
+
+    it 'should be false when none of requested changes occurs' do
+      @geokit_cache.changed?.should be_false
+    end
+  end
+
+
+  describe 'decode_html_entities_in_text_attributes' do
+    it 'should decode html-entities in all text attributes when geocoding was successful' do
+      @geokit_cache.should_receive(:geocoding_successful?).and_return(true)
+      GeokitCache::TEXT_ATTRIBUTES.each do |text_attribute|
+        @geokit_cache.should_receive(:send).with(text_attribute).and_return(text_attribute)
+        @geokit_cache.should_receive(:send).with("#{text_attribute}=", text_attribute.to_s)
+      end
+      @geokit_cache.decode_html_entities_in_text_attributes
+    end
+
+    it 'should not decode html-entities in any text attributes when geocoding was not successful' do
+      @geokit_cache.should_receive(:geocoding_successful?).and_return(false)
+      GeokitCache::TEXT_ATTRIBUTES.each do |text_attribute|
+        @geokit_cache.should_not_receive(:send).with(text_attribute)
+        @geokit_cache.should_not_receive(:send).with("#{text_attribute}=", text_attribute.to_s)
+      end
+      @geokit_cache.decode_html_entities_in_text_attributes
+    end
+  end
+
+  describe 'class method' do
+    it 'geocode should return geoloc for updated or new record' do
+      record = mock(GeokitCache)
+      record.should_receive(:update_and_return!)
+      GeokitCache.should_receive(:find_or_create).with(:complete_address).and_return(record)
+      GeokitCache.geocode(:complete_address)
+    end
+
+    describe 'find_or_create' do
+      it 'should return existing record' do
+        GeokitCache.should_receive(:find_by_complete_address).with(:complete_address).and_return(:record)
+        GeokitCache.find_or_create(:complete_address).should == :record
+      end
+
+      it 'should create new record when record does not exist in database' do
+        GeokitCache.should_receive(:find_by_complete_address).with(:complete_address)
+        GeokitCache.should_receive(:new).with(:complete_address => :complete_address).and_return(:new_record)
+        GeokitCache.find_or_create(:complete_address).should == :new_record
+      end
+    end
+  end
+
+end
+
+
+describe Example do
+
+  it 'geocoder should be GeokitCache' do
+    Example.new.geocoder.should == GeokitCache
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'geokit-cache'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: Pr0d1r2-geokit-cache
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Marcin Nowicki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: Pr0d1r2-active_record_connectionless
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: Pr0d1r2-active_record_geocodable
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: htmlentities
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Caching support in database for locations geocoded by andre/geokit-gem
+email: pr0d1r2@ragnarson.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- generators/geokit_cache/geokit_cache_generator.rb
+- generators/geokit_cache/templates/model.rb
+- generators/geokit_cache/templates/model_spec.rb
+- lib/geokit-cache.rb
+- lib/geokit/cache/active_record.rb
+- lib/geokit/cache/model.rb
+- spec/geokit-cache_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/Pr0d1r2/geokit-cache
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Geokit caching support
+test_files: 
+- spec/geokit-cache_spec.rb
+- spec/spec_helper.rb