stastic 0.1.0 → 0.2.0

data/Rakefile

@@ -0,0 +1,11 @@
+require "rubygems"
+require "rake"
+require "rspec/core/rake_task"
+
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+

data/bin/stastic

@@ -1,5 +1,15 @@
 #!/usr/bin/env ruby
 
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
 require 'stastic'
+require 'stastic/command'
+require 'stastic/generator'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Stastic::Command.run(command, args)
 
-puts "stastic (http://stastic.com) - #{Stastic::VERSION}"

data/lib/server.rb

@@ -0,0 +1,43 @@
+require 'webrick'
+
+class Server < WEBrick::HTTPServer
+  class NonCachingFileHandler < WEBrick::HTTPServlet::FileHandler
+    def prevent_caching(res)
+      res['ETag']          = nil
+      res['Last-Modified'] = Time.now + 100**4
+      res['Cache-Control'] = 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0'
+      res['Pragma']        = 'no-cache'
+      res['Expires']       = Time.now - 100**4
+    end
+
+    def do_GET(req, res)
+      super
+      prevent_caching(res)
+    end
+  end
+
+  def initialize(path, port)
+    @port = port
+    @path = path
+    mime_types = WEBrick::HTTPUtils::DefaultMimeTypes
+    mime_types.store 'js', 'application/javascript'
+    super(
+      :Port => @port,
+      :MimeTypes => mime_types
+    )
+  end
+
+  def start
+    mount("/", NonCachingFileHandler, @path)
+    t = Thread.new {
+      super
+    }
+
+    trap("INT") { shutdown }
+    t.join()
+  end
+end
+
+
+
+

data/lib/stastic/client.rb

@@ -0,0 +1,72 @@
+require 'rest-client'
+require 'json'
+
+module Stastic
+  class InvalidCredentials < RestClient::Forbidden; end
+  class ValidationFailed < RestClient::UnprocessableEntity; end
+
+  class Client
+    attr_accessor :user, :token, :host
+
+    def self.authenticate(email, password)
+      client = new
+      client.request(:get, "/authenticate", {:email => email, :password => password})["token"]
+    end
+
+    def self.request(method, uri, payload = nil, headers = {})
+      client = new
+      client.request(method, uri, payload, headers)
+    end
+
+    def self.create(name = nil)
+      if name
+        request(:post, "/sites", {:site => {:name => name}})
+      else
+        request(:post, "/sites")
+      end
+    end
+
+    def self.list
+      request(:get, "/sites")
+    end
+
+    def self.publish(site_id, archive_path)
+      request(:put, "/sites/#{site_id}/publish", {:site => {:archive => File.new(archive_path)}})
+    end
+
+    def self.rename(site_id, name)
+      request(:put, "/sites/#{site_id}", {:site => {:name => name}})
+    end
+
+    def self.add_domain(site_id, domain_name)
+      request(:post, "/sites/#{site_id}/domains", {:domain => {:host => domain_name}})
+    end
+
+    def self.remove_domain(site_id, domain_name)
+      request(:delete, "/sites/#{site_id}/domains/#{domain_name}")
+    end
+
+    def initialize(host = "http://stastic.com")
+      if Stastic::Config.exists?
+        self.user = Stastic::Config.user
+        self.token = Stastic::Config.token
+      end
+      self.host = host
+    end
+
+    def request(method, uri, payload = nil, headers = {})
+      headers.merge!(:accept => 'json', "X-STASTIC" => Stastic::VERSION)
+
+      response = RestClient::Request.execute(
+        :method   => method,
+        :url      => host + uri,
+        :headers  => headers,
+        :payload  => payload,
+        :user     => user,
+        :password => token)
+
+      return JSON::parse(response.body)
+    end
+
+  end
+end

data/lib/stastic/command.rb

