skypager 0.0.2

data/lib/skypager/data/request.rb

@@ -0,0 +1,12 @@
+module Skypager
+  module Data
+    class Request < Source
+      requires :host,
+               :path
+
+      def initialize name, options={}
+        super
+      end
+    end
+  end
+end

data/lib/skypager/data/source.rb

@@ -0,0 +1,171 @@
+module Skypager
+  module Data
+    class Source
+      attr_reader :options, :name
+      attr_accessor :raw, :processed, :format, :scopes, :slug_column, :refreshed_at, :path
+
+      class << self
+        attr_accessor :required_options
+      end
+
+      def self.requires *args
+        self.required_options = args
+      end
+
+      def initialize(name, options={})
+        @name     ||= name
+        @options  ||= options
+        @format   ||= options.fetch(:format, :json)
+        @path     ||= options.fetch(:path) { Pathname(Dir.pwd()) }
+
+        @slug_column = options.fetch(:slug_column, :_id)
+
+        ensure_valid_options!
+      end
+
+      def to_s
+        data.to_json
+      end
+
+      # defines a scope for the records in this data source
+      # a scope is a named filter, implemented in the form of a block
+      # which is passed each record.  if the block returns true, it returns
+      # the record:
+      #
+      # Example:
+      #
+      # data_source(:galleries) do
+      #   scope :active, -> {|record| record.state == "active" }
+      # end
+      def scope(*args, block)
+        name = args.first
+        (self.scopes ||= {})[name.to_sym] = block
+      end
+
+      def has_scope?(scope_name)
+        scope_name && (self.scopes ||= {}).key?(scope_name.to_sym)
+      end
+
+      # compute properties takes the raw data of each record
+      # and sets additional properties on the records which may
+      # not be persited in the data source
+      def compute_properties
+        self.processed && self.processed.map! do |row|
+          if slug_column && row.respond_to?(slug_column)
+            row.slug = row.send(slug_column).to_s.parameterize
+          end
+
+          row
+        end
+      end
+
+      # makes sure that the required options for this data source
+      # are passed for any instance of the data source
+      def ensure_valid_options!
+        missing_options = (Array(self.class.required_options) - options.keys.map(&:to_sym))
+
+        missing_options.reject! do |key|
+          respond_to?(key) && send(key).present?
+        end
+
+        if missing_options.length > 0
+          raise 'Error: failure to supply the following options:' + missing_options.map(&:to_s).join(",")
+        end
+      end
+
+      def select(&block)
+        data.select(&block)
+      end
+
+      def refresh
+        fetch
+        process
+        self.refreshed_at = Time.now.to_i
+        self
+      end
+
+      def refresh_if_stale?
+        refresh! if stale?
+      end
+
+      # A data source is stale if it has been populated
+      # and the age is greater than the max age we allow.
+      def stale?
+        !need_to_refresh? && (age > max_age)
+      end
+
+      def max_age
+        max = ENV['MAX_DATA_SOURCE_AGE']
+        (max && max.to_i) || 120
+      end
+
+      # how long since this data source has been refreshed?
+      def age
+        Time.now.to_i - refreshed_at.to_i
+      end
+
+      def data
+        refresh if need_to_refresh?
+        processed
+      end
+
+      def refresh!
+        refresh
+        save_to_disk
+      end
+
+      def need_to_refresh?
+        !(@fetched && @_processed)
+      end
+
+      def fetch
+        @fetched = true
+        self.raw = []
+      end
+
+      def preprocess
+        self.raw.dup
+      end
+
+      def process
+        @_processed = true
+        self.processed = preprocess
+        # set_id
+        compute_properties
+        self.processed
+      end
+
+      def refreshed_at
+        return @refreshed_at if @refreshed_at.to_i > 0
+
+        if path_to_file.exist?
+          @refreshed_at = FileUtils.mtime(path.join(file)).to_i
+        end
+      end
+
+      def save_to_disk
+        unless path_to_file.dirname.exist?
+          FileUtils.mkdir(path_to_file.dirname)
+        end
+
+        path_to_file.open('w+') {|fh| fh.write(to_s) }
+      end
+
+      def persisted?
+        path_to_file && path_to_file.exist?
+      end
+
+      def file
+        @file ||= name.parameterize if name.respond_to?(:parameterize)
+        @file = "#{@file}.json" unless @file.match(/\.json/i)
+        @file
+      end
+
+      def path_to_file
+        Pathname(path).join("#{ file }")
+      end
+    end
+
+  end
+end
+

