has_vcards 0.20.3 → 1.0.0.rc0

data/README.markdown

@@ -1,14 +0,0 @@
-has_vcards
-==========
-
-Rails plugin providing VCard like contact and address models and helpers.
-
-
-License
-=======
-
-Copyright (c) 2007-2010 Simon Hürlimann <simon.huerlimann@cyt.ch>
-Copyright (c) 2008 Agrabah <http://www.agrabah.ch>
-Copyright (c) 2007-2010 ZytoLabor <http://www.zyto-labor.com>
-
-Released under the MIT license.

data/app/controllers/directory_lookup_controller.rb

@@ -1,17 +0,0 @@
-class DirectoryLookupController < ApplicationController
-  def search
-    @selector = params[:selector]
-    vcard_params = extract_vcard_params(params, @selector)
-
-    @vcard = Vcard.new(vcard_params)
-    render 'vcards/directory_lookup'
-  end
-
-  private
-  def extract_vcard_params(params, selector)
-    keys = selector.delete(']').split('[');
-    vcard_params = params
-    keys.each {|key| vcard_params = vcard_params[key]}
-    return vcard_params
-  end
-end

data/app/controllers/phone_numbers_controller.rb

@@ -1,14 +0,0 @@
-class PhoneNumbersController < ApplicationController
-  # User inherited resources logic
-  inherit_resources
-  respond_to :html, :js
-
-  # Relations
-  optional_belongs_to :vcard
-
-  # Optionally support in place editing
-  if respond_to? :in_place_edit_for
-    in_place_edit_for :phone_number, :phone_number_type
-    in_place_edit_for :phone_number, :number
-  end
-end

data/app/controllers/vcards_controller.rb

@@ -1,20 +0,0 @@
-class VcardsController < ApplicationController
-  # User inherited resources logic
-  inherit_resources
-  respond_to :html, :js
-
-  def directory_lookup
-    @vcard = Vcard.find(params[:id])
-  end
-
-  def directory_update
-    @vcard = Vcard.find(params[:id])
-    new_params = params[:vcard].select{|key, value| ['family_name', 'given_name', 'street_address', 'postal_code', 'locality'].include?(key)}
-
-    @vcard.update_attributes(new_params)
-
-    @vcard.save
-
-    redirect_to @vcard.object
-  end
-end

data/app/helpers/has_vcards_helper.rb

@@ -1,13 +0,0 @@
-module HasVcardsHelper
-  def address(vcard, line_separator = '<br/>')
-    vcard.address_lines.map{|line| h(line)}.join(line_separator).html_safe
-  end
-
-  def full_address(vcard, line_separator = '<br/>')
-    vcard.full_address_lines.map{|line| h(line)}.join(line_separator).html_safe
-  end
-
-  def contact(vcard, line_separator = '<br/>', label_separator = ' ')
-    vcard.contact_lines(label_separator).map{|line| h(line)}.join(line_separator).html_safe
-  end
-end

data/app/input/zip_locality_input.rb

@@ -1,14 +0,0 @@
-class ZipLocalityInput < SimpleForm::Inputs::StringInput
-  def zip_codes
-    SwissMatch.zip_codes.map{|zip| zip.to_s}.inspect
-  end
-
-  def input
-    input_html_options[:type] = 'text'
-    input_html_options[:autocomplete] = 'off'
-    input_html_options['data-provide'] = 'typeahead'
-    input_html_options['data-source'] = zip_codes
-
-    super
-  end
-end

data/app/models/address.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-class Address < ActiveRecord::Base
-  # Access restrictions
-  attr_accessible :extended_address, :street_address, :post_office_box, :postal_code, :locality, :zip_locality
-
-  belongs_to :vcard
-
-  # Validations
-  include I18nHelpers
-
-  def validate_address
-    errors.add_on_blank(:postal_code)
-    errors.add_on_blank(:locality)
-
-    if street_address.blank? and extended_address.blank? and post_office_box.blank?
-      errors.add(:street_address, "#{t_attr(:street_address, Vcard)} #{I18n.translate('errors.messages.empty')}")
-      errors.add(:extended_address, "#{t_attr(:extended_address, Vcard)} #{I18n.translate('errors.messages.empty')}")
-      errors.add(:post_office_box, "#{t_attr(:post_office_box, Vcard)} #{I18n.translate('errors.messages.empty')}")
-    end
-  end
-
-  # Helpers
-  def to_s
-    I18n.translate('has_vcards.address.to_s',
-      :street_address => street_address,
-      :postal_code => postal_code,
-      :locality => locality
-    )
-  end
-
-  # Composed attributes
-  def zip_locality
-    "#{postal_code} #{locality}"
-  end
-
-  def zip_locality=(value)
-    self.postal_code, self.locality = value.split(' ', 2)
-  end
-end

data/app/models/honorific_prefix.rb

@@ -1,6 +0,0 @@
-# encoding: utf-8
-
-class HonorificPrefix < ActiveRecord::Base
-  # Access restrictions
-  attr_accessible :sex, :position, :name
-end