@@ -0,0 +1,41 @@
+require 'trollop'
+require 'stastic/config'
+require 'stastic/client'
+require 'stastic/commands/base'
+Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each { |c| require c }
+
+module Stastic
+  module Command
+    extend self
+
+    class UnknownCommand < RuntimeError; end
+    class InvalidOptions < RuntimeError; end
+
+
+    def run(cmd, args)
+      begin
+        klass, method = parse_command(cmd)
+        runner = klass.new(args)
+        raise UnknownCommand unless runner.respond_to?(method)
+        runner.send(method)
+      rescue UnknownCommand
+        puts "Invalid command `#{cmd}`. Run `stastic help` for available commands."
+      rescue InvalidOptions
+        puts "Invalid options for `#{cmd}`. Run `stastic help` for more information."
+      end
+    end
+
+    private
+
+      def parse_command(cmd)
+        begin
+          klass, method = cmd.split(':')
+          return eval("Stastic::Command::#{klass.capitalize}"), method || :index
+        rescue NameError, NoMethodError
+          puts $!.inspect
+          raise UnknownCommand
+        end
+      end
+
+  end
+end

data/lib/stastic/commands/auth.rb

@@ -0,0 +1,8 @@
+module Stastic::Command
+  class Auth < Base
+    
+    def index
+      request_credentials
+    end
+  end
+end

data/lib/stastic/commands/base.rb

@@ -0,0 +1,96 @@
+module Stastic::Command
+  class Base
+  
+    def initialize(args); end
+
+    private
+
+      def request_credentials
+        print "Enter your Stastic login credentials.\n\n"
+        attempts = 0
+
+        begin
+          attempts += 1
+          print "  Email: "
+          email = ask
+          print "  Password: "
+          password = ask_for_password
+          token = Stastic::Client.authenticate(email, password)
+        rescue Stastic::InvalidCredentials
+          if attempts < 3
+            print "\nInvalid credentials - try again.\n\n"
+            retry
+          else
+            print "\nInvalid credentials -- too many tries!\n"
+            exit
+          end
+        end
+
+        Stastic::Config.update({:user => email, :token => token}, :global)
+        print "\nYour credentials have been saved.\n"
+      end
+
+      def echo_off
+        system "stty -echo"
+      end
+
+      def echo_on
+        system "stty echo"
+      end
+
+      def ask
+        gets.strip
+      end
+
+      def ask_for_password
+        echo_off
+        password = ask
+        puts
+        echo_on
+        return password
+      end
+
+      def with_valid_user
+        request_credentials unless Stastic::Config.credentials?
+        begin
+          yield
+        rescue RestClient::Forbidden
+          request_credentials
+          retry 
+        rescue RestClient::UnprocessableEntity => e
+          puts "There was an error with the request:"
+          puts 
+          JSON.parse(e.response)['errors'].each do |msg|
+            printf("   * %s\n", msg)
+          end
+          puts
+          exit -1
+        end
+      end
+
+      def with_valid_site
+        request_credentials unless Stastic::Config.credentials?
+        missing_site_id unless Stastic::Config.site_defined?
+        begin
+          yield
+        rescue RestClient::Forbidden
+          request_credentials
+          retry 
+        rescue RestClient::UnprocessableEntity => e
+          puts "Error:"
+          puts e.response.to_s
+          puts
+          exit
+        end
+      end
+
+      def missing_site_id
+        puts "No Stastic Site found.  To create a site, run:"
+        puts 
+        puts "  stastic create"
+        puts
+        exit
+      end 
+  end
+end
+

data/lib/stastic/commands/create.rb