data/lib/skypager/data/source_routes_proxy.rb

@@ -0,0 +1,30 @@
+require 'uri_template'
+
+module Skypager
+  module Data
+    class SourceRoutesProxy
+      def initialize(app, data_source, options={})
+        template = URITemplate.new(:colon, options[:url])
+
+        data = data_source.data
+
+        # If we're passed a scope that means we should
+        # limit the set of records we are mapping to by the
+        # scope defined in this data source
+        if options[:scope]
+          tester = data_source.scopes[options[:scope]]
+        end
+
+        to = options[:template] || options[:to]
+
+        as = options.fetch(:as, :current_record)
+
+        data.each do |row|
+          url = template.expand(row.to_hash)
+          app.proxy(url, to, :locals => {as => row}, :ignore => true)
+        end
+
+      end
+    end
+  end
+end

data/lib/skypager/dns.rb

@@ -0,0 +1,65 @@
+module Skypager::DNS
+  class Manager
+    include Singleton
+
+    def self.method_missing(meth, *args, &block)
+      if client.respond_to?(meth)
+        client.send(meth, *args, &block)
+      end
+    end
+
+    def self.client
+      instance.tap {|i| i.authorize }
+    end
+
+    def setup(options={})
+      unless Skypager.config.dnsimple_api_token
+        if dnsimple_api_token = options.fetch(:dnsimple_api_token) { ask("What is the DNSimple API Token?", String) }
+          Skypager.config.set 'dnsimple_api_token', dnsimple_api_token
+        end
+      end
+
+      unless Skypager.config.dnsimple_username
+        if dnsimple_username = options.fetch(:dnsimple_username) { ask("What is the DNSimple Username or email?", String) }
+          Skypager.config.set 'dnsimple_username', dnsimple_username
+        end
+      end
+    end
+
+    def authorize
+      @authorized ||= begin
+                        DNSimple::Client.api_token = Skypager.config.dnsimple_api_token
+                        DNSimple::Client.username = Skypager.config.dnsimple_username
+                      end
+    end
+
+    def parent_domain
+      @parent_domain ||= DNSimple::Domain.find(Skypager.config.domain)
+    end
+
+    def domain_records
+      DNSimple::Record.all(parent_domain)
+    end
+
+    def cname_records
+      domain_records.select do |record|
+        record.record_type == "CNAME"
+      end
+    end
+
+    def deployment_alias_records
+      cname_records.select do |record|
+        record.content.include? "s3-website-us-east-1.amazonaws.com"
+      end
+    end
+
+    # Used to link up a skypager internal site to an S3 Bucket
+    def setup_cname internal_name, external_host
+      authorize
+
+      unless cname_records.find {|r| r.name == internal_name }
+        DNSimple::Record.create(parent_domain, internal_name, 'CNAME', external_host)
+      end
+    end
+  end
+end

data/lib/skypager/extension.rb

