vcardigan 0.0.2

data/lib/vcardigan/errors.rb

@@ -0,0 +1,3 @@
+module VCardigan
+  EncodingError = Class.new(StandardError)
+end

data/lib/vcardigan/properties/name_property.rb

@@ -0,0 +1,17 @@
+module VCardigan
+
+  class NameProperty < Property
+
+    def setup
+      @values = ['', '', '', '', '']
+    end
+
+    private
+
+    def add_value(value, idx)
+      @values[idx] = value if value
+    end
+
+  end
+
+end

data/lib/vcardigan/property.rb

@@ -0,0 +1,222 @@
+module VCardigan
+
+  class Property
+
+    APPLE_LABEL = /_\$!<(.*?)>!\$_/
+
+    attr_accessor :group
+    attr_reader :name
+    attr_reader :params
+    attr_reader :values
+
+    def initialize(vcard, name, *args)
+      @vcard = vcard
+      @params = {}
+      @values = []
+      @group = nil
+
+      setup if respond_to? :setup
+
+      # Determine whether this property name has a group
+      name_parts = name.to_s.split('.', 2)
+
+      # If it has a group, set it
+      if name_parts.length > 1
+        @group = name_parts.first
+      end
+
+      # Set the name
+      @name = name_parts.last.downcase
+
+      # Build out the values/params from the passed arguments
+      valueIdx = 0
+      args.each do |arg|
+        if arg.is_a? Hash
+          arg.each do |param, value|
+            param = param_name(param.to_s.downcase, value)
+            value = param_value(param, value)
+            add_param(param, value)
+          end
+        else
+          value = parse_value(arg.to_s)
+          add_value(value, valueIdx)
+          valueIdx += 1
+        end
+      end
+    end
+
+    def self.create(vcard, name, *args)
+      name = name.to_s.downcase
+      classname = ''
+
+      case name
+      when 'n'
+        className = 'NameProperty'
+      else
+        className = 'Property'
+      end
+
+      cls = Module.const_get('VCardigan').const_get(className)
+      cls.new(vcard, name, *args)
+    end
+
+    def self.parse(vcard, data)
+      # Gather the parts
+      data = data.strip
+      parts = data.split(':', 2)
+      values = parts.last.split(';')
+      params = parts.first.split(';')
+      name = params.shift
+      
+      # Create argument array
+      args = [vcard, name]
+
+      # Add values to array
+      args.concat(values)
+
+      # Add params to array
+      params.each do |param|
+        keyval = param.split('=')
+        hash = Hash[keyval.first, keyval.last]
+        args.push(hash)
+      end
+
+      # Instantiate a new class with the argument array
+      self.create(*args)
+    end
+    
+    def value(idx = 0)
+      @values[idx]
+    end
+
+    def param(name)
+      name ? @params[name.to_s.downcase] : nil
+    end
+
+    def to_s
+      # Name/Group
+      name = @name.upcase
+      property = @group ? "#{@group}.#{name}" : name.upcase
+
+      # Params
+      @params.each do |param, value|
+        str = param_to_s(param, value)
+        property << ';' << str if str
+      end
+
+      # Split with colon
+      property << ':'
+
+      # Values
+      @values.each_with_index do |value, idx|
+        property << ';' unless idx === 0
+        property << value
+      end
+
+      line_fold(property)
+    end
+
+    private
+
+    def version
+      @vcard.version
+    end
+
+    def v3?
+      version == '3.0'
+    end
+
+    def v4?
+      version == '4.0'
+    end
+
+    def param_name(name, value)
+      case name
+      when 'type'
+        if value == 'pref'
+          name = 'preferred'
+        end
+      when 'pref'
+        name = 'preferred'
+      end
+      name
+    end
+
+    def param_value(name, value)
+      case name
+      when 'preferred'
+        value = value.to_s
+        number = value.to_i
+        if number > 0
+          value = number
+        else 
+          value = nil if value.downcase == 'false' or value == '0'
+          value = 1 if value
+        end
+      end
+      value
+    end
+
+    def parse_value(value)
+      # Parse Apple labels
+      match = value.match(APPLE_LABEL)
+      if match
+        value = match[1]
+      end
+      value
+    end
+
+    def add_value(value, idx)
+      @values.push(value)
+    end
+
+    def add_param(name, value)
+      name = name.to_s.downcase
+      if @params[name]
+        # Create array of param values if we have an existing param name
+        # present in the hash
+        unless @params[name].is_a? Array
+          @params[name] = [@params[name]]
+        end
+        @params[name].push(value)
+      else
+        # Default is to just set the param to the value
+        @params[name] = value
+      end
+    end
+
+    def param_to_s(name, value)
+      case name
+      when 'preferred'
+        if !value or value === 0
+          return nil
+        end
+        name = v3? ? 'type' : 'pref'
+        value = v3? ? 'pref' : value.is_a?(Numeric) ? value : 1
+      else
+      end
+      value = value.to_s
+      name.upcase << '=' << value unless value.empty?
+    end
+
+    def line_fold(string)
+      chars = @vcard.chars
+      if chars == 0
+        out = string
+      else
+        out = ''
+        while string.length > 0
+          if string.length >= chars
+            amount = out.empty? ? chars : chars - 1
+            out += "#{string.slice!(0, amount)}\n "
+          else
+            out += string.slice!(0, string.length)
+          end
+        end
+      end
+      out
+    end
+
+  end
+
+end