@@ -0,0 +1,68 @@
+module Stastic::Command
+  class Create < Base
+    attr_accessor :name
+    attr_accessor :template
+
+    def initialize(args = [])
+      case args.size
+      when 0
+        self.name = nil
+      when 1
+        if args.first == "--template"
+          self.template = "default"
+        else
+          self.name = args.first
+        end
+      when 2
+        raise(Stastic::InvalidOptions) unless args.first == "--template"
+        self.template = "default"
+        self.name = args.last
+        puts self.template
+      else
+        raise(Stastic::InvalidOptions)
+      end
+    end
+
+    def index
+      if template
+        copy_template("#{File.dirname(__FILE__)}/../../../templates/#{template}/")
+      end
+
+      response = with_valid_user do
+        Stastic::Client.create(name)
+      end
+
+      if response["id"]
+        Stastic::Config.add(:site_id => response["id"])
+      end
+
+      if response["name"]
+        Stastic::Config.add(:name => response["name"])
+        print "Your site has been created!\n\n"
+        print "  Site Name: #{Stastic::Config.name}\n"
+        print "  Site URL:  #{Stastic::Config.name}.stastic.com\n\n"
+        print "Use `stastic publish` to publish your site whenever you're ready.\n"
+      end
+
+    end
+
+    private
+
+      def copy_template(src)
+        dest = Dir.pwd
+        Dir.foreach(src) do |file|
+          s = File.join(src, file)
+          d = File.join(dest, file)
+
+          if File.directory?(s)
+            FileUtils.cp_r(s, d, :preserve => true)
+          else
+            FileUtils.cp(s,d, :preserve => true)
+          end
+        end
+
+      end
+
+  end
+end
+

data/lib/stastic/commands/domains.rb

