ical_importer 0.0.1

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1,5 @@
+rvm --create ruby-1.9.3-p125@ical_importer
+# Ensure that Bundler is installed, install it if it is not.
+if ! command -v bundle > /dev/null; then
+  gem install bundler
+fi

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in automation.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    ical_importer (0.0.1)
+      activesupport (~> 3.0.15)
+      i18n
+      ri_cal
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.0.16)
+    awesome_print (1.0.2)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    rake (0.9.2.2)
+    ri_cal (0.8.8)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  ical_importer!
+  rake
+  rspec

data/README.md

@@ -0,0 +1,74 @@
+# Ical Importer
+
+Easily import your iCal feeds.
+
+[![TravisCI](https://secure.travis-ci.org/tstmedia/ical_importer.png "TravisCI")](http://travis-ci.org/tstmedia/ical_importer "Travis-CI IcalImporter")
+
+<!---
+[RubyGems](NOT YET "NOT YET")
+--->
+
+# Notes
+
+* Recurrence events are not the same as recurring events
+
+# Usage
+
+Add
+
+```ruby
+gem 'ical_importer', :git => 'http://github.com/tstmedia/ical_importer.git'
+```
+
+to your Gemfile
+
+Then you can do:
+
+```ruby
+IcalImporter::Parser.new(a_url).parse # To get just an array of events
+
+IcalImporter::Parser.new(a_url).parse do |event|
+  event.uid
+  event.title
+  event.description
+  event.location
+  event.start_date_time
+  event.end_date_time
+  event.utc
+  event.date_exclusions
+  event.recur_end_date
+  event.recur_month_repeat_by
+  event.recur_interval
+  event.recur_interval_value
+  event.recurrence_id
+  event.all_day_event
+  event.recurrence
+  event.utc?
+  event.all_day_event?
+  event.recurrence?
+  event.recur_week_sunday
+  event.recur_week_monday
+  event.recur_week_tuesday
+  event.recur_week_wednesday
+  event.recur_week_thursday
+  event.recur_week_friday
+  event.recur_week_saturday
+end
+
+parser = IcalImporter::Parser.new(a_url)
+parser.parse do |e|
+  # block stuffs
+end
+
+# Each of these also accepts blocks and returns a list
+parser.all_events
+parser.recurrence_events
+parser.single_events
+```
+
+# TODO
+
+* Current implementation based on an extraction from another app
+  - some of the recurring/recurrence/single logic is fragmented
+  - Re-implement to be more similarly classifiable across these different scenarios
+* Document Methods

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:docs) do |t|
+    t.rspec_opts = ["--format doc"]
+  end
+end
+
+task :default => :spec

data/ical_importer.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ical_importer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jon Phenow"]
+  gem.email         = ["jon.phenow@tstmedia.com"]
+  gem.description   = %q{Easily import iCal Events from a URL and handle their output}
+  gem.summary       = %q{}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "ical_importer"
+  gem.require_paths = ["lib"]
+  gem.version       = IcalImporter::VERSION
+
+  gem.add_dependency 'activesupport', "~> 3.0.15"
+  gem.add_dependency 'ri_cal'
+  gem.add_dependency 'i18n'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'awesome_print'
+end

data/lib/ical_importer/builder.rb

@@ -0,0 +1,22 @@
+module IcalImporter
+  class Builder
+    attr_reader :event, :recurrence_builder
+    def initialize(event, recurrence_builder)
+      @event = event
+      @recurrence_builder = recurrence_builder
+    end
+
+    def handle_as_recurrence?
+      event.recurrence_id.present?
+    end
+
+    def build
+      if handle_as_recurrence?
+        recurrence_builder << event
+        nil # Don't want this messing up our collect in Collector
+      else
+        SingleEventBuilder.new(event).build
+      end
+    end
+  end
+end

data/lib/ical_importer/collector.rb

@@ -0,0 +1,25 @@
+module IcalImporter
+  class Collector
+    attr_reader :single_events, :events, :recurrence_events
+
+    def initialize(events)
+      @events = events
+      @single_events = []
+      @recurrence_events = []
+    end
+
+    def collect
+      self.tap do
+        recurrence_builder = RecurrenceEventBuilder.new
+        single_events.tap do |c|
+          events.each do |remote_event|
+            c << Builder.new(remote_event, recurrence_builder).build
+          end
+          @recurrence_events = recurrence_builder.build.built_events.flatten.compact
+          c.flatten!
+          c.compact!
+        end
+      end
+    end
+  end
+end

data/lib/ical_importer/date_exclusion.rb

@@ -0,0 +1,11 @@
+module IcalImporter
+  class DateExclusion
+    attr_accessor :date_exclusion
+
+    def initialize(attributes)
+      attributes.each do |name, value|
+        instance_variable_set "@#{name}", value if [:date_exclusion].include? name.to_sym
+      end
+    end
+  end
+end

data/lib/ical_importer/local_event.rb

@@ -0,0 +1,59 @@
+module IcalImporter
+  class LocalEvent
+    class << self
+      attr_accessor :class_attributes
+    end
+
+    @class_attributes = [
+      :uid,
+      :title,
+      :description,
+      :location,
+      :start_date_time,
+      :end_date_time,
+      :utc,
+      :date_exclusions,
+      :recur_end_date,
+      :recur_month_repeat_by,
+      :recur_interval,
+      :recur_interval_value,
+      :recur_end_date,
+      :recurrence_id,
+      :all_day_event,
+      :recurrence
+    ]
+
+    attr_accessor *class_attributes
+    alias utc? utc
+    alias all_day_event? all_day_event
+    alias recurrence? recurrence
+
+    DAYS = %w[sunday monday tuesday wednesday thursday friday saturday]
+    DAYS.each do |day|
+      class_attributes << "recur_week_#{day}".to_sym
+      attr_accessor "recur_week_#{day}"
+    end
+
+    def initialize(attributes)
+      self.attributes = attributes
+      @date_exclusions ||= []
+    end
+
+    def get_attributes(list)
+      raise ArgumentError, "Must be an Array" unless list.is_a? Array
+      list.collect! { |e| e.to_s }
+      attributes.select { |k,_| list.include? k.to_s }
+    end
+
+    def to_hash
+      Hash[*self.class.class_attributes.collect { |attribute| [attribute.to_sym, send(attribute)] }.flatten(1)]
+    end
+    alias :attributes :to_hash
+
+    def attributes=(attributes)
+      attributes.each do |name, value|
+        instance_variable_set "@#{name}", value if self.class.class_attributes.include? name.to_sym
+      end
+    end
+  end
+end

data/lib/ical_importer/parser.rb

@@ -0,0 +1,75 @@
+module IcalImporter
+  class Parser
+    attr_reader :feed, :bare_feed, :url
+
+    def initialize(url)
+      @url = url
+      @bare_feed = open_ical
+      if should_parse?
+        @bare_feed.pos = 0
+        @feed = RiCal.parse @bare_feed
+      end
+    end
+
+    def should_parse?
+      bare_feed.present?
+    end
+
+    def worth_parsing?
+      should_parse? && feed.present? && feed.first
+    end
+
+    def all_events(&block)
+      tap_and_each (@imported_single_events || []) + (@imported_recurrence_events || []), &block
+    end
+
+    def single_events(&block)
+      tap_and_each (@imported_single_events || []), &block
+    end
+
+    def recurrence_events(&block)
+      tap_and_each (@imported_recurrence_events || []), &block
+    end
+
+    def parse(&block)
+      if worth_parsing?
+        collected = Collector.new(feed.first.events).collect
+        @imported_single_events = collected.single_events
+        @imported_recurrence_events = collected.recurrence_events
+        tap_and_each (@imported_single_events + @imported_recurrence_events), &block
+      end
+    end
+
+    private
+
+    def tap_and_each(list)
+      list.tap do |r|
+        r.each do |event|
+          yield event if block_given?
+        end
+      end
+    end
+
+    def open_ical(protocol = 'http')
+      raise ArgumentError, "Must be http or https" unless %w[http https].include? protocol
+      begin
+        Timeout::timeout(5) do
+          open prepped_uri(protocol)
+        end
+      rescue
+        return open_ical 'https' if protocol == 'http'
+        nil
+      end
+    end
+
+    def prepped_uri(protocol)
+      uri = url.strip.gsub(/^[Ww]ebcal:/, "#{protocol}:")
+      uri = begin
+              URI.unescape(uri)
+            rescue URI::InvalidURIError
+            end
+      URI.escape(uri)
+    end
+
+  end
+end

data/lib/ical_importer/recurrence_event_builder.rb

@@ -0,0 +1,37 @@
+module IcalImporter
+  class RecurrenceEventBuilder
+    attr_reader :events_to_build, :built_events
+    def initialize
+      @events_to_build = []
+      @built_events = []
+    end
+
+    def <<(event)
+      raise ArgumentError, "Must be a RiCal Event" unless event.is_a? RiCal::Component::Event
+      @events_to_build << event
+    end
+
+    def build
+      self.tap do
+        events_to_build.each do |remote_event|
+          @built_events << build_new_local_event(remote_event)
+        end
+      end
+    end
+
+    private
+
+    def build_new_local_event(remote_event)
+      LocalEvent.new({
+        :uid => remote_event.uid,
+        :title => remote_event.summary,
+        :description => remote_event.description,
+        :location => remote_event.location || '',
+        :start_date_time => remote_event.start_date_time,
+        :end_date_time => remote_event.end_date_time,
+        :date_exclusions => [DateExclusion.new(:exclude_date => remote_event.recurrence_id)],
+        :recurrence => true
+      })
+    end
+  end
+end

data/lib/ical_importer/remote_event.rb

@@ -0,0 +1,54 @@
+module IcalImporter
+  class RemoteEvent
+    attr_accessor :event, :utc
+    alias :utc? :utc
+    delegate :description, :recurs?, :rrule_property, :exdate, :to => :event
+
+    def initialize(event)
+      @event = event
+      begin
+        @utc = @event.dtstart.try(:tzid) != :floating
+      rescue
+        @utc = true
+      end
+    end
+
+    def start_date_time
+      get_date_time_for :dtstart
+    end
+
+    def end_date_time
+      get_date_time_for :dtend
+    end
+
+    def all_day_event?
+      (Time.parse(end_date_time.to_s) - Time.parse(start_date_time.to_s)) >= 1.day
+    end
+
+    def event_attributes
+      {
+        :uid => event.uid,
+        :title => event.summary,
+        :utc => utc?,
+        :description => event.description,
+        :location => event.location || '',
+        :start_date_time => start_date_time,
+        :end_date_time => end_date_time,
+        :all_day_event => all_day_event?
+      }
+    end
+
+    private
+
+    def get_date_time_for(event_method)
+      event_method = event_method.to_sym
+      raise ArgumentError, "Should be dtend or dtstart" unless [:dtstart, :dtend].include? event_method
+      event_time = event.send event_method
+      if event_time.is_a? DateTime
+        (event_time.tzid == :floating) ? event_time : event_time.utc
+      else
+        event_time.to_datetime
+      end
+    end
+  end
+end

data/lib/ical_importer/single_event_builder.rb

@@ -0,0 +1,128 @@
+module IcalImporter
+  class SingleEventBuilder
+    attr_reader :event, :local_event
+
+    def initialize(event)
+      @event = RemoteEvent.new event
+      @local_event = LocalEvent.new @event.event_attributes
+    end
+
+    # Get single-occurrence events built and get a lits of recurrence
+    # events, these must be build last
+    def build
+      # handle recuring events
+      @local_event.tap do |le|
+        if @event.recurs?
+          rrule = @event.rrule_property.first # only support recurrence on one schedule
+          # set out new event's basic rucurring properties
+          le.attributes = recurrence_attributes rrule
+
+          set_date_exclusion
+          frequency_set rrule
+        else # make sure we remove this if it changed
+          le.attributes = non_recurrence_attributes
+        end
+      end
+    end
+
+    private
+
+    def non_recurrence_attributes
+      attributes = {
+        :recur_interval => "none",
+        :recur_interval_value => nil,
+        :recur_end_date => nil
+      }
+      if !@local_event.all_day_event && @event.start_date_time.day != @event.end_date_time.day # single event that spans multiple days
+        attributes.merge({
+          :recur_interval => "day",
+          :recur_interval_value => 1,
+          :recur_end_date => @event.end_date_time.end_of_day - 1.day,
+          :all_day_event => true
+        })
+      end
+      attributes
+    end
+
+    def recurrence_attributes(rrule)
+      {
+        :recur_interval => recur_map[rrule.freq],
+        :recur_interval_value => rrule.interval,
+        :recur_end_date => rrule.until.try(:to_datetime)
+      }
+    end
+
+    def set_date_exclusion
+      # set any date exclusions
+      @local_event.date_exclusions = @event.exdate.flatten.map{|d| DateExclusion.new(:exclude_date => d)}
+    end
+
+    def frequency_set(rrule)
+      # if .bounded? is an integer that's googles "recur X times"
+      # if that's the case we try to figure out the date it should be by
+      # multiplying thise "X" times by the frequency that the event recurrs
+      if rrule.bounded?.is_a? Fixnum # convert X times to a date
+        case rrule.freq
+        when "DAILY"
+          @local_event.recur_end_date = frequency_template.days
+        when "WEEKLY"
+          if rrule.to_ical.include?("BYDAY=")
+            remote_days = rrule.to_ical.split("BYDAY=").last.split(";WKST=").first.split(',')
+            day_map.each do |abbr, day|
+              @local_event.send "recur_week_#{day}=", remote_days.include?(abbr)
+            end
+          else
+            remote_days = [@local_event.start_date_time.wday]
+            wday_map.each do |abbr, day|
+              @local_event.send "recur_week_#{day}=", remote_days.include?(abbr)
+            end
+          end
+          # recurrence X times is probably broken - we can select multiple times in a week
+          @local_event.recur_end_date = (frequency_template / remote_days.length).weeks
+        when "MONTHLY"
+          @local_event.recur_month_repeat_by = (rrule.to_ical =~ /BYDAY/) ? "day_of_week" : "day_of_month"
+          @local_event.recur_end_date = frequency_template.months
+        when "YEARLY"
+          @local_event.recur_end_date = frequency_template.years
+        end
+      end
+    end
+
+    def frequency_template
+      @local_event.start_date_time + (rrule.bounded? * rrule.interval - 1)
+    end
+
+    def recur_map
+      {
+        "DAILY" => "day",
+        "WEEKLY" => "week",
+        "MONTHLY" => "month",
+        "YEARLY" => "year"
+      }
+    end
+
+    def day_map
+      {
+        "SU" => "sunday",
+        "MO" => "monday",
+        "TU" => "tuesday",
+        "WE" => "wednesday",
+        "TH" => "thursday",
+        "FR" => "friday",
+        "SA" => "saturday"
+      }
+    end
+
+    def wday_map
+      {
+        0 => "sunday",
+        1 => "monday",
+        2 => "tuesday",
+        3 => "wednesday",
+        4 => "thursday",
+        5 => "friday",
+        6 => "saturday"
+      }
+    end
+  end
+end

data/lib/ical_importer/version.rb

@@ -0,0 +1,3 @@
+module IcalImporter
+  VERSION = '0.0.1'
+end

data/lib/ical_importer.rb

@@ -0,0 +1,11 @@
+require 'active_support/all'
+require 'ri_cal'
+
+require 'ical_importer/date_exclusion'
+require 'ical_importer/builder'
+require 'ical_importer/collector'
+require 'ical_importer/remote_event'
+require 'ical_importer/local_event'
+require 'ical_importer/parser'
+require 'ical_importer/recurrence_event_builder'
+require 'ical_importer/single_event_builder'

data/spec/ical_importer/builder_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module IcalImporter
+  describe Builder do
+    subject { Builder.new(event, recurrence_builder) }
+    let(:recurrence_builder) { RecurrenceEventBuilder.new }
+
+    describe "#handle_as_recurrence?" do
+      describe "recurrence_id'd event" do
+        let(:event) { stub :recurrence_id => 1 }
+        it "handles as recurrence" do
+          subject.handle_as_recurrence?.should == true
+        end
+      end
+
+      describe "non-recurrence_id'd event" do
+        let(:event) { stub :recurrence_id => nil }
+        it "handles as recurrence" do
+          subject.handle_as_recurrence?.should == false
+        end
+      end
+    end
+
+    describe "#build" do
+      let(:event) { stub }
+      describe "recurrence" do
+        let(:event) { stub :recurrence_id => 1 }
+        it "adds events to be computed with recurrence_builder" do
+          recurrence_builder.should_receive(:<<).with(event)
+          subject.build.should == nil
+        end
+      end
+
+      describe "non-recurrence" do
+        let(:event) { stub :recurrence_id => nil }
+        it "builds single event" do
+          single_event_builder = stub
+          returned = stub
+          SingleEventBuilder.should_receive(:new).with(event).and_return single_event_builder
+          single_event_builder.should_receive(:build).and_return(returned)
+          subject.build.should == returned
+        end
+      end
+    end
+  end
+end

data/spec/ical_importer/collector_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module IcalImporter
+  describe Collector do
+    let(:events) { [] }
+    subject { Collector.new events }
+    it { should respond_to :collect }
+
+    describe "#collect" do
+      let(:events) { [stub, stub] }
+      let(:r_builder) { stub(:build => stub(:built_events => [])) }
+      it "tries to build, then cleanup the returns" do
+        built = stub
+        RecurrenceEventBuilder.should_receive(:new).and_return r_builder
+        Builder.should_receive(:new).with(events[0], r_builder).ordered.and_return(built)
+        Builder.should_receive(:new).with(events[1], r_builder).ordered.and_return(built)
+        built.should_receive(:build).twice.and_return "boom"
+        subject.collect
+      end
+    end
+  end
+end