data/app/models/phone_number.rb

@@ -1,43 +0,0 @@
-class PhoneNumber < ActiveRecord::Base
-  # Access restrictions
-  attr_accessible :phone_number_type, :number
-
-  # Vcard association
-  belongs_to :vcard, :inverse_of => :contacts
-  belongs_to :object, :polymorphic => true
-
-  # Validation
-  validates_presence_of :number
-
-  # phone number types
-  scope :by_type, lambda {|value| where(:phone_number_type => value)}
-  scope :phone, by_type('phone')
-  scope :fax, by_type('fax')
-  scope :mobile, by_type('mobile')
-  scope :email, by_type('email')
-
-  def label
-    case phone_number_type
-    when 'phone'
-      "Tel:"
-    when 'fax'
-      "Fax:"
-    when 'mobile'
-      "Mob:"
-    when 'email'
-      "Mail:"
-    else
-      phone_number_type
-    end
-  end
-  
-  # String
-  def to_s(separator = " ", format = :default)
-    case format
-      when :label
-        return [label, number].compact.join(separator)
-      else
-        return number
-    end
-  end
-end

data/app/models/vcard.rb

@@ -1,112 +0,0 @@
-# encoding: utf-8
-
-module HasAddress
-  def self.included(base)
-    base.alias_method_chain :address, :autobuild
-  end
-
-  def address_with_autobuild
-    address_without_autobuild || build_address
-  end
-end
-
-class Vcard < ActiveRecord::Base
-  # Access restrictions
-  attr_accessible :full_name, :honorific_prefix, :family_name, :given_name
-
-  has_one :address, :autosave => true, :validate => true
-  accepts_nested_attributes_for :address
-  attr_accessible :address_attributes
-  delegate  :post_office_box, :extended_address, :street_address, :locality, :region, :postal_code, :country_name, :zip_locality, :to => :address
-  delegate  :post_office_box=, :extended_address=, :street_address=, :locality=, :region=, :postal_code=, :country_name=, :zip_locality=, :to => :address
-  attr_accessible :post_office_box, :extended_address, :street_address, :locality, :region, :postal_code, :country_name, :zip_locality
-  include HasAddress
-
-  has_many :addresses, :autosave => true, :validate => true
-  accepts_nested_attributes_for :addresses
-
-  scope :active, :conditions => {:active => true}
-  scope :by_name, lambda {|name| {:conditions => self.by_name_conditions(name)}}
-  scope :with_address, joins(:address).includes(:address)
-
-  belongs_to :object, :polymorphic => true
-
-  # Validations
-  include I18nHelpers
-
-  def validate_name
-    if full_name.blank?
-      errors.add(:full_name, "#{t_attr(:full_name, Vcard)} #{I18n.translate('errors.messages.empty')}")
-      errors.add(:family_name, "#{t_attr(:family_name, Vcard)} #{I18n.translate('errors.messages.empty')}")
-      errors.add(:given_name, "#{t_attr(:given_name, Vcard)} #{I18n.translate('errors.messages.empty')}")
-    end
-  end
-
-  # Convenience accessors
-  def full_name
-    result = read_attribute(:full_name)
-    result ||= [ family_name, given_name ].compact.join(' ')
-
-    return result
-  end
-
-  def abbreviated_name
-    return read_attribute(:full_name) if read_attribute(:full_name)
-
-    [given_name.try(:first).try(:upcase), family_name].compact.join(". ")
-  end
-
-  # Advanced finders
-  def self.by_name_conditions(name)
-    ['vcards.full_name LIKE :name OR vcards.family_name LIKE :name OR vcards.given_name LIKE :name OR vcards.nickname LIKE :name', {:name => name}]
-  end
-
-  def self.find_by_name(name)
-    self.find(:first, :conditions => self.by_name_conditions(name))
-  end
-
-  def self.find_all_by_name(name)
-    self.find(:all, :conditions => self.by_name_conditions(name))
-  end
-
-  # Helper methods
-  def address_lines
-    lines = [extended_address, street_address, post_office_box, "#{postal_code} #{locality}"]
-
-    # Only return non-empty lines
-    lines.map {|line| line.strip unless (line.nil? or line.strip.empty?)}.compact
-  end
-
-  def full_address_lines
-    lines = [honorific_prefix, full_name] + address_lines
-
-    # Only return non-empty lines
-    lines.map {|line| line.strip unless (line.nil? or line.strip.empty?)}.compact
-  end
-
-  def contact_lines(separator = " ")
-    lines = contacts.map{|p| p.to_s unless (p.number.nil? or p.number.strip.empty?)}
-
-    # Only return non-empty lines
-    lines.map {|line| line.strip unless (line.nil? or line.strip.empty?)}.compact
-  end
-
-  # Phone numbers
-  has_many :contacts, :class_name => 'PhoneNumber', :as => :object, :inverse_of => :vcard do
-    def build_defaults
-      ['Tel. geschäft', 'Tel. privat', 'Handy', 'E-Mail'].map{ |phone_number_type|
-        build(:phone_number_type => phone_number_type) unless exists?(:phone_number_type => phone_number_type)
-      }
-    end
-  end
-  accepts_nested_attributes_for :contacts, :reject_if => proc {|attributes| attributes['number'].blank? }, :allow_destroy => true
-  attr_accessible :contacts_attributes
-
-  # Salutation
-  def salutation
-    I18n.translate(honorific_prefix.presence || :default, :scope => 'salutation', :family_name => family_name, :default => :default)
-  end
-
-  # SwissMatch
-  include Vcard::DirectoryLookup
-end

