skypager 0.1.2 → 0.2.0

data/examples/gallery-site/source/tutorial.md

@@ -1,151 +0,0 @@
-# Using the skypager gem to build dynamic, data driven sites with middleman
-
-Skypager takes an already powerful website creation tool 'Middleman' and adds a few key integrations
-with services like Dropbox and Google Drive / Google Documents, as well as Amazon S3, Cloudfront, and DNSimple.
-
-This automates a ton of boring setup chores and allows designers and developers to crank out dynamic, data driven websites
-without having to worry too much about servers.  And since these websites are all technically 'static', and backed by a global CDN, 
-Skypager websites will be fast as hell. 
-
-The skypager gem is open source.  If you want to automate your builds and releases every time files change on Dropbox or any time data changes in a Google Spreadsheet, you
-can either run the skypager build server on your own server or you can sign up on skypager.io and we will set all of that up for you as well.
-
-## Using the skypager gem in your own projecs
-
-In this tutorial, we are going to use the skypager gem and the skypager middleman extension to build a photo gallery website.
-
-The information about our photo galleries is going to be stored in a google spreadsheet.  The photo galleries themselves, are going to be stored on Dropbox.
-
-- 1) create a new middleman project
-
-  ```bash
-  middleman init
-  ```
-
-- 2) add the skypager gem, and activate it in your config.rb
-
-  ```ruby
-  # Gemfile
-
-  gem 'skypager', github: "architects/skypager", branch: "master"
-
-  # config.rb
-
-  activate :skypager
-  ```
-
-- 3) setup the google drive and dropbox integrations.  this requires you
-  to create applications in the respective developer consoles for google
-  and dropbox
-
-  ```bash
-  alias be='bundle exec'
-  be skypager setup
-  ```
-
-- 4) once your applications are setup, you can create a google
-  spreadsheet datasource.  the spreadsheet data source will be used to
-  generate dynamic pages and content to be displayed with our html
-  templates
-
-  ```bash
-  be skypager create datasource galleries
-  ```
-
-  follow the prompts, selecting 'google spreadsheet' and enter in
-  some fields for this data source.
-
-  for this example we will use:
-
-  `title description cover_image status release_date`
-
-  this will end up creating the following line in our `config.rb`
-
-  ```ruby
-  # config.rb
-
-  data_source :galleries, :type => "google", :key => "..."
-  ```
-
-- 5) in order to get pretty urls from our data source, we are going to 
-    configure the data source to make 'slugs' out of the title column.
-
-    edit the config.rb file:
-
-  ```ruby
-  # config.rb
-
-  data_source :galleries, :type => "google", :key => "...", :slug_column => 'title'
-  ```
-
-- 6) with this done, we will now have access to the galleries data
-  source from within any template, or from within the `config.rb` file
-  itself which means we can use the data source to generate dynamic
-  urls such as: `/galleries/my-gallery-title` which will display the
-  info in the spreasheet.
-
-- 7) let's open up the actual spreadsheet and add some rows to it.
-
-  ```bash
-  be skypager edit datasource galleries
-  ```
-
-  this will open up the spreadsheet in your browser for you.
-
-- 8) with some actual data in our spreadsheet, lets get a couple of
-  pages rendered with it. open up the `source/index.html.erb` file and
-  put in the following content.
-
-  ```erb
-  <h1>Galleries</h1>
-
-  <ul>
-    <% data.galleries.each do |gallery| %>
-      <li>
-        <p><%= gallery.title %></p>
-      </li>
-    <% end %>
-  </ul>
-  ```
-
-  here we are accessing the data from the galleries spreadsheet in our template
-  by iterating over `data.galleries` and listing each one.  If we edit the spreadsheet,
-  and add a new row, and then refresh the page, you will see the new data show up. 
-
-  **note:** if you don't see data showing up, you can restart your development server. in development,
-  skypager attempts to keep up to date, but in order not to keep nagging the server we do 
-  some checking and sometimes this might make data stale.  
-
-- 9) we can create separate pages for each row in the spreadsheet. 
-
-  ```ruby
-  # config.rb
-  map_data_source(:galleries, :url => "/galleries/:slug", :to => "gallery.html.erb", :as => :gallery)
-  ```
-
-  this will dynamically add routes for every row in the galleries data source, and display that individual
-  row using the `gallery.html.erb` template
-
-  since we added the `slug_column` option and set it to title, then it will turn our title column data
-  into a friendly url.  for example: `My Awesome Gallery` becomes available at `/galleries/my-awesome-gallery`
-  
-  editing the `source/gallery.html.erb` template file:
- 
-  ```erb
-  <h1><%= gallery.title %></h1>
-  <%= image_tag(gallery.cover_image) %>
-  <p><%= gallery.description %></p> 
-  ``` 
-
-  and now editing the `source/index.html.erb` template file we can link to our galleries.
-
-  ```erb
-  <a href="/galleries/<%= gallery.slug %>">
-    <%= gallery.title %>
-  </a>
-  ```
-
-### Using dropbox as a media store for your website content
-
-- 10) a gallery isn't much without some images. in this tutorial, we are going to integrate with Dropbox to store our 
-      image files. 

