almanack 1.0.5 → 1.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edcbe493e1eeafbf85972b28c5427a87c48ef3e6
-  data.tar.gz: 7b74a5466823eacc3ef1a50bc35966e575225f42
+  metadata.gz: 49d69b1b032ff7f536d34807c859021af3840f3e
+  data.tar.gz: b5ea878e85c09b1e967054e7038400fcc0125120
 SHA512:
-  metadata.gz: d1082a9baf6ff0d079604b21f03e1eb7a21ea480e7d49ea9ff1db95e80246e914cccd30137292de9787416571df53916710f8ed6b83713789dadeaeb2e7440ca
-  data.tar.gz: cb8546fed04c611ef7a93f60ad3a0bd3129558a9b3cfd33c5de86b68cc182115d28760d9521d5162c227ccf53293fa801c7f0eb2525277daf71f74276ab99cd2
+  metadata.gz: d40154226158a3bbf56e6de69e1cd495827eef1563cbf88e8823257cdf8653c2eec181070a6be6e2ae0f0b19d9fc9c56a5b02471945f6ae35bba68cecb6151b9
+  data.tar.gz: 0a8723f866ee7403cd8d66044c16c6e93c197c5a9b7485d7af61da75a00a8cc31f9c2a04fc3cdfc40d22b80c903b9e9ebd703f2e8704ab34e8246b8a302bd024

data/.travis.yml

@@ -1,6 +1,8 @@
 language: ruby
 cache: bundler
 rvm:
+- 2.1.4
+- 2.1.3
 - 2.1.2
 - 2.1.0
 - 2.0.0

data/almanack.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "addressable"
   spec.add_dependency "thor"
   spec.add_dependency "faraday"
+  spec.add_dependency "rack-contrib"
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"

data/example.ru

@@ -11,13 +11,13 @@ Almanack.config do |calendar|
   calendar.add_events [
     {
       title: "Hogswatch",
-      start_date: now + Almanack::Calendar::ONE_DAY,
-      end_date: now + Almanack::Calendar::ONE_DAY * 2,
+      start_time: now + Almanack::ONE_DAY,
+      end_time: now + Almanack::ONE_DAY * 2,
       description: 'The sausages have been strung, the wreaths of oakleaves hung and the stockings dangled. The pork pie, the sherry and the all-important turnip await their festive guests. The poker lent against the fireplace may or may not have been bent over the head of some nightmare creature.',
       location: 'Castle of Bones'
     },
-    { title: "Soul Cake Tuesday", start_date: now + 10 * Almanack::Calendar::ONE_DAY },
-    { title: "Eve of Small Gods", start_date: now + 30 * Almanack::Calendar::ONE_DAY },
+    { title: "Soul Cake Tuesday", start_time: now + 10 * Almanack::ONE_DAY },
+    { title: "Eve of Small Gods", start_time: now + 30 * Almanack::ONE_DAY },
   ]
 end
 

data/lib/almanack/base.rb

@@ -0,0 +1,22 @@
+module Almanack
+  ONE_HOUR = 60 * 60
+  ONE_DAY = 24 * ONE_HOUR
+  ONE_MONTH = 30 * ONE_DAY
+  ONE_YEAR = 365 * ONE_DAY
+
+  class << self
+    def config(&block)
+      @config ||= Configuration.new
+      yield @config if block_given?
+      @config
+    end
+
+    def calendar
+      @calendar ||= Calendar.new(config)
+    end
+
+    def reset!
+      config.reset!
+    end
+  end
+end

data/lib/almanack/calendar.rb

@@ -2,13 +2,11 @@ require 'forwardable'
 
 module Almanack
   class Calendar
-    ONE_HOUR = 60 * 60
-    ONE_DAY = 24 * ONE_HOUR
-    ONE_MONTH = 30 * ONE_DAY
-    ONE_YEAR = 365 * ONE_DAY
-
     extend Forwardable
-    def_delegators :@config, :event_sources, :title, :days_lookahead
+    def_delegators :@config, :event_sources,
+                             :title,
+                             :days_lookahead,
+                             :feed_lookahead
 
     def initialize(config)
       @config = config
@@ -26,32 +24,16 @@ module Almanack
       end.flatten
 
       event_list.sort_by do |event|
-        event.start_date.to_time
+        event.start_time.to_time
       end
     end
 
     def ical_feed
