blockspring-cli 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db5beb5a65470e420b59d1e7aec32e116ad5c254
-  data.tar.gz: 12bcb0cb001032d1bea981f9a0c74629feb52e1c
+  metadata.gz: 292e435f1ec64d78ded1b4ac70d3bfa987ae6645
+  data.tar.gz: 17844302c5ef29a5192b41dbd378e54e9f0b0b5a
 SHA512:
-  metadata.gz: 3b8a3d0d14ca9c1c9e6742644988dc1180bfa9c404fadea1a43717f58568f42c7a92a61d49f2df4fb847d52d686e7731619c4d94d0e3c687f8550d3b3cac3cdf
-  data.tar.gz: 9a106fff42463f833d7026662f54421f119654b06a37a7733d2515930f7d58775942c8df552846092d323f25d81b7805a4cf3597e7ec6e8791ec481610c19005
+  metadata.gz: 616de4bda0e684004c6eb093a97f7e36077f883c76f5fe871d96d074acdbf87f19e32a42339c51c65d17c6a9b7d39db0b715edcfc0c3aa323cd99670373959b7
+  data.tar.gz: 3c8dddad60d3b0634089805bb1724cb9de2fa6f9c756632e79996d4759575dd376119df599b09648544dad4b0acf0de1f1414eed10b598d1c200d45e1be42e58

data/README.md

@@ -1,36 +1,178 @@
 # Blockspring CLI
 
-The Blockspring CLI is used to manage and run blocks from the command line.
+The Blockspring CLI is used to manage, run, and deploy cloud functions (we call them "blocks") from the command line.
 
-## Installation
+Once deployed, you can use your blocks from just about anywhere. For more info, check out: https://www.blockspring.com.
 
-Install via command line:
+## Getting Started
+
+Let's deploy our first block in less than 60 seconds.
+
+To get started, we'll need ruby. If you don't have ruby on your machine, first visit https://www.ruby-lang.org/en/installation/ to install it.
+
+#### Step 1: Install the Blockspring-CLI tool
 
     $ gem install blockspring-cli
 