data/lib/skypager/builder.rb

@@ -1,158 +0,0 @@
-module Skypager
-  class Builder
-
-    attr_reader :app,
-                :source,
-                :logger,
-                :options
-
-    def initialize(app, options={})
-      @app = app
-      @options = options.reverse_merge(clean: true, verbose: true)
-      @source_dir = app.source_path
-      @build_dir  = app.build_path
-      @to_clean   = Set.new
-
-      @logger = app.logger
-      @rack = ::Rack::Test::Session.new(app.class.to_rack_app)
-    end
-
-    def build(force=false)
-      return unless force || needs_build?
-
-      queue_current_paths if should_clean?
-      execute!
-      clean! if should_clean?
-
-      app.site.requires_build!(false)
-      app.deploy! if app.auto_deploy?
-    end
-
-    protected
-
-    def clean!
-      @to_clean.each do |f|
-        FileUtils.rm_rf(f)
-      end
-
-      Dir[@build_dir.join('**', '*')].select { |d| File.directory?(d) }.each do |d|
-        FileUtils.rm_rf(d) if Pathname(d).children.empty?
-      end
-    end
-
-    def should_clean?
-      options[:clean]
-    end
-
-    def queue_current_paths
-      return unless app.build_path.exist?
-
-      paths = ::Middleman::Util.all_files_under(app.build_path).map(&:realpath).select(&:file?)
-
-      @to_clean += paths.select do |path|
-        path.to_s !~ /\/\./ || path.to_s =~ /\.(htaccess|htpasswd)/
-      end
-
-      return unless RUBY_PLATFORM =~ /darwin/
-
-      # handle UTF-8-MAC filename on MacOS
-      @to_clean = @to_clean.map { |path| path.to_s.encode('UTF-8', 'UTF-8-MAC') }
-    end
-
-    def needs_build?
-      @needs_build = app.data_sources.values.any? do |ds|
-        ds.fresh_on_server?
-      end
-
-      # TODO
-      # Add support for google drive folders, github folder changes
-      @needs_build = @needs_build || app.syncables.any? do |syncable|
-        syncable.dropbox? && syncable.has_remote_changes?
-      end
-
-      @needs_build
-    end
-
-    def execute!
-      sort_order = %w(.png .jpeg .jpg .gif .bmp .svg .svgz .ico .webp .woff .otf .ttf .eot .js .css)
-
-      app.sitemap.resources.select do |resource|
-        resource.ext == '.css'
-      end.each(&method(:build_resource))
-
-      app.files.find_new_files((@source_dir + app.images_dir).relative_path_from(app.root_path))
-      app.sitemap.ensure_resource_list_updated!
-
-      resources = app.sitemap.resources.sort_by do |r|
-        sort_order.index(r.ext) || 100
-      end
-
-      if @build_dir.expand_path.relative_path_from(@source_dir).to_s =~ /\A[.\/]+\Z/
-        raise ":build_dir (#{@build_dir}) cannot be a parent of :source_dir (#{@source_dir})"
-      end
-
-      resources.reject do |resource|
-        resource.ext == '.css'
-      end.each(&method(:build_resource))
-
-    end
-
-    def build_resource(resource)
-      return if options[:glob] && !File.fnmatch(options[:glob], resource.destination_path)
-
-      output_path = render_to_file(resource)
-
-      return unless should_clean? && output_path.exist?
-
-      if RUBY_PLATFORM =~ /darwin/
-        # handle UTF-8-MAC filename on MacOS
-
-        @to_clean.delete(output_path.realpath.to_s.encode('UTF-8', 'UTF-8-MAC'))
-      else
-        @to_clean.delete(output_path.realpath)
-      end
-    end
-
-    def render_to_file(resource)
-      output_file = @build_dir + resource.destination_path.gsub('%20', ' ')
-
-      if resource.binary?
-        if !output_file.exist?
-          #base.say_status :create, output_file, :green
-        elsif FileUtils.compare_file(resource.source_file, output_file)
-          #base.say_status :identical, output_file, :blue
-          return output_file
-        else
-          #base.say_status :update, output_file, :yellow
-        end
-
-        output_file.dirname.mkpath
-        FileUtils.cp(resource.source_file, output_file)
-      else
-        begin
-          response = @rack.get(URI.escape(resource.request_path))
-
-          if response.status == 200
-            Pathname(output_file).open("w+") {|fh| fh.write binary_encode(response.body) }
-          else
-            handle_error(output_file, response.body)
-          end
-        rescue => e
-          handle_error(output_file, "#{e}\n#{e.backtrace.join("\n")}", e)
-        end
-      end
-
-      output_file
-    end
-
-    def handle_error(file_name, response, *args)
-
-    end
-
-    def binary_encode(string)
-      string.force_encoding('ascii-8bit') if string.respond_to?(:force_encoding)
-      string
-    end
-
-  end
-end