-      now = Time.now
-      future = now + ONE_YEAR
-
-      # Three hours is the duration for events missing end dates, a
-      # recommendation suggested by Meetup.com.
-      three_hours = 3 * ONE_HOUR
-
-      ical = RiCal.Calendar
-
-      events_between(now..future).each do |event|
-        ical_event = RiCal.Event
-        ical_event.summary = event.title
-        ical_event.dtstart = event.start_date.utc
-        ical_event.dtend = (event.end_date || event.start_date + three_hours).utc
-        ical_event.description = event.description if event.description
-        ical_event.location = event.location if event.location
-
-        ical.add_subcomponent(ical_event)
-      end
+      Representation::IcalFeed.from(self).to_s
+    end
 
-      ical.to_s
+    def json_feed
+      Representation::JSONFeed.from(self).to_s
     end
   end
 end

data/lib/almanack/configuration.rb

@@ -4,9 +4,15 @@ module Almanack
 
     DEFAULT_THEME = "legacy"
     DEFAULT_DAYS_LOOKAHEAD = 30
+    DEFAULT_FEED_LOOKAHEAD = 365
 
     attr_reader :event_sources
-    attr_accessor :title, :theme, :theme_paths, :theme_root, :days_lookahead
+    attr_accessor :title,
+                  :theme,
+                  :theme_paths,
+                  :theme_root,
+                  :days_lookahead,
+                  :feed_lookahead
 
     def initialize
       reset!
@@ -19,6 +25,7 @@ module Almanack
     def reset!
       @theme = DEFAULT_THEME
       @days_lookahead = DEFAULT_DAYS_LOOKAHEAD