data/lib/vcardigan/vcard.rb

@@ -0,0 +1,165 @@
+module VCardigan
+
+  class VCard
+
+    VCARD_PATTERN = /BEGIN:VCARD\s+(.*?)VERSION:(.+?)\s+(.+?)END:VCARD/m;
+
+    attr_accessor :version
+    attr_accessor :chars
+
+    def initialize(options = {})
+      # Backwards compatibility
+      if options.is_a? String
+        options = { :version => options }
+      end
+
+      # Default options
+      @version = options[:version] || '4.0'
+      @chars = options[:chars] || 75
+
+      @fields = {}
+      @groups = {}
+      @group = nil
+    end
+
+    def parse(data)
+      match = VCARD_PATTERN.match(data)
+      if match
+        # Set version number
+        @version = match[2]
+        lines = "#{match[1].strip}#{match[3].strip}"
+
+        # Add the parsed properties to this vCard
+        lines.each_line do |line|
+          property = VCardigan::Property.parse(self, line)
+          add_prop(property)
+        end
+      end
+      self
+    end
+
+    def [](group)
+      @group = group
+      self
+    end
+
+    def method_missing(method, *args)
+      if args.empty?
+        # Return the field property/properties when no arguments are passed
+        field(method)
+      else
+        # Add property to vCard
+        add(method, *args)
+      end
+    end
+
+    def add(name, *args)
+      if @group
+        # If there's a group, add it to the name
+        name = "#{@group}.#{name}"
+        
+        # Reset group to nil
+        @group = nil
+      end
+
+      # Build the property and add it to the vCard
+      property = build_prop(name, *args)
+      add_prop(property)
+    end
+
+    def field(name)
+      name = name.to_s.downcase
+      if @group and @fields[name]
+        # Finds all items that match the prop type in the group
+        fields = @fields[name].find_all do |prop|
+          prop.group == @group.to_s
+        end
+
+        # Reset the group to nil and return the fields
+        @group = nil
+        fields
+      else
+        @fields[name]
+      end
+    end
+
+    def group(name)
+      @groups[name]
+    end
+
+    def to_s
+      # Raise errors if invalid
+      validate
+
+      # Start vCard
+      vcard = build_prop(:begin, 'VCARD').to_s << "\n"
+
+      # Add version
+      vcard << build_prop(:version, @version).to_s << "\n"
+
+      # Add the properties
+      @fields.each do |field, properties|
+        properties.each do |property|
+          vcard << property.to_s << "\n"
+        end
+      end
+
+      # END
+      vcard << build_prop(:end, 'VCARD').to_s << "\n"
+
+      # Return vCard
+      return vcard
+    end
+
+    # Aliases ##########
+
+    def name(*args)
+      n(*args)
+    end
+
+    def fullname(*args)
+      fn(*args)
+    end
+
+    # Private ##########
+    private
+
+    def build_prop(name, *args)
+      VCardigan::Property.create(self, name, *args)
+    end
+
+    def add_prop(property)
+      name = property.name
+      group = property.group
+
+      # Create a field on the fields hash, if not already present, to house
+      # the property
+      unless @fields.has_key? name
+        @fields[name] = []
+      end
+      
+      # Add the property to the field array
+      @fields[name].push(property)
+
+      if group
+        # Add a field on the groups hash, if not already present, to house the
+        # group properties
+        unless @groups.has_key? group
+          @groups[group] = []
+        end
+
+        # Add the property to the groups array
+        @groups[group].push(property)
+      end
+    end
+
+    def validate
+      unless @fields['fn']
+        raise VCardigan::EncodingError,
+          "vCards must include an FN field"
+      end
+    end
+
+  end
+
+end