@@ -0,0 +1,203 @@
+require 'middleman-core' unless defined?(::Middleman)
+
+module Skypager
+  class Extension < ::Middleman::Extension
+
+    option :site_name, nil, 'The name of this site'
+    option :synced_folders, {}, 'The settings for dropbox source syncing'
+    option :data_sources, [], 'The data source mappings for this site'
+    option :deploy_options, {}, 'Deploy options: domain, bucket_name, use_cdn, aliases, auto_deploy'
+
+    def initialize(app, options_hash={}, &block)
+      # if only skypager/extension is required this will be necessary
+      require 'skypager' unless defined?(Skypager::Data)
+
+      super
+
+      app.include(ClassMethods)
+
+      options_hash.reverse_merge!(:data_sources     => {},
+                                  :synced_folders   => {},
+                                  :deploy_options   => {},
+                                  :site_name        => File.basename(app.root))
+
+      options_hash.each do |key, value|
+        app.set(key, value)
+      end
+
+      unless $skypager_command
+        app.ready do
+          synced_folders.each do |name, folder|
+            folder.sync()
+          end
+
+          # Load the data source and save it to disk
+          data_sources.each do |name, source|
+            source.refresh
+            source.save_to_disk unless source.persisted?
+            data.callbacks(name, -> { source.data })
+          end
+        end
+
+        # In development, we will try to refresh remote data stores (e.g. google spreadsheets)
+        # before every request once every minute or so
+        app.before do
+          data_sources.values.each do |data_source|
+            data_source.refresh_if_stale?
+          end if development?
+        end
+
+        app.after_build do
+          if deploy_options[:auto_deploy]
+            app.site.deploy()
+          end
+        end
+
+      end
+    end
+
+    helpers do
+      def dropbox(path)
+      end
+
+      def site
+        @site ||= Skypager::Site.new(site_name)
+      end
+
+      def deployment
+        @deployment ||= Skypager::Sync::Amazon.client(deploy_options)
+      end
+    end
+
+    module ClassMethods
+      def build_path
+        Pathname(build_dir)
+      end
+
+      def data_path
+        Pathname(data_dir)
+      end
+
+      def source_path
+        Pathname(source_dir)
+      end
+
+      def deploy_to(provider, options={})
+        self.deploy_options ||= {}
+
+        if provider == :amazon || provider == :aws
+          self.deploy_options[:domain] = options[:domain] || Skypager.config.domain
+          self.deploy_options[:bucket_name] = options[:bucket_name] || "#{ site_name }.#{ deploy_options[:domain] }"
+          self.deploy_options[:custom_domain] = options[:custom_domain]
+        end
+      end
+
+      def dropbox_sync(*args)
+        folder  = args.first
+        options = args.extract_options!
+
+        local_path = folder
+        remote_path ||= options[:to] || options[:with] || args[1] || local_path
+
+        dropbox_data[:folders] ||= {}
+
+        f = dropbox_data[:folders][folder] ||= {
+          remote_path: remote_path,
+          local_path: local_path,
+          type: "dropbox",
+          cursor: nil,
+          site_name: site_name,
+          folder: folder
+        }
+
+        dropbox_data[:folders][folder].merge!(options)
+
+        self.synced_folders[folder] = Skypager::Sync::Folder.new(f.merge(app: self, root:Pathname(root)))
+
+        save_dropbox_settings
+      end
+
+      def syncables
+        @syncables ||= Array(synced_folders.values)
+      end
+
+      def syncable
+        syncables.first
+      end
+
+      def save_dropbox_settings
+        json = dropbox_data.to_json
+        dropbox_data_file.open('w+') {|fh| fh.write(json) }
+      end
+
+      def dropbox_data
+        unless Pathname(data_dir).exist?
+          FileUtils.mkdir_p Pathname(data_dir)
+        end
+
+        @dropbox_data ||= begin
+                            Hashie::Mash.new(JSON.parse(dropbox_data_file.read))
+                          rescue
+                            Hashie::Mash.new({})
+                          end
+      end
+
+      def dropbox_data_file
+        Pathname(data_dir).join('dropbox.json').tap do |path|
+          unless path.exist?
+            path.open('w+') {|fh| fh.write("{}") }
+          end
+        end
+      end
+
+      def google_spreadsheets
+        Skypager::Data::GoogleSpreadsheet
+      end
+
+      def map_data_source(name, *args)
+        options = args.extract_options!
+        options[:data_source] = name
+        scope = options[:scope] = args.first
+
+        _data_source = data_sources[name]
+
+        if !_data_source
+          raise "Could not find a data source named #{ name }"
+        end
+
+        if scope && !_data_source.has_scope?(scope)
+          raise "Invalid scope for #{name} data source"
+        end
+
+        Skypager::Data::SourceRoutesProxy.new(self, _data_source, options)
+      end
+
+      def data_source(name, options=nil, &block)
+        if options.nil? && !block_given? && self.data_sources[name.to_sym]
+          return self.data_sources[name.to_sym]
+        end
+
+        source =  case
+                  when options[:type].to_s == "google"
+                    unless existing = google_spreadsheets[options[:key] || options[:title]]
+                      raise 'Could not find a spreadsheet. You can use the `skypager list spreadsheets` command to find the right one, or the `skypager create data source` command to create a new one.'
+                    end
+
+                    existing
+                  when options[:type].to_s == "excel"
+
+                  when options[:type].to_s == "request"
+
+                  end
+
+        (self.data_sources[name.to_sym] = source).tap do |ds|
+          ds.instance_eval(&block) if block.respond_to?(:call)
+          ds.slug_column = (options[:slug] || options[:slug_column]) if (options[:slug] || options[:slug_column])
+          ds.path ||= Pathname(root).join(data_dir)
+        end
+      end
+    end
+  end
+end
+
+::Middleman::Extensions.register(:skypager, Skypager::Extension)