data/app/models/vcard/directory_address.rb

@@ -1,21 +0,0 @@
-module Vcard::DirectoryAddress
-  def to_vcard
-    Vcard.new(
-      :given_name     => first_name,
-      :family_name    => family_name,
-      :street_address => street,
-      :postal_code    => zip_code,
-      :locality       => city
-    )
-  end
-
-  def to_vcard_attributes
-    {
-      :given_name     => first_name,
-      :family_name    => family_name,
-      :street_address => street,
-      :postal_code    => zip_code,
-      :locality       => city
-    }
-  end
-end

data/app/models/vcard/directory_lookup.rb

@@ -1,122 +0,0 @@
-module Vcard::DirectoryLookup
-  def map_for_directory
-    search = {}
-    search[:first_name] = given_name
-    search[:family_name] = family_name
-    search[:street] = street_address
-    search[:zip_code] = postal_code
-    search[:city] = locality
-
-    search
-  end
-
-  def directory_lookup(ignore_fields = [])
-    search = map_for_directory
-
-    search.reject!{|key, value| ignore_fields.include? key}
-
-    # TODO:
-    # We should fetch additional pages if the result indicates there
-    # are more pages.
-    ::SwissMatch.directory_service.addresses(search, :per_page => 10)
-  end
-
-  def directory_found?(ignore_fields = [])
-    directory_lookup(ignore_fields).present?
-  end
-
-  def normalize(value)
-    normalized_value = UnicodeUtils.downcase(value.to_s)
-    normalized_value.gsub!(/str\./, 'strasse')
-    normalized_value.gsub!(/str([ $])/, 'strasse\1')
-
-    normalized_value
-  end
-
-  def directory_matches(ignore_lookup_fields = [])
-    matches = directory_lookup(ignore_lookup_fields)
-    matches.map do |match|
-      search = map_for_directory
-
-      perfect = []
-      search.each do |key, value|
-        perfect << key if normalize(match.send(key)) == normalize(value)
-      end
-
-      partial = []
-      search.each do |key, value|
-        partial << key if value.present? && normalize(match.send(key)).include?(normalize(value))
-      end
-      partial -= perfect
-
-      bad = search.keys - perfect - partial - ignore_lookup_fields
-
-      {:address => match, :perfect => perfect, :partial => partial, :bad => bad, :ignore => ignore_lookup_fields}
-    end
-  end
-
-  def directory_filter(match, filter = {})
-    # Exact filters
-    filter[:perfect].each do |field|
-      return false unless match[:perfect].include?(field)
-    end if filter[:perfect]
-    filter[:partial].each do |field|
-      return false unless match[:partial].include?(field)
-    end if filter[:partial]
-    filter[:bad].each do |field|
-      return false unless match[:bad].include?(field)
-    end if filter[:bad]
-
-    # "Better than" filters
-    filter[:partial_or_perfect].each do |field|
-      return false unless match[:perfect].include?(field) || match[:partial].include?(field)
-    end if filter[:partial_or_perfect]
-
-    return true
-  end
-
-  def filtered_matches(filters)
-    ignores = filters.delete(:ignore) || []
-
-    directory_matches(ignores).collect do |match|
-      match[:address] if directory_filter(match, filters)
-    end.compact
-  end
-
-  # Everything matches
-  def perfect_matches
-    filtered_matches(:perfect => [:family_name, :first_name, :street, :city])
-  end
-
-  def perfect_match?
-    perfect_matches.present?
-  end
-
-  # Everything is found, given or family name does is partial match
-  def great_matches
-    filtered_matches(:partial_or_perfect => [:family_name, :first_name], :perfect => [:street, :city])
-  end
-
-  def great_match?
-    great_matches.present?
-  end
-
-  # Everything but given name matches, family name might be partial
-  def family_name_matches
-    filtered_matches(:ignore => [:first_name], :partial_or_perfect => [:family_name], :perfect => [:street, :city])
-  end
-
-  def family_name_match?
-    family_name_matches.present?
-  end
-
-  # Same address different names
-  def address_matches
-    filtered_matches(:ignore => [:first_name, :family_name], :perfect => [:street, :city])
-  end
-
-  # Similar name in same locality
-  def locality_matches
-    filtered_matches(:ignore => [:first_name, :street], :partial_or_perfect => [:family_name], :perfect => [:city])
-  end
-end