data/lib/skypager/cli/commands/build.rb

@@ -1,64 +0,0 @@
-if defined?(Slim::Engine)
-  Slim::Engine.disable_option_validator!
-end
-
-command 'build' do |c|
-  c.syntax = "skypager build"
-  c.description = "performs a build on the site"
-
-  c.option "--force", nil, 'Whether or not we should force a build'
-
-  $enable_skypager_sync_from_command = true
-
-  c.action do |args, options|
-    require 'rack/test'
-    require 'skypager/builder'
-
-    app = Skypager.app
-    builder = Skypager::Builder.new(app, clean: true, verbose: true)
-
-    if app.site.requires_build? || options.force.present?
-      puts "== Building site: #{ app.site.name }"
-      builder.build(options.force.present?)
-    else
-      puts "== Site is not marked to be built. Skipping unless the --force flag is passed"
-    end
-  end
-end
-
-command 'run build server' do |c|
-  c.syntax = 'skypager run build server [OPTIONS]'
-  c.description = 'run the skypager webhook handler'
-
-  c.option '--port', Fixnum, 'What port should this run on?'
-  c.option '--host', String, 'What host should this run on?'
-
-  c.action do |args, options|
-    require 'rack'
-    require 'skypager/builder/server'
-
-    opts = {
-      Host: options.host || '0.0.0.0',
-      Port: options.port || 3000
-    }
-
-    Rack::Handler::WEBrick.run(Skypager::Builder::Server.new, opts) do |server|
-       [:INT, :TERM].each { |sig| trap(sig) { server.stop } }
-    end
-
-  end
-end
-
-command 'generate builder crontab' do |c|
-  c.syntax = 'skypager generate builder crontab'
-  c.description = 'generates a crontab which will build sites that are marked to be built'
-
-  c.action do |args, options|
-    lines = Skypager::Site.sites.map do |site|
-      "*/5 * * * * cd #{ site.root } && bundle exec skypager build"
-    end
-
-    puts "== run 'crontab -e' as root and add the following content:\n\n\n"
-    puts lines.join("\n")
-  end
-end

data/lib/skypager/cli/commands/config.rb