data/lib/vcardigan/version.rb

@@ -0,0 +1,5 @@
+module VCardigan
+
+  VERSION = '0.0.2'
+
+end

data/lib/vcardigan.rb

@@ -0,0 +1,21 @@
+require_relative 'vcardigan/version'
+require_relative 'vcardigan/vcard'
+require_relative 'vcardigan/property'
+require_relative 'vcardigan/properties/name_property'
+require_relative 'vcardigan/errors'
+
+module VCardigan
+
+  class << self
+
+    def create(*args)
+      VCardigan::VCard.new(*args)
+    end
+
+    def parse(*args)
+      VCardigan::VCard.new.parse(*args)
+    end
+
+  end
+
+end

data/spec/examples/property_spec.rb

@@ -0,0 +1,122 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe VCardigan::Property do
+
+  describe '#init' do
+    let(:vcard) { VCardigan.create }
+
+    context 'without a group' do
+      let(:name) { :email }
+      let(:value) { 'joe@strummer.com' }
+      let(:params) { { :type => 'uri' } }
+      let(:prop) { VCardigan::Property.create(vcard, name, value, params) }
+
+      it 'should set the name' do
+        prop.name.should == name.to_s.downcase
+      end
+
+      it 'should set the value' do
+        prop.values.first.should == value
+      end
+    end
+  end
+
+  describe '#values' do
+    let(:vcard) { VCardigan.create }
+    let(:name) { :email }
+    let(:value) { 'joe@strummer.com' }
+    let(:prop) { VCardigan::Property.create(vcard, name, value) }
+    
+    it 'should return the values array' do
+      prop.values.should == prop.instance_variable_get(:@values)
+    end
+  end
+
+  describe '#value' do
+    let(:vcard) { VCardigan.create }
+    let(:name) { :n }
+    let(:value1) { 'Strummer' }
+    let(:value2) { 'Joe' }
+    let(:prop) { VCardigan::Property.create(vcard, name, value1, value2) }
+
+    context 'without an index' do
+      it 'should return the first item from the values array' do
+        prop.value.should == prop.instance_variable_get(:@values).first
+      end
+    end
+
+    context 'with an index' do
+      it 'should return the item corresponding to the index' do
+        prop.value(1).should == prop.instance_variable_get(:@values)[1]
+      end
+    end
+  end
+
+  describe '#params' do
+    let(:vcard) { VCardigan.create }
+    let(:name) { :email }
+    let(:value) { 'joe@strummer.com' }
+    let(:params) { { :type => 'uri' } }
+    let(:prop) { VCardigan::Property.create(vcard, name, value, params) }
+
+    it 'should return the params array' do
+      prop.params.should == prop.instance_variable_get(:@params)
+    end
+  end
+
+  describe '#param' do
+    let(:vcard) { VCardigan.create }
+    let(:name) { :email }
+    let(:value) { 'joe@strummer.com' }
+    let(:params) { { :type => 'uri' } }
+    let(:prop) { VCardigan::Property.create(vcard, name, value, params) }
+
+    context 'with a param that exists' do
+      it 'should return the param' do
+        prop.param(:type).should == params[:type]
+      end
+    end
+
+    context 'with a param that does not exist' do
+      it 'should return nil' do
+        prop.param(:random).should == nil
+      end
+    end
+  end
+
+  describe '#to_s' do
+    let(:vcard) { VCardigan.create }
+    let(:name) { :email }
+    let(:group) { :item1 }
+    let(:value) { 'joe@strummer.com' }
+    let(:params) { { :type => 'uri' } }
+    let(:prop) { VCardigan::Property.create(vcard, "#{group}.#{name}", value, params) }
+
+    it 'should return the property vCard formatted' do
+      prop.to_s.should == "#{group}.#{name.upcase};TYPE=#{params[:type]}:#{value}"
+    end
+  end
+
+  describe '#parse' do
+    let(:vcard) { VCardigan.create }
+    let(:name) { :email }
+    let(:group) { :item1 }
+    let(:value) { 'joe@strummer.com' }
+    let(:params) { { :type => 'uri' } }
+    let(:string) { "#{group}.#{name.upcase};TYPE=#{params[:type]}:#{value}" }
+    let(:prop) { VCardigan::Property.parse(vcard, string) }
+
+    it 'should set the group' do
+      prop.group.should == group.to_s.downcase
+    end
+
+    it 'should set the name' do
+      prop.name.should == name.to_s.downcase
+    end
+
+    it 'should set the values' do
+      prop.values.should == [value]
+    end
+  end
+
+end

