skypager 0.1.2 → 0.2.0

data/lib/skypager/data/request.rb

@@ -1,12 +0,0 @@
-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

@@ -1,194 +0,0 @@
-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
-
-        processors.each do |processor|
-          original = self.processed.dup
-          modified = []
-
-          original.each_with_index do |record, index|
-            previous = original[index - 1]
-            modified.push(processor.call(record, index, previous: previous, set: original))
-          end
-
-          self.processed = modified
-        end
-      end
-
-      def processors &block
-        @processors ||= []
-        @processors << block if block_given?
-        @processors
-      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 fresh_on_server?
-        need_to_refresh?
-      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 = File.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.gsub!("-","_")
-        @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

@@ -1,30 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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 domain
-      parent_domain
-    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

@@ -1,271 +0,0 @@
-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'
-    option :skypager, {}, 'Options to be passed to Skypager.config'
-
-    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     => {}.to_mash,
-                                  :synced_folders   => {}.to_mash,
-                                  :deploy_options   => {}.to_mash,
-                                  :site_name        => File.basename(app.root))
-
-      options_hash.each do |key, value|
-        app.set(key, value)
-      end
-
-      unless ($skypager_command || ENV['DISABLE_SKYPAGER_SYNC']) && !$enable_skypager_sync_from_command
-        app.ready do
-          sync_folders()
-          load_stores()
-          # Load the data source and save it to disk
-        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
-         if !Skypager.config.dropbox_setup? && !Skypager.config.google_setup? && !Skypager.config.amazon_setup?
-           puts "\n\n== Use Skypager's one time setup script to automate huge parts of your workflow!"
-           puts "Run 'skypager setup' now"
-           puts "\n\n\n"
-           raise 'Run skypager setup first'
-         end
-
-          data_sources.values.each do |data_source|
-            data_source.refresh_if_stale?
-          end if development?
-        end
-      end
-
-      app.before_configuration do
-      end
-
-      app.after_build do
-        site.requires_build!(false)
-        deploy! if auto_deploy?
-      end
-
-      app.after_configuration do
-        save_site_config()
-      end
-
-    end
-
-    helpers do
-      def deploy!
-        site.deploy(build_path)
-      end
-
-      def auto_deploy?
-        !!deploy_options[:auto_deploy]
-      end
-
-      def save_site_config
-        syncable_config = site.config.syncables ||= {}.to_mash
-
-        syncables.each do |folder|
-          type = folder.type
-          cfg = syncable_config[type] ||= {}.to_mash
-          cfg.paths ||= []
-          cfg.paths.push(syncable.remote_path.to_s)
-          cfg.paths.uniq!
-        end
-
-        if Skypager.config.dropbox_setup?
-          syncable_config.dropbox ||= {}
-          syncable_config.dropbox.uid = Skypager.dropbox.account.uid
-        end
-
-        site.set(:syncables, syncable_config)
-      end
-
-      def site
-        return @site if @site
-
-        @site = Skypager::Site.new(site_name, deploy_options: deploy_options).tap do |site|
-          site.load_config
-          site.set(:deploy_options, deploy_options)
-          site.set(:root, root) unless site.config.key?(:root)
-        end
-      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 ||= {}
-
-        self.deploy_options[:auto_deploy] = !!options[:auto_deploy]
-
-        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 app
-        self
-      end
-
-      def stores
-        data_sources.values
-      end
-
-      def load_stores persist=false
-        data_sources.each do |name, source|
-          source.refresh
-          source.save_to_disk if persist || !source.persisted?
-          data.callbacks(name, -> { source.data })
-        end
-
-        after_stores_loaded.each do |callback|
-          callback = app.method(callback) if callback.is_a?(Symbol)
-          app.instance_eval(&callback) if callback.respond_to?(:call)
-        end
-      end
-
-      # middleman does have an event system, we can piggyback on that instead
-      def after_stores_loaded &block
-        @after_stores_callbacks ||= []
-        @after_stores_callbacks << block if block_given?
-        @after_stores_callbacks
-      end
-
-      def sync_folders
-        syncables.each(&:sync)
-      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
-                            JSON.parse(dropbox_data_file.read).to_mash
-                          rescue
-                            {}.to_mash
-                          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)