-## Usage
+#### Step 2: Login to Blockspring   
+We'll need to login with our Blockspring account. No Blockspring account yet? Sign up here first: https://api.blockspring.com/users/sign_up.
+
+    $ blockspring login
+    Enter your Blockspring credentials.
+    Username or email: jason@example.com
+    Password (typing will be hidden):
+    You are logged in as jason.
+
+#### Step 3: Create a new block
+We can create blocks in ruby, python, javascript, php, or R (and more languages are coming soon). Let's create a ruby block since ruby is already installed on our machine.
+
+    $ blockspring new rb "My new Ruby block"
+    Creating directory my-new-ruby-block
+    Creating script file my-new-ruby-block/block.rb
+    Creating config file my-new-ruby-block/blockspring.json
+
+#### Step 4: Deploy your block
+Let's enter our new block's directory and deploy.
+
+    $ cd my-new-ruby-block
+    $ blockspring push
+    Syncronizing script file ./block.rb
+    Syncronizing config file ./blockspring.json
+
+#### Step 5: Visit your block's homepage
+Now that our block is now deployed we can visit its homepage to see it in action.
+
+    $ blockspring open
+    
+That's it! We've deployed our first block. To learn more about the Blockspring-CLI, check out the [API in Detail](#api-in-detail) section below. Otherwise, let's pick out our favorite language and start writing our own blocks.
+
+######Language-Specific Libraries
+<table>
+  <tr>
+    <th>If you prefer this language...</th>
+    <th>Use this library...</th>
+  </tr>
+  <tr>
+    <td>Ruby</td>
+    <td style="text-align: left"><a href="https://github.com/blockspring/blockspring.rb">https://github.com/blockspring/blockspring.rb</a></td>
+  </tr>
+  <tr>
+    <td>Python</td>
+    <td style="text-align: left"><a href="https://github.com/blockspring/blockspring.py">https://github.com/blockspring/blockspring.py</a></td>
+  </tr>
+  <tr>
+    <td>Javascript</td>
+    <td style="text-align: left"><a href="https://github.com/blockspring/blockspring.js">https://github.com/blockspring/blockspring.js</a></td>
+  </tr>
+  <tr>
+    <td>PHP</td>
+    <td style="text-align: left"><a href="https://github.com/blockspring/blockspring.php">https://github.com/blockspring/blockspring.php</a></td>
+  </tr>
+  <tr>
+    <td>R</td>
+    <td style="text-align: left"><a href="https://github.com/blockspring/blockspring.R">https://github.com/blockspring/blockspring.R</a></td>
+  </tr>
+</table>
+
+<br/>
+## API in Detail
+Let's explore the Blockspring-CLI tool API in detail.
+
+####Authentication
+######LOGIN
+You must be logged in to run Blockspring-CLI tool commands.
+
+    $ blockspring login
+    
+######LOGOUT
+
+    $ blockspring logout
+
+####Block Management
+######GET
+We can ```GET``` a block down to our local machine. The block will be saved in a new directory and can be edited or even executed locally.
+
+    $ blockspring get <block id>
+
+Below is an example ```GET``` request for the following block: https://api.blockspring.com/pkpp1233/6dd22564137f10b8108ec6c8f354f031. The block id can be found directly in the URL.
+
+    $ blockspring get pkpp1233/6dd22564137f10b8108ec6c8f354f031
+
+######NEW
+To create a ```NEW``` block:
+
+    $ blockspring new <language> <block name>
+    
+Here are explicit commands to create a new block in each supported language:
+    
+    // Ruby: creates dir w/ block.rb & blockspring.json
+    $ blockspring new rb "fun ruby block"
+    
+    // Python: creates dir w/ block.py & blockspring.json
+    $ blockspring new py "fun python block"
+    
+    // Javascript: creates dir w/ block.js & blockspring.json
+    $ blockspring new js "fun javascript block"
+    
+    // PHP: creates dir w/ block.php & blockspring.json
+    $ blockspring new php "fun php block"
+    
+    // R: creates dir w/ block.R & blockspring.json
+    $ blockspring new R "fun R block"
+    
+The ```NEW``` command creates a working directory for your block and populates that directory with two files: a ```block.*``` (asterisk is for your language of choice - file holds your function) and a ```blockspring.json``` (this file holds the block's configs and additional data).
+
+######PULL
+We can ```PULL``` a block's recent changes down to our machine. ```PULL``` is used from our block's working directory.
+
+    $ blockspring pull
+    
+Note: If the block isn't in a directory on our machine yet, we either need to use ```GET``` to retrieve it or ```NEW``` to create it.
+    
+######PUSH
+We can ```PUSH``` a block's recent changes up to Blockspring. ```PUSH``` is used from our block's working directory.
+
+    $ blockspring push
+
+######OPEN
+
+We can ```OPEN``` our block's homepage on Blockspring. ```OPEN``` is used from our block's working directory.
+
+    $ blockspring open
+
+####Executing Blocks from the Command Line
+######RUN
+We can execute our blocks directly from the command line with the ```RUN``` command. ```RUN``` can be used to execute blocks remotely, or to execute blocks locally on your machine. Blocks, whether they're executed in the cloud or locally, can easily pipe together with other command-line tools.
+
+Let's execute a block remotely by passing parameters into stdin or via command-line arguments.
+
+    // execute with stdin (recommended).
+    $ echo '{"num1": 30, "num2": 50}' | blockspring run <block id>
+    
+    // execute with args.
+    $ blockspring run <block id> --num1=30 --num2=50
+
+Remember, a block id can be found directly in a block's URL. The block id for https://api.blockspring.com/pkpp1233/ce6c7c230d8a4ff4d22ae96654ca4bd2 is pkpp1233/ce6c7c230d8a4ff4d22ae96654ca4bd2. Try running the sum with this block id.
+
+    $ echo '{"num1": 30, "num2": 50}' | blockspring run pkpp1233/ce6c7c230d8a4ff4d22ae96654ca4bd2
+    
+######RUN:LOCAL
+
+We can also run blocks locally on our computer. Let's do a ```GET``` request to a local directory and then use ```RUN:LOCAL``` to execute that block locally without sending any data to Blockspring.
 
-#### Login with your api.blockspring.com account.
-```bash
-blockspring login
-```
+    $ blockspring get pkpp1233/ce6c7c230d8a4ff4d22ae96654ca4bd2
+    $ cd summer-ce6c7c23
+    $ echo '{"num1": 30, "num2": 50}' | blockspring run:local python block.py
+    
+Note: To```RUN``` blocks locally, we need to have the proper runtimes and dependencies installed. This is a Blockspring WIP. To run the above example locally, we need to make sure we have the python runtime and the blockspring python library installed (see [Language-Specific Libraries](#language-specific-libraries)).
 
-#### Create a new block
-```bash
-blockspring new js "My new JS block"
-cd my-new-js-block
-```
+####Help
 
-#### Edit your function
-```bash
-echo "console.log('hi');" > block.js
-```
+    $ blockspring help
 
-#### Push
-```bash
-blockspring push
-```
+If ```HELP``` isn't particularly helpful for your problem, just email us: <a href="mailto:founders@blockspring.com">founders@blockspring.com</a>
 
+<br/>
 ## License
 
 MIT - see the license file.

data/lib/blockspring/cli/auth.rb

@@ -81,11 +81,15 @@ class Blockspring::CLI::Auth
     end
 
     def api_key(login, password)
-      response = RestClient.post "#{base_url}/cli/login", { login: login, password: password }, user_agent: Blockspring::CLI.user_agent
-      if response.code == 200
-        response.to_str
-      else
-        raise 'login failed'
+      response = RestClient.post "#{base_url}/cli/login", { login: login, password: password }, user_agent: Blockspring::CLI.user_agent do |response, request, result, &block|
+        case response.code
+        when 200
+          response.to_str
+        when 401
+          error('Invalid username or password.')
+        else
+          error('login failed')
+        end
       end
     end
 

data/lib/blockspring/cli/command/block.rb

@@ -109,12 +109,17 @@ class Blockspring::CLI::Command::Block < Blockspring::CLI::Command::Base
       uri = "#{Blockspring::CLI::Auth.base_url}/cli/blocks"
     end
 
-    begin
-      response = RestClient.post uri, payload.to_json, :content_type => :json, :accept => :json, params: { api_key: key }, user_agent: Blockspring::CLI.user_agent
-      json_response = JSON.parse(response.body)
-      save_block_files(json_response, '.', 'Syncronizing')
-    rescue RestClient::Exception => msg
-      error(msg.inspect)
+
+    response = RestClient.post(uri, payload.to_json, :content_type => :json, :accept => :json, params: { api_key: key }, user_agent: Blockspring::CLI.user_agent) do |response, request, result, &block|
+      case response.code
+      when 200
+        json_response = JSON.parse(response.body)
+        save_block_files(json_response, '.', 'Syncronizing')
+      when 401
+        error('You must be logged in to push a block')
+      when 404
+        error('That block does not exist or you don\'t have permission to push to it')
+      end
     end
   end
 
@@ -136,6 +141,9 @@ class Blockspring::CLI::Command::Block < Blockspring::CLI::Command::Base
     language = @args[0]
     name = @args[1]
 
+    return error('You must specify a language') unless language
+    return error('You must specify a name for your block') unless name
+
     begin
 
       block = get_template(language)
@@ -178,8 +186,16 @@ protected
   # TODO: move this to another file like 'api'
   def get_block(block_id)
     _user, key = Blockspring::CLI::Auth.get_credentials
-    response = RestClient.get "#{Blockspring::CLI::Auth.base_url}/cli/blocks/#{block_id}", params: { api_key: key }, user_agent: Blockspring::CLI.user_agent
-    JSON.parse(response.to_str)
+    response = RestClient.get("#{Blockspring::CLI::Auth.base_url}/cli/blocks/#{block_id}", params: { api_key: key }, user_agent: Blockspring::CLI.user_agent) do |response, request, result, &block|
+      case response.code
+      when 200
+        JSON.parse(response.to_str)
+      when 404
+        error('That block does not exist or you don\'t have permission to access it')
+      else
+        error('Could not get block data from server')
+      end
+    end
   end
 
   def get_template(format)

data/lib/blockspring/cli/version.rb

@@ -1,5 +1,5 @@
 module Blockspring
   module CLI
-    VERSION = "0.0.9"
+    VERSION = "0.0.10"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blockspring-cli
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Blockspring
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-04 00:00:00.000000000 Z
+date: 2014-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler