country_state_select 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02bf73bd8a9196b44064226453776133072796c9
-  data.tar.gz: df815b26922b16949f4c47ed724b20a042a73ba9
+  metadata.gz: 2c7cc9e30bebe46054458ff4145604012db5eeba
+  data.tar.gz: f378530aece9b4763fdfec46e6963c29ae3a038e
 SHA512:
-  metadata.gz: 2fadfdc4f7209ad09cdd7a172b23789518cc0f33717ad4e6ce153562d2c51006c9988d48965ee22e63a54a795b19023ca72faacdea50f3326ff0942513bedcbc
-  data.tar.gz: f1b5ce31078cf6740469c7f79dd9250ec8013dd7fcc0b618f6f0d1a93bd6bde12be41d038503f0592a8d291f9a20e4e6bd080e09328d065a75f1003a3717d5db
+  metadata.gz: 49807b5fe4c87a700b8f45eac6fbafbcdf7bab75beec9c94b70afaf7750074d5a1cd41e8aede34b20b119ec79bbbaabee7aa878763b3c789370e5df3690ad831
+  data.tar.gz: ccd794e1caf34f5ab5ac01910cd055e6f88c2ea348dd297bfdb177dd10fde1466282e032e4277c2959439fc814286b3ae27f775d12d68ba5cd80f6e2538e31fb

data/.travis.yml

@@ -6,4 +6,6 @@ rvm:
   - 2.1.2
 script:
   # ---if you written test cases then write commands here to run
+
   - bundle install
+  - rspec

data/README.md

@@ -1,22 +1,140 @@
 ##Country State Select [![Build Status](https://travis-ci.org/arvindvyas/Country-State-Select.svg?branch=master)](https://travis-ci.org/arvindvyas/Country-State-Select)  [![Code Climate](https://codeclimate.com/github/arvindvyas/Country-State-Select/badges/gpa.svg)](https://codeclimate.com/github/arvindvyas/Country-State-Select)
 
-Country State Select is library which gives you all the country names and when you select any country then it also create the other select box with all the states name of that country
+Country State Select is a library that provides an easy API to generate Country , State / Province  and City dropdowns for use in forms.
+
+When implemented correctly, a State / Province dropdown is filled with appropriate regions based upon what Country a user has selected .
+
+For instance, if a user chooses "United States of America" for a Country dropdown, the State dropdown will be filled with the 50 appropriate states plus the District of Columbia also then user can list city according to state selection but currently cities are limited.
+
+The data for Countries and States is populated by the excellent [city-state](https://github.com/loureirorg/city-state) gem. 
 
 #Getting Started
 
-Country State Select is released as a Ruby Gem. The gem is to be installed within a Ruby
-or Rails application. To install, simply add the following to your Gemfile.
+Country State Select is released as a Ruby Gem and requires the Rails environment as well.
+
+To install, simply add the following to your Gemfile.
 
     gem 'country_state_select'
   
-Run bundle install and don't forget to restart your server after you install a new gem.
+Then run 
+    
+    bundle install
+
+
+Don't forget to restart your server after you install it.
+
+
+## chosen JavaScript assets
+  The application makes use of the chosen-rails library for a better user experience.  This can be disabled if desired.  
+  
+  If you're using chosen-rails, please add the following to app/assets/javascripts/application.js:
   
+      //= require chosen-jquery
 
 
-##Contributing to Country State Select
+## chosen CSS assets
+
+  You'll also need to add the chosen-rails stylesheet.
 
-  Fork, fix, then send me a pull request.
+  If you're using chosen-rails, please add the following to app/assets/stylesheets/application.css:
+
+    *= require chosen
+
+ or
+    
+    @import "chosen";
+    
+    
+# Form Implementation in SimpleForm
+
+Implementation in a view is simple. 
+
+Just create a simple_form object like so:
+
+    <%= simple_form_for @form_object do |f| 
+      f.button :submit
+    end %>
+    
+Once your form object is created, add in fields for your user to select a Country and State / Province.      
+
+## Country Field
+
+To add the Country field, add an input field like the following:
+
+    <%= f.input :country_field, collection: CountryStateSelect.countries_collection %>
   
-##License
+The above code is simply a normal simple_form field object with a collection of countries passed to it using the CountryStateSelect library.  
+
+You can pass any of the normal options that a field object accepts - :label, :input_html, etc.    
+    
+## States / Provinces Field
+
+To list the States / Provinces, add an input field like the following:
+
+    <%= options = { form: f, field_names: { :country => :country_field, :state => :state_field } }
+    
+    f.input :state_field, CountryStateSelect.state_options(options) %>
+    
+It's important to note that the :country and :state keys in the :field_names object must contain the correct values in order for the correct States / Provinces to load into the window. 
+
+Other than that, it's yet another standard simple_form field object.  
+
+Any options that are valid in simple_form field can be passed into the options hash.
+
+# Required JavaScript
+
+The magic of the library is the JavaScript that is performed on the fields.  This JavaScript needs to be included in order for the proper State / Provinces to be selected based upon your Country selection.  
+
+Add this JavaScript to the page that is loading your form:
+
+    $(document).on('ready page:load', function() {
+      return CountryStateSelect({
+        country_id: "country_field_id",
+        state_id: "state_field_id"
+      });
+    });
+
+If you are using CoffeeScript, use the following:
+
+    $(document).on 'ready page:load', ->
+        CountryStateSelect({ country_id: "country_field_id", state_id: "state_field_id" })
+
+The country_id accepts the form ID for the country field.  The state_id accepts the form ID for the state field.
+
+The easiest way to determine the ID is to view the source in the web browser. (Or, you could set it in the options hash.)
+
+The ID being referred to is like the following in a select menu:
+
+    <select id="country_field_id"></select>
+   
+# chosen UI improvements (optional)
+
+The CountryStateSelect interface offers the option to turn the Chosen library on or off.  
+
+To turn it on, set it to true:
+
+    $(document).on('ready page:load', function() {
+      return CountryStateSelect({
+        chosen_ui: true,
+        ...
+        ...
+        ...
+      });
+    }); 
+
+To turn it off, set it to false:
+
+    $(document).on('ready page:load', function() {
+      return CountryStateSelect({
+        chosen_ui: false,
+        ...
+        ...
+        ...
+      });
+    });
+    
+
+##Contributing to Country State Select
 
-:include:license
+  Fork, fix, then send a pull request.
+ 

data/app/controllers/country_state_select/cscs_controller.rb

@@ -8,5 +8,14 @@ module CountryStateSelect
          format.json { render :json => csc.to_a}
       end
     end
+
+    # Sent it to state_id and  country id it will return cities of that states
+    def find_cities
+      cities = CS.cities(params[:state_id].to_sym, params[:country_id].to_sym)
+
+      respond_to do |format|
+         format.json { render :json => cities.to_a}
+      end
+    end
   end
 end

data/config/routes.rb

@@ -1,6 +1,6 @@
 Rails.application.routes.draw do
- scope :module => "country_state_select" do
-  post 'find_states' => 'cscs#find_states'
-  get 'find_states' => 'cscs#find_states'
-end
+  scope :module => "country_state_select" do
+    post 'find_states' => 'cscs#find_states'
+    post 'find_cities' => 'cscs#find_cities'
+  end
 end

data/country_state_select.gemspec

@@ -8,18 +8,24 @@ Gem::Specification.new do |spec|
   spec.version       = CountryStateSelect::VERSION
   spec.authors       = ["Arvind Vyas"]
   spec.email         = ["arvindvyas07@gmail.com"]
-  spec.summary       = %q{This is to list country and state.}
-  spec.description   = %q{Can list out country and according to that can list state dynamically.}
-  spec.homepage      = "https://github.com/arvindvyas/country_state_select.git"
+  spec.summary       = %q{Dynamically select Country and State.}
+  spec.description   = %q{Country State Select is a Ruby Gem that aims to make Country and State/Province selection a cinch in Ruby on Rails environments.}
+  spec.homepage      = "https://github.com/aldefouw/country_state_select.git"
   spec.license       = "MIT"
 
-  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  spec.files         = `git ls-files`.split("\n")
-  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  spec.require_paths = ['lib']
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'rails', '>= 3.0'
-  spec.add_runtime_dependency 'city-state'
   spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'pry'
+
+  spec.add_runtime_dependency 'rails'
+  spec.add_runtime_dependency 'simple_form', "~> 3.2"
+  spec.add_runtime_dependency 'chosen-rails', "~> 1.4"
+  spec.add_runtime_dependency 'compass-rails', '~> 2.0.4'
+  spec.add_runtime_dependency 'city-state'
 end

data/lib/country_state_select.rb

@@ -1,37 +1,48 @@
 require "country_state_select/version"
-require 'country_state_select/cst_data'
+require "city-state"
+require "rails"
+require "sass-rails"
+require "compass-rails"
+require "chosen-rails"
+require "simple_form"
 
 module CountryStateSelect
-  include CountryStateSelect::CstData
-  
-  def self.countries
-    CountryStateSelect::CstData.countries
+
+  #Collect the Countries
+  def self.countries_collection
+    CS.countries.except!(:COUNTRY_ISO_CODE).collect {|p| [ p[ 1], p[0] ] }.compact
   end
 
-  def self.india
-    CountryStateSelect::CstData.states("IN")
+  #Pass array of unwanted countries to get back all except those in the array
+  def self.countries_except(*except)
+    countries_collection.collect { |c| c unless except.include?(c.second) }.compact
   end
 
-  def self.us_states
-    CountryStateSelect::CstData.states("US")
+  #Return either the State (String) or States (Array)
+  def self.states_collection(f, options)
+    states = collect_states(f.object.send(options[:country]))
+    return f.object.send(options[:state]) if states.size == 0
+    states
   end
-  
-  def self.canadian_states
-    CountryStateSelect::CstData.states("CA")
+
+  #Return the collected States for a given Country
+  def self.collect_states(country)
+    CS.states(country).collect {|p| [ p[1], p[0] ] }.compact
   end
-  
-  def self.uk_states 
-    CountryStateSelect::CstData.states("GB")
+
+  #Return the cities of given state and country
+  def self.collect_cities(state_id = '', country_id = '')
+    CS.cities(state_id.to_sym, country_id.to_sym)
   end
 
-  #this method will provide the user to opetion to skip any countries in drop down list 
-  def self.countries_except(*except)
-    countries = []
-    self.countries.each do |country|
-      countries<< country unless  country.in?(except)
-    end
-    return countries
+  #Return a hash for use in the simple_form
+  def self.state_options(options)
+    states = states_collection(options[:form], options[:field_names])
+    options = options.merge(collection: states)
+    options = options.merge(:as => :string) if states.class == String
+    options
   end
+
 end
 
 case ::Rails.version.to_s

data/lib/country_state_select/version.rb

@@ -1,3 +1,3 @@
 module CountryStateSelect
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

data/spec/country_state_select_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe CountryStateSelect do
+
+  describe '#countries_collection' do
+    it 'does not include :COUNTRY_ISO_CODE' do
+      expect(CountryStateSelect.countries_collection).not_to include([:COUNTRY_ISO_CODE=>"country_name"])
+    end
+
+    it "returns an array" do
+      method_call = CountryStateSelect.countries_collection
+      expect(method_call.class).to eq(Array)
+    end
+
+    it "returns the value first and the key second" do
+      method_call = CountryStateSelect.countries_collection
+      expect(method_call.first.first).to eq("Andorra")
+      expect(method_call.first.second).to eq(:AD)
+    end
+  end
+
+  describe "#countries_except" do
+    let(:us) { ["United States", :US] }
+    let(:sm) { ["Saint Martin", :MF] }
+    let(:exceptions) {  [us, sm]  }
+
+    it 'does include the United States ordinarily' do
+      expect(CountryStateSelect.countries_except([])).to include(us)
+    end
+
+    it 'does include Saint Martin ordinarily' do
+      expect(CountryStateSelect.countries_except([])).to include(sm)
+    end
+
+    it 'does not include the United States or Saint Martin if we exclude them explicitly' do
+      expect(CountryStateSelect.countries_except(exceptions)).not_to include(exceptions)
+    end
+
+    it "returns the same result as #countries_collection if no exceptions are passed" do
+      expect(CountryStateSelect.countries_except()).to eq(CountryStateSelect.countries_collection)
+    end
+  end
+
+  describe '#states_collection' do
+    let(:f) { double( object: { }  ) }
+    let(:options) { { country: 'country_field_name', state: 'state_field_name' } }
+
+    it "should return 51 elements when we query for the United States" do
+      expect(f.object).to receive(:country_field_name).and_return('US') #Set the form Country Field to US
+
+      method_call = CountryStateSelect.states_collection(f, options)
+
+      expect(method_call.class).to eq(Array)
+      expect(method_call.size).to eq(51)
+    end
+
+    it "should return a String when we query for Saint Martin" do
+      expect(f.object).to receive(:country_field_name).and_return('MF') #Set the form Country Field to MF for Saint Martin
+      expect(f.object).to receive(:state_field_name).and_return('')
+
+      method_call = CountryStateSelect.states_collection(f, options)
+
+      expect(method_call.class).to eq(String)
+      expect(method_call.size).to eq(0)
+    end
+
+    it "should return the 'State from Form' if the Country requested returns no States" do
+      expect(f.object).to receive(:country_field_name).and_return('MF') #Set the form Country Field to MF for Saint Martin
+      expect(f.object).to receive(:state_field_name).and_return('State from Form')
+
+      method_call = CountryStateSelect.states_collection(f, options)
+
+      expect(method_call).to eq("State from Form")
+    end
+  end
+
+  describe '#states_options' do
+    let(:f) { double( object: {} ) }
+    let(:options) { { form: f,  label: "State / Province", field_names: { :country => :country_field_name, :state => :state_field_name } } }
+
+    it "should return a Hash" do
+      expect(f.object).to receive(:country_field_name).and_return('US')
+
+      method_call = CountryStateSelect.state_options(options)
+      expect(method_call.class).to eq(Hash)
+    end
+
+    it "should contain a key-value pair of as: => :string if no states are returned for the country" do
+      expect(f.object).to receive(:country_field_name).and_return('MF')
+      expect(f.object).to receive(:state_field_name).and_return('')
+
+      method_call = CountryStateSelect.state_options(options)
+      expect(method_call).to have_key(:as)
+      expect(method_call[:as]).to eq(:string)
+    end
+
+    it "should not return a key called 'as' if we want a dropdown" do
+      expect(f.object).to receive(:country_field_name).and_return('US')
+
+      method_call = CountryStateSelect.state_options(options)
+      expect(method_call).not_to have_key(:as)
+    end
+
+    it "should have a label if one has been set" do
+      expect(f.object).to receive(:country_field_name).and_return('US')
+
+      method_call = CountryStateSelect.state_options(options)
+      expect(method_call).to have_key(:label)
+      expect(method_call[:label]).to eq(options[:label])
+    end
+
+    it "should contain a collection of type Array if a country has states" do
+      expect(f.object).to receive(:country_field_name).and_return('US')
+
+      method_call = CountryStateSelect.state_options(options)
+      expect(method_call).to have_key(:collection)
+      expect(method_call[:collection].class).to eq(Array)
+    end
+
+    it "should contain a collection of type String if a country has no states" do
+      expect(f.object).to receive(:country_field_name).and_return('MF')
+      expect(f.object).to receive(:state_field_name).and_return('')
+
+      method_call = CountryStateSelect.state_options(options)
+      expect(method_call).to have_key(:collection)
+      expect(method_call[:collection].class).to eq(String)
+    end
+  end
+
+  describe '#collect_states' do
+    it "returns an array" do
+      method_call = CountryStateSelect.collect_states('US')
+      expect(method_call.class).to eq(Array)
+    end
+
+    it "returns the diffrent value for the key and value" do
+      method_call = CountryStateSelect.collect_states('US')
+      expect(method_call.first.first).not_to eq(method_call.first.second)
+    end
+
+    it "returns the value part of the key-value pair" do
+      method_call = CountryStateSelect.collect_states('US')
+      expect(method_call.first.first).to eq("Alaska")
+    end
+
+    it "returns an empty array if there are no states in that Country" do
+      method_call = CountryStateSelect.collect_states('MF')
+      expect(method_call).to eq([])
+    end
+  end
+
+  describe '#collect_cities' do
+
+    it "returns an array" do
+      method_call = CountryStateSelect.collect_cities(:mp, :in)
+      expect(method_call.class).to eq(Array)
+    end
+
+    it "it should return same value if city is not duplicate with state with out sending country" do
+      city_without_country = CountryStateSelect.collect_cities(:mp, '')
+      city_with_country = CountryStateSelect.collect_cities(:mp, :in)
+      expect(city_without_country).to eq(city_with_country)
+    end
+
+
+    it "returns an empty array if there are no states in that Country" do
+      method_call = CountryStateSelect.collect_cities('', '')
+      expect(method_call).to eq([])
+    end
+  end
+
+end