@@ -0,0 +1,41 @@
+module Stastic::Command
+  class Domains < Base
+    attr_accessor :domain_name
+
+    def initialize(args = [])
+      case args.size
+      when 1
+        self.domain_name = args.first
+        raise(Stastic::Command::InvalidOptions) unless validate_domain(domain_name)
+      else
+        raise(Stastic::Command::InvalidOptions)
+      end
+
+    end
+
+    def index
+    end
+
+    def add
+      print "Adding domain #{domain_name}... "
+      with_valid_site do
+        Stastic::Client.add_domain(Stastic::Config.site_id, domain_name)
+      end
+      puts "Success\n"
+    end
+
+    def remove
+      print "Removing domain #{domain_name}... "
+      with_valid_site do
+        Stastic::Client.remove_domain(Stastic::Config.site_id, domain_name)
+      end
+      puts "Success\n"
+    end
+
+    private
+      def validate_domain(domain_name)
+        domain_name =~ /^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.){1,3}([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$/
+      end
+
+  end
+end

data/lib/stastic/commands/help.rb

@@ -0,0 +1,33 @@
+module Stastic::Command
+  class Help < Base
+
+    def index
+      print usage
+    end
+
+    private
+
+      def usage
+        <<-EOF
+stastic (#{Stastic::VERSION}) - command-line tool for managing your Stastic sites
+
+Available Commands
+------------------
+
+  stastic help                     # You're looking at it!
+  stastic create [name]            # Create a site (using the current directory)
+  stastic publish                  # Publish the site
+  stastic info                     # Show info about the current site
+  stastic list                     # List sites associated with your account
+  stastic rename <name>            # Rename the site (name.stastic.com)
+  stastic domains:add <domain>     # Add a domain to the site (example.com)
+  stastic domains:remove <domain>  # Remove a domain from the site
+  stastic preview                  # Start local HTTP server
+  stastic set site_root <path>     # Set the local path to the static files
+
+        EOF
+      end
+
+  end
+end
+

data/lib/stastic/commands/info.rb

@@ -0,0 +1,26 @@
+module Stastic::Command
+  class Info < Base
+    attr_accessor :name
+
+    def index
+      puts info
+    end
+
+    private
+
+      def info
+        generator = Stastic::Generator.detect
+        <<-EOF
+stastic version  :   #{Stastic::VERSION}
+user             :   #{Stastic::Config.user}
+active site name :   #{Stastic::Config.name}
+active site id   :   #{Stastic::Config.site_id}
+active site url  :   http://#{Stastic::Config.name}.stastic.com/
+
+generator        :  #{generator.desc}
+site_root        :  #{generator.site_root}
+
+        EOF
+      end
+  end
+end

data/lib/stastic/commands/list.rb

@@ -0,0 +1,37 @@
+module Stastic::Command
+  class List < Base
+
+    def index
+      list
+    end
+
+    private
+
+      def list
+        response = with_valid_user { Stastic::Client.list }
+
+        puts header
+        response['sites'].each do |site| 
+          site_info(site, site['id'] == Stastic::Config.site_id ? "*" : " ")
+        end
+        puts 
+      end
+
+      def header
+        <<-EOF
+
+Your Stastic Sites
+-----------------
+
+  name                           url
+  ----                           ---
+        EOF
+      end
+
+      def site_info(site, marker = " ")
+        printf("%-2s%-30s http://%s.stastic.com\n", marker, site['name'], site['name']) 
+      end
+
+  end
+end
+

data/lib/stastic/commands/preview.rb

@@ -0,0 +1,9 @@
+module Stastic::Command
+  class Preview < Base
+
+    def index
+      generator = Stastic::Generator.detect
+      generator.preview
+    end
+  end
+end

data/lib/stastic/commands/publish.rb

@@ -0,0 +1,34 @@
+module Stastic::Command
+  class Publish < Base
+
+    def index
+      publish
+    end
+
+    private
+      def publish
+        puts "Detecting..."
+        generator = Stastic::Generator.detect
+        puts "Found: #{generator.desc}"
+        
+        puts "Building..."
+        generator.build
+
+        puts "Packaging..."
+        archive_path = generator.package
+
+        print "Uploading..."
+        upload(archive_path)
+
+      end
+
+      def upload(archive_path)
+        print "Uploading your archive...\n"
+        reponse = with_valid_site do
+          Stastic::Client.publish(Stastic::Config.site_id, archive_path)
+        end
+        puts "Complete\n"
+      end
+
+  end
+end

data/lib/stastic/commands/rename.rb

@@ -0,0 +1,25 @@
+module Stastic::Command
+  class Rename < Base
+    attr_accessor :new_name
+
+    def initialize(args = [])
+      case args.size
+      when 1
+        self.new_name = args.first
+      else
+        raise(Stastic::Command::InvalidOptions)
+      end
+    end
+
+    def index
+      print "Changing Site Name... "
+      response = with_valid_site do
+        Stastic::Client.rename(Stastic::Config.site_id, new_name)
+      end
+      Stastic::Config.update(:name => response["name"])
+      puts "Success\n"
+    end
+
+  end
+end
+

data/lib/stastic/commands/set.rb

@@ -0,0 +1,54 @@
+module Stastic::Command
+  class Set < Base
+    attr_accessor :settings
+
+    VALID_SETTINGS = [:site_root, :site_id]
+
+    def initialize(args = [])
+      case args.size
+      when 0
+        raise(Stastic::Command::InvalidOptions)
+      else
+        self.settings = parse_args(args)
+        validate_settings(settings)
+      end
+    end
+
+    def index
+      update_settings(settings)
+    end
+
+    private
+      def parse_args(args)
+        args.inject(Hash.new) do |h,arg|
+          k,v = arg.split('=')
+          h[k.to_sym] = v
+          h
+        end
+      end
+
+      def validate_settings(settings)
+        raise(Stastic::Command::InvalidOptions) unless settings.keys.all? {|key| VALID_SETTINGS.include?(key)}
+      end
+
+      def set_name(name)
+        print "Changing Site Name... "
+        begin
+          response = Stastic::Client.request(:put, "/sites/#{Stastic::Config.site_id}", {:site => {:name => name}})
+        rescue Stastic::InvalidCredentials
+          request_credentials
+          retry 
+        rescue Stastic::ValidationFailed
+          print "Could not change site name\n"
+          exit
+        end
+
+        puts "Success\n"
+        true
+      end
+
+      def update_settings(settings)
+        Stastic::Config.update(settings)
+      end
+  end
+end