+      @feed_lookahead = DEFAULT_FEED_LOOKAHEAD
       @event_sources = []
 
       @theme_paths = [
@@ -33,16 +40,20 @@ module Almanack
       root || raise(ThemeNotFound, "Could not find theme #{theme} in #{paths}")
     end
 
+    def add_event_source(source)
+      @event_sources << source
+    end
+
     def add_ical_feed(url)
-      @event_sources << EventSource::IcalFeed.new(url, connection: connection)
+      add_event_source EventSource::IcalFeed.new(url, connection: connection)
     end
 
     def add_events(events)
-      @event_sources << EventSource::Static.new(events)
+      add_event_source EventSource::Static.new(events)
     end
 
     def add_meetup_group(options)
-      @event_sources << EventSource::MeetupGroup.new(options.merge(connection: connection))
+      add_event_source EventSource::MeetupGroup.new(options.merge(connection: connection))
     end
   end
 end

data/lib/almanack/event.rb

@@ -3,21 +3,72 @@ require 'ostruct'
 module Almanack
   class Event < OpenStruct
     def formatted_date
-      formatted = "#{formatted_day(start_date)} at #{formatted_time(start_date)}"
+      formatted = "#{formatted_day(start_time)} at #{formatted_time(start_time)}"
 
-      if end_date
+      if end_time
         formatted << " to "
-        formatted << "#{formatted_day(end_date)} at " unless ends_on_same_day?
-        formatted << formatted_time(end_date)
+        formatted << "#{formatted_day(end_time)} at " unless ends_on_same_day?
+        formatted << formatted_time(end_time)
       end
 
       formatted
     end
 
+    # Deprecated in favour of start_time
+    def start_date
+      deprecated :start_date, newer_method: :start_time
+    end
+
+    def start_time
+      read_attribute :start_time, fallback: :start_date
+    end
+
+    # Deprecated in favour of end_time
+    def end_date
+      deprecated :end_date, newer_method: :end_time
+    end
+
+    def end_time
+      read_attribute :end_time, fallback: :end_date
+    end
+
+    def serialized
+      each_pair.with_object({}) do |(attr, _), hash|
+        hash[attr] = serialize_attribute(attr)
+      end
+    end
+
     private
 
+    def serialize_attribute(attribute)
+      value = send(attribute)
+      value.is_a?(Time) ? value.iso8601 : value
+    end
+
+    def deprecated(older_method, options = {})
+      newer_method = options.delete(:newer_method)
+      value = read_attribute(newer_method, fallback: older_method)
+      warn "Event method #{older_method} is deprecated; use #{newer_method} instead"
+      value
+    end
+
+    def read_attribute(newer_method, options = {})
+      older_method = options.delete(:fallback)
+      newer_value = self[newer_method]
+      fallback_value = self[older_method]
+
+      if fallback_value && newer_value
+        raise "Both #{older_method} and #{newer_method} properties are set, please use #{newer_method} only instead"
+      elsif newer_value
+        newer_value
+      elsif fallback_value
+        warn "Deprecated event property #{older_method} is set; set #{newer_method} property instead"
+        fallback_value
+      end
+    end
+
     def ends_on_same_day?
-      [start_date.year, start_date.yday] == [end_date.year, end_date.yday]
+      [start_time.year, start_time.yday] == [end_time.year, end_time.yday]
     end
 
     def formatted_time(time)

data/lib/almanack/event_source/ical_feed.rb

@@ -12,6 +12,10 @@ module Almanack
         end
       end
 
+      def serialized_between(date_range)
+        { events: events_between(date_range).map(&:serialized) }
+      end
+
       private
 
       def each_ical_event(&block)
@@ -38,8 +42,8 @@ module Almanack
       def event_from(occurrence)
         Event.new(
           title: occurrence.summary,
-          start_date: occurrence.dtstart,
-          end_date: occurrence.dtend,
+          start_time: occurrence.dtstart,
+          end_time: occurrence.dtend,
           description: occurrence.description,
           location: occurrence.location
         )

data/lib/almanack/event_source/meetup_group.rb

@@ -3,19 +3,40 @@ module Almanack
     class MeetupGroup
       def initialize(options = {})
         @request_options = options
+        @group_properties = {}
       end
 
       def events_between(date_range)
         events.select do |event|
-          event.start_date >= date_range.min && event.start_date <= date_range.max
+          event.start_time >= date_range.min && event.start_time <= date_range.max
         end
       end
 
+      def serialized_between(date_range)
+        # TODO `events` must be called before @group_properties is accessed
+        serialized_events = events_between(date_range).map(&:serialized)
+        @group_properties.merge(events: serialized_events)
+      end
+
       private
 
       def events
-        request = MeetupAPIRequest.new(@request_options.clone)
-        request.results.map { |result| event_from(result) }
+        results = MeetupAPIRequest.new(@request_options.clone).results
+        record_group_details_from results
+        results.map { |result| event_from(result) }
+      end
+
+      def record_group_details_from(results)
+        first_result = results.first
+        return if !first_result
+
+        group = first_result['group']
+        return if !group
+
+        @group_properties = {
+          name: group['name'],
+          url: "http://www.meetup.com/" + group['urlname']
+        }
       end
 
       def event_from(result)
@@ -29,8 +50,8 @@ module Almanack
 
         Event.new(
           title: event_name,
-          start_date: start_time,
-          end_date: end_time,
+          start_time: start_time,
+          end_time: end_time,
           description: result['description'],
           location: location_from_venue(result['venue']),
           url: result['event_url']

data/lib/almanack/event_source/static.rb

@@ -7,10 +7,14 @@ module Almanack
 
       def events_between(date_range)
         events.select do |event|
-          event.start_date >= date_range.min && event.start_date <= date_range.max
+          event.start_time >= date_range.min && event.start_time <= date_range.max
         end
       end
 
+      def serialized_between(date_range)
+        { events: events_between(date_range).map(&:serialized) }
+      end
+
       private
 
       def events

data/lib/almanack/representation/ical_feed.rb

@@ -0,0 +1,59 @@
+module Almanack
+  module Representation
+    class IcalFeed
+      attr_reader :calendar
+
+      def initialize(calendar)
+        @calendar = calendar
+      end
+
+      def ical
+        @ical ||= ical_calendar
+      end
+
+      def to_s
+        ical.to_s
+      end
+
+      def self.from(calendar)
+        self.new(calendar)
+      end
+
+      private
+
+      def events
+        calendar.events_between(now..lookahead)
+      end
+
+      def ical_calendar
+        events.each_with_object(RiCal.Calendar) do |event, calendar_component|
+          calendar_component.add_subcomponent ical_event_for(event)
+        end
+      end
+
+      def ical_event_for(event)
+        ical_event = RiCal.Event
+        ical_event.summary = event.title
+        ical_event.dtstart = event.start_time.utc
+        ical_event.dtend = (event.end_time || event.start_time + default_event_duration ).utc
+        ical_event.description = event.description if event.description
+        ical_event.location = event.location if event.location
+        ical_event
+      end
+
+      def lookahead
+        now + calendar.feed_lookahead * ONE_DAY
+      end
+
+      def default_event_duration
+        # Three hours is the duration for events missing end dates, a
+        # recommendation suggested by Meetup.com.
+        3 * ONE_HOUR
+      end
+
+      def now
+        @now ||= Time.now
+      end
+    end
+  end
+end

data/lib/almanack/representation/json_feed.rb

@@ -0,0 +1,55 @@
+module Almanack
+  module Representation
+    class JSONFeed
+      attr_reader :calendar
+
+      def initialize(calendar)
+        @calendar = calendar
+      end
+
+      def to_s
+        json_friendly = SerializedTransformation.new(serialized)
+        json_friendly.key { |key| camelize(key.to_s) }
+        json_friendly.apply.to_json
+      end
+
+      def self.from(calendar)
+        self.new(calendar)
+      end
+
+      private
+
+      def camelize(string)
+        string.split('_').map.with_index do |part, index|
+          index.zero? ? part : part.capitalize
+        end.join
+      end
+
+      def date_range
+        now..lookahead
+      end
+
+      def serialized
+        { event_sources: serialized_event_sources }
+      end
+
+      def serialized_event_sources
+        event_sources.map do |source|
+          source.serialized_between(date_range)
+        end
+      end
+
+      def event_sources
+        calendar.event_sources
+      end
+
+      def lookahead
+        now + calendar.feed_lookahead * ONE_DAY
+      end
+
+      def now
+        @now ||= Time.now
+      end
+    end
+  end
+end

data/lib/almanack/serialized_transformation.rb

@@ -0,0 +1,53 @@
+module Almanack
+  class SerializedTransformation
+
+    def initialize(subject)
+      @subject = subject
+      @transformations = {}
+    end
+
+    def key(&block)
+      @transformations[:key] = block
+    end
+
+    def value(&block)
+      @transformations[:value] = block
+    end
+
+    def apply
+      recurse(cloned)
+    end
+
+    private
+
+    def cloned
+      @subject.dup
+    end
+
+    def recursable?(node)
+      node.is_a?(Array) || node.is_a?(Hash)
+    end
+
+    def no_change
+      -> (obj) { obj }
+    end
+
+    def transformation(type, entity)
+      (@transformations[type] || no_change).call(entity)
+    end
+
+    def recurse(entity)
+      cloned = case entity
+      when Array
+        entity.map { |child| recurse(child) }
+      when Hash
+        entity.each_with_object({}) do |(key, value), hash|
+          transformed_key = recursable?(key) ? recurse(key) : transformation(:key, key)
+          hash[transformed_key] = recurse(value)
+        end
+      else
+        transformation(:value, entity)
+      end
+    end
+  end
+end

data/lib/almanack/server/environment.rb

@@ -0,0 +1,38 @@
+module Almanack
+  module ServerContext
+    module Environment
+      def basename(file)
+        Pathname(file).split.last.to_s.split(".", 2).first
+      end
+
+      def locate_asset(name, within: path)
+        name = basename(name)
+        path = settings.root.join(within)
+        available = Pathname.glob(path.join("*"))
+        asset = available.find { |path| basename(path) == name }
+        raise "Could not find stylesheet #{name} inside #{available}" if asset.nil?
+        asset
+      end
+
+      def auto_render_template(asset)
+        renderer = asset.extname.split(".").last
+        content = asset.read
+        respond_to?(renderer) ? send(renderer, content) : content
+      end
+
+      def auto_render_asset(*args)
+        auto_render_template locate_asset(*args)
+      end
+
+      def theme_stylesheet_path
+        settings.root.join('stylesheets')
+      end
+
+      def register_sass_loadpaths!
+        if !Sass.load_paths.include?(theme_stylesheet_path)
+          Sass.load_paths << theme_stylesheet_path
+        end
+      end
+    end
+  end
+end

data/lib/almanack/server/helpers.rb

@@ -1,36 +1,40 @@
-Almanack::Server.helpers do
-  # @return The URL to your consolidated iCal feed.
-  def feed_url
-    "webcal://#{request.host}:#{request.port}/#{settings.feed_path}"
-  end
+module Almanack
+  module ServerContext
+    module Helpers
+      # @return The URL to your consolidated iCal feed.
+      def feed_url
+        "webcal://#{request.host}:#{request.port}/#{settings.feed_path}"
+      end
 
-  # @return The URL to Almanack's project homepage.
-  def almanack_project_url
-    Almanack::HOMEPAGE
-  end
+      # @return The URL to Almanack's project homepage.
+      def almanack_project_url
+        Almanack::HOMEPAGE
+      end
 
-  # @return The URL to Almanack's issues page.
-  def almanack_issues_url
-    Almanack::ISSUES
-  end
+      # @return The URL to Almanack's issues page.
+      def almanack_issues_url
+        Almanack::ISSUES
+      end
 
-  # @return The current time.
-  def now
-    Time.now
-  end
+      # @return The current time.
+      def now
+        Time.now
+      end
 
-  # @return The calendar.
-  def calendar
-    @calendar ||= Almanack.calendar
-  end
+      # @return The calendar.
+      def calendar
+        @calendar ||= Almanack.calendar
+      end
 
-  # @return The title of the page.
-  def page_title(separator: " – ")
-    [@title, calendar.title].compact.join(separator)
-  end
+      # @return The title of the page.
+      def page_title(separator: " – ")
+        [@title, calendar.title].compact.join(separator)
+      end
 
-  # Use to set the title of the page.
-  def title(value)
-    @title = value
+      # Use to set the title of the page.
+      def title(value)
+        @title = value
+      end
+    end
   end
 end