data/spec/examples/vcard_spec.rb

@@ -0,0 +1,250 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe VCardigan::VCard do
+
+  describe '#init' do
+    context 'no options' do
+      let(:vcard) { VCardigan.create }
+      
+      it 'should set default version' do
+        vcard.version.should == '4.0'
+      end
+
+      it 'should set default line char limit' do
+        vcard.chars.should == 75
+      end
+    end
+
+    context 'version number for args (backward compat)' do
+      let(:version) { '3.0' }
+      let(:vcard) { VCardigan.create(version) }
+
+      it 'should set version' do
+        vcard.version.should == version
+      end
+    end
+
+    context 'passed options args' do
+      let(:version) { '3.0' }
+      let(:chars) { 100 }
+      let(:vcard) { VCardigan.create(:version => version, :chars => chars) }
+
+      it 'should set version' do
+        vcard.version.should == version
+      end
+
+      it 'should set line char limit' do
+        vcard.chars.should == chars
+      end
+    end
+  end
+
+  describe '#[]' do
+    let(:group) { :item1 }
+    let(:vcard) { VCardigan.create }
+
+    before do
+      vcard[group]
+    end
+
+    it 'should return vcard' do
+      vcard.should be_an_instance_of(VCardigan::VCard)
+    end
+
+    it 'should set group' do
+      vcard.instance_variable_get(:@group).should == group
+    end
+  end
+
+  describe '#add' do
+    let(:name) { :email }
+    let(:value) { 'joe@strummer.com' }
+    let(:vcard) { VCardigan.create }
+    let(:fields) { vcard.instance_variable_get(:@fields) }
+
+    context 'with no group' do
+      before do
+        vcard.add(name, value)
+      end
+
+      it 'should add field name (as string) to fields hash' do
+        fields.should have_key(name.to_s)
+      end
+
+      it 'should create array on field name' do
+        fields[name.to_s].should be_an_instance_of(Array)
+      end
+
+      it 'should have single item in array' do
+        fields[name.to_s].length.should == 1
+      end
+
+      it 'should add property to field name array' do
+        fields[name.to_s].first.should be_an_instance_of(VCardigan::Property)
+      end
+    end
+
+    context 'with group' do
+      let(:group) { :item1 }
+      let(:groups) { vcard.instance_variable_get(:@groups) }
+
+      before do
+        vcard[group].add(name, value)
+      end
+
+      it 'should add group name (as string) to groups hash' do
+        groups.should have_key(group.to_s)
+      end
+
+      it 'should create array on group name' do
+        groups[group.to_s].should be_an_instance_of(Array)
+      end
+
+      it 'should have single item in array' do
+        groups[group.to_s].length.should == 1
+      end
+
+      it 'should add property group name array' do
+        groups[group.to_s].first.should be_an_instance_of(VCardigan::Property)
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    let(:vcard) { VCardigan.create }
+
+    context 'with args' do
+      let(:name) { :email }
+      let(:email) { 'joe@strummer.com' }
+      let(:params) { { :type => 'uri' } }
+
+      it 'should call #add' do
+        vcard.should_receive(:add).with(name, email, params)
+        vcard.send(name, email, params)
+      end
+    end
+
+    context 'without args' do
+      let(:name) { :email }
+
+      it 'should call #field' do
+        vcard.should_receive(:field).with(name)
+        vcard.send(name)
+      end
+    end
+  end
+
+  describe '#field' do
+    let(:vcard) { VCardigan.create }
+    let(:fields) { vcard.instance_variable_get(:@fields) }
+    let(:name) { :email }
+    let(:value) { 'joe@strummer.com' }
+
+    context 'no group' do
+      before do
+        vcard.send(name, value)
+      end
+
+      it 'should return field name array' do
+        vcard.field(name).should == fields[name.to_s]
+      end
+
+      it 'should have correct property in array' do
+        vcard.field(name).first.value.should == value
+      end
+    end
+
+    context 'with group' do
+      let(:group) { :item1 }
+      let(:value2) { 'joestrummer@strummer.com' }
+
+      before do
+        vcard.send(name, value)
+        vcard[group].send(name, value2)
+      end
+
+      it 'should return field name array with props within group' do
+        vcard[group].field(name).should == fields[name.to_s].find_all do |prop|
+          prop.group == group.to_s
+        end
+      end
+
+      it 'should have correct property in array' do
+        vcard[group].field(name).first.value.should == value2
+      end
+    end
+  end
+
+  describe 'Aliases' do
+    let(:vcard) { VCardigan.create }
+
+    context '#name' do
+      it 'should call method_missing with method n' do
+        vcard.should_receive(:method_missing).with(:n)
+        vcard.name
+      end
+    end
+    
+    context '#fullname' do
+      it 'should call method_missing with method fn' do
+        vcard.should_receive(:method_missing).with(:fn)
+        vcard.fullname
+      end
+    end
+  end
+
+  describe '#to_s' do
+    let(:vcard) { VCardigan.create }
+
+    context 'with no FN' do
+      it 'should raise an error' do
+        expect { vcard.to_s }.to raise_error(VCardigan::EncodingError)
+      end
+    end
+
+    context 'with an FN and N' do
+      before do
+        vcard.name('Strummer', 'Joe')
+        vcard.fullname('Joe Strummer')
+      end
+
+      it 'should have BEGIN on first line' do
+        vcard.to_s.split("\n").first.should == 'BEGIN:VCARD'
+      end
+
+      it 'should proceed with VERSION' do
+        vcard.to_s.split("\n")[1].should == 'VERSION:4.0'
+      end
+
+      it 'should include the N field' do
+        vcard.to_s.split("\n")[2].should == 'N:Strummer;Joe;;;'
+      end
+
+      it 'should include the FN field' do
+        vcard.to_s.split("\n")[3].should == 'FN:Joe Strummer'
+      end
+
+      it 'should end with END' do
+        vcard.to_s.split("\n").last.should == 'END:VCARD'
+      end
+    end
+  end
+
+  describe '#parse' do
+    context 'valid 4.0 vCard' do
+      let(:data) { File.read(File.dirname(__FILE__) + '/../helpers/joe.vcf') }
+      let(:vcard) { VCardigan.parse(data) }
+      let(:fields) { vcard.instance_variable_get(:@fields) }
+
+      it 'should set the version' do
+        vcard.version.should == '4.0'
+      end
+
+      it 'should add the properties to the fields array' do
+        fields.should have_key('n')
+        fields.should have_key('fn')
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/vcardigan'

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: vcardigan
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Matt Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: vCardigan is a ruby library for building and parsing vCards that supports
+  both v3.0 and v4.0.
+email: matt@mlmorg.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vcardigan/errors.rb
+- lib/vcardigan/properties/name_property.rb
+- lib/vcardigan/property.rb
+- lib/vcardigan/vcard.rb
+- lib/vcardigan/version.rb
+- lib/vcardigan.rb
+- spec/examples/property_spec.rb
+- spec/examples/vcard_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/brewster/vcardigan
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby vCard Builder/Parser
+test_files:
+- spec/examples/property_spec.rb
+- spec/examples/vcard_spec.rb
+- spec/spec_helper.rb