@@ -1,58 +0,0 @@
-command 'config localize' do |c|
-  c.syntax = "skypager config localize"
-  c.description = "sets up a local skypager config file for this project"
-
-  c.action do |args, options|
-    path = Skypager.config.cwd_config_path
-
-    unless path.exist?
-      path.open("w+") do |fh|
-        fh.write(Skypager.config.home_config.to_json)
-      end
-    end
-  end
-end
-
-command 'config' do |c|
-  c.syntax = 'skypager config [options]'
-  c.description = 'list skypager configuration settings'
-
-  c.action do |_args, _options|
-    Skypager::Configuration.initialize!
-
-    Skypager.config.show
-  end
-end
-
-command 'config get' do |c|
-  c.syntax = 'skypager config:get [options]'
-  c.description = 'view a skypager configuration setting'
-
-  c.action do |args, _options|
-    Skypager::Configuration.initialize!
-
-    puts Skypager.config.get(args.first)
-  end
-end
-
-command 'config set' do |c|
-  c.syntax = 'skypager config:set KEY=VALUE KEY=VALUE [options]'
-  c.description = 'manipulate skypager configuration settings'
-
-  c.option '--global', nil, 'Set the configuration globally'
-
-  c.action do |args, _options|
-    Skypager::Configuration.initialize!
-
-    args.select { |pair| pair.match(/=/) }
-      .map { |pair| pair.split('=') }
-      .each do |group|
-        key, value = group
-        Skypager.config.set(key, value, false, global: !!(_options.global))
-      end
-
-    Skypager.config.save!
-
-    Skypager.config.show
-  end
-end

data/lib/skypager/cli/commands/create.rb

@@ -1,98 +0,0 @@
-create_command = lambda do |c|
-  c.syntax = 'skypager create data source NAME [options]'
-  c.description = "Create a data source"
-
-  c.option "--type", nil, "What type of data source? google-spreadsheet, dropbox-excel, rest-endpoint"
-  c.option "--spreadsheet-name", nil, "What is the spreadsheet name? will be used to find the key"
-  c.option "--dropbox-path", nil, "What is the path to the excel?"
-  c.option "--fields", "", "comma separated list of fields"
-  c.option "--collaborators", "", "comma separated list of email address to share this data source with"
-
-  c.action do |args, options|
-    name = args.first
-
-    options.default :fields => "",
-                    :collaborators => ""
-
-    name ||= ask("What should the name of this data source be?", String)
-
-    type = options.type
-    type ||= choose("Where will this data be stored?", "Google Spreadsheet", "Excel on Dropbox")
-
-    types = {
-      "Google Spreadsheet" => "google",
-      "Excel on Dropbox" => "dropbox-excel",
-      "REST API Endpoint" => "rest-endpoint"
-    }
-
-    type            = types.fetch(type) { type }
-    fields          = options.fields.split(",").map(&:strip)
-    collaborators   = options.collaborators.split(",").map(&:strip)
-
-    if fields.empty?
-      fields = ask("Enter the names of the columns. Make sure to use underscore_instead_of_space:", Array)
-    end
-
-    case type
-
-    when "google"
-      spreadsheet = Skypager::Data::GoogleSpreadsheet.create_from_data([], title: name, headers: fields, skypager_config_info: true)
-
-      if !collaborators.empty?
-        spreadsheet.share_write_access_with(*collaborators)
-      end
-
-    when "dropbox-excel"
-
-    end
-  end
-end
-
-command 'create datasource' do |c|
-  create_command.call(c)
-end
-
-command 'create data source' do |c|
-  create_command.call(c)
-end
-
-command 'create syncable' do |c|
-  c.syntax      = 'skypager create synced folder NAME [options]'
-  c.description = "Create a synced folder"
-
-  c.option "--type", nil, "What service is holding the folder? dropbox, google-drive"
-  c.option "--skip-config", nil, 'Skip modifying the config'
-
-  c.action do |args, options|
-    type = options.type
-    type ||= choose("What service is holding the folder?", "Google Drive", "Dropbox")
-
-    types = {
-      "Google Drive" => "google-drive",
-      "Dropbox" => "dropbox"
-    }
-
-    if defined?(::Middleman)
-      app = ::Middleman::Application.server.inst do
-        set :environment, 'development'
-      end
-    end
-
-    type    = types.fetch(type) { type }
-
-    if type == "dropbox"
-      Skypager::Sync::Dropbox.create_site_folder(app.site_name)
-
-      puts "\n\n"
-      local_path = ask("Enter a relative path to the folder in this project that you would like to sync with Dropbox. e.g. source/images or source", String)
-      puts "\n\n"
-      remote_path = ask("Enter the remote path. leave blank to use the same", String)
-      remote_path = local_path if remote_path.to_s.length == 0
-
-      Skypager.dropbox.sync_folders(local_path, remote_path, app: app, append_config: !!!options.skip_config)
-
-    elsif type == "google-drive"
-      Skypager::Sync::Google.create_site_folder(app.site_name)
-    end
-  end
-end