slice-ruby 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ba0c0ad115c43862e724220ecb9de82bbf4e945
+  data.tar.gz: 33167ae57e9c4bd5172534dd9ff8135c77ca640b
+SHA512:
+  metadata.gz: e5a6fbb27f75bf8f48a10b40097ff2402f1d5a824e33ff9d60c0a9145b53712b65459bce735f22373a3cb89ce68f013038be0435da9e3db5c28bea3768f06bb4
+  data.tar.gz: 840b0bd98254b2cc86a55eadb81029397e4f421f0a6e69acacfd17fd2c3ad90bbc9b0ced813104f7bdf6b48cfc75b5812c91646c98897d19398490c8171072a6

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+- 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in slice.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Naoki Orii
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Makefile

@@ -0,0 +1,18 @@
+all: test doc
+
+doc:
+	git grep -h "^\s\+# \?" lib/slice/response.rb               | sed -E 's; +# ?;;' > doc/response.md
+	git grep -h "^\s\+# \?" lib/slice/client.rb                 | sed -E 's; +# ?;;' > doc/client.md
+	git grep -h "^\s\+# \?" lib/slice/resource_based_methods.rb | sed -E 's; +# ?;;' >> doc/client.md
+
+release:
+	bundle exec rake release
+
+setup:
+	gem install bundler
+	bundle install
+
+test:
+	bundle exec rspec
+
+.PHONY: doc release setup test

data/README.md

@@ -0,0 +1,102 @@
+# slice-ruby
+
+A Ruby interface to the Slice API
+
+## Quick start
+
+Install via Rubygems
+
+`gem install slice-ruby`
+
+... or add to your Gemfile
+
+`gem "slice-ruby", "~> 0.1"`
+
+## Sample Usage
+
+```ruby
+require 'slice'
+
+oauth = Slice::OAuth.new(client_id, client_secret, redirect_url)
+auth_url = oauth.generate_auth_url
+
+access_token = oauth.authenticate! auth_code
+
+client = Slice::Client.new(access_token: access_token.token)
+client.list_items
+client.list_orders
+client.create_order(orderTitle: 'Your Amazon.com order', ...)
+client.get_order(123)
+client.update_order(123, orderTotal: 395, ...)
+client.list_items(limit: 3, offset: 10)
+client.list_items(limit: 3, offset: 10).status
+client.list_items(limit: 3, offset: 10).headers
+client.list_items(limit: 3, offset: 10).body
+```
+
+See [doc/client.md](doc/client.md) for more details
+
+Also, note that `access_token` is a `OAuth2::AccessToken` object from [intridea/oauth2](https://github.com/intridea/oauth2), so you can call methods on it such as `access_token.expired?` and `access_token.refresh!`
+
+## CLI Usage
+
+You can use the `slice` executable to call `Slice::Client`'s methods.
+
+```
+$ slice <method> <arguments> [headers|params] [options]
+           |          |          |      |         |
+           |          |          |      |         `-- -H, --host
+           |          |          |      |             -a, --access-token
+           |          |          |      |             -c, --color
+           |          |          |      |             -h, --help
+           |          |          |      |                 --header
+           |          |          |      |                 --no-body
+           |          |          |      |
+           |          |          |      `------------ key=value or key:=value
+           |          |          |
+           |          |          `------------------- Key:value
+           |          |
+           |          `------------------------------ required arguments for the method
+           |
+           `----------------------------------------- method name
+
+
+$ slice list_orders
+$ slice list_merchants
+$ slice list_orders limit=3 offset=2
+
+```
+
+### Method and Arguments
+
+Pass [Slice::Client's method name](doc/client.md) and required arguments.
+
+### Access token
+
+Accepts access token via `-a, --access-token` or `SLICE_ACCESS_TOKEN` environment variable.
+
+### Headers
+
+To set custom request headers, use `Key:value` syntax.
+
+```
+$ slice list_items "Authorization:Bearer 1234567890abcdef1234567890abcdef"
+```
+
+### Params
+
+Params are used for query string in the GET method, or for request body in other methods.
+You can set params by `key=value` or `key:=value` syntax.
+`key=value` is parsed into its String value, while `key:=value` is parsed into its JSON value (e.g. key:=17 will be `{"key":17}`).
+The `slice` executable also accepts params via STDIN.
+
+```
+$ slice list_items page=2 per_page=10
+$ slice create_item < params.json
+```
+
+![](images/cli.png)
+
+## Acknowledgements
+
+A good chunk of the code has been shamelessly taken from [increments/qiita-rb](https://github.com/increments/qiita-rb).

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new("spec")
+task :default => :spec

data/bin/slice

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "slice"
+
+builder = Slice::CommandBuilder.new(ARGV)
+command = builder.call
+command.call

data/lib/slice.rb

@@ -0,0 +1,22 @@
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/string/strip"
+require "faraday"
+require "faraday_middleware"
+require "json"
+require "rack/utils"
+require "rainbow"
+require "rouge"
+require "slop"
+
+require "slice/arguments"
+require "slice/client"
+require "slice/command_builder"
+require "slice/commands/base"
+require "slice/commands/error"
+require "slice/commands/request"
+require "slice/oauth"
+require "slice/resource_based_methods"
+require "slice/response"
+require "slice/response_renderer"
+require "slice/version"

data/lib/slice/arguments.rb

@@ -0,0 +1,133 @@
+module Slice
+  class Arguments
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def access_token
+      slop_options["access-token"] || ENV["SLICE_ACCESS_TOKEN"]
+    end
+
+    def arguments
+      parsed_argv_data[:arguments]
+    end
+
+    def color
+      slop_options["color"]
+    end
+
+    def error_message
+      slop_options.to_s
+    end
+
+    def headers
+      parsed_argv_data[:headers]
+    end
+
+    def host
+      slop_options["host"]
+    end
+
+    def method_name
+      ARGV[0]
+    end
+
+    def params
+      params_from_stdin.merge(parsed_argv_data[:params])
+    end
+
+    def show_body
+      !slop_options["no-body"]
+    end
+
+    def show_header
+      slop_options["header"]
+    end
+
+    def valid?
+      has_valid_slop_options? && has_valid_method_name? && has_valid_arguments? && !has_invalid_json_input?
+    end
+
+    private
+
+    def has_input_from_stdin?
+      has_pipe_input? || has_redirect_input?
+    end
+
+    def has_invalid_json_input?
+      params_from_stdin
+      false
+    rescue JSON::ParserError
+      true
+    end
+
+    def has_pipe_input?
+      File.pipe?(STDIN)
+    end
+
+    def has_redirect_input?
+      File.select([STDIN], [], [], 0) != nil
+    end
+
+    def has_valid_arguments?
+      -(Client.instance_method(method_name).arity) - 1 == arguments.length
+    end
+
+    def has_valid_method_name?
+      !method_name.nil? && Client.instance_methods.include?(method_name.to_sym)
+    end
+
+    def has_valid_slop_options?
+      !slop_options["help"]
+    rescue
+      false
+    end
+
+    def params_from_stdin
+      @params_from_stdin ||= begin
+        if has_input_from_stdin?
+          JSON.parse(STDIN.read)
+        else
+          {}
+        end
+      end
+    end
+
+    def parsed_argv_data
+      @parsed_argv_data ||= begin
+        params = {}
+        headers = {}
+        arguments = []
+        ARGV[1..-1].each do |section|
+          case
+          when /(?<key>.+):(?<value>[^=]+)/ =~ section
+            headers[key] = value
+          when /(?<key>.+):=(?<value>.+)/ =~ section
+            params[key] = JSON.parse(%<{"key":#{value}}>)["key"]
+          when /(?<key>.+)=(?<value>.+)/ =~ section
+            params[key] = value
+          else
+            arguments << section
+          end
+        end
+        {
+          arguments: arguments,
+          headers: headers,
+          params: params,
+        }
+      end
+    end
+
+    def slop_options
+      @slop_options ||= Slop.parse!(@argv) do
+        banner "Usage: slice <method> [arguments] [headers|params] [options]"
+        on "H", "host=", "Change API server's host"
+        on "a", "access-token=", "Access token"
+        on "c", "color", "Color output"
+        on "h", "help", "Display help message"
+        on "header", "Show response header"
+        on "no-body", "Hide response body"
+      end
+    end
+  end
+end

data/lib/slice/client.rb

@@ -0,0 +1,153 @@
+require "uri"
+require "slice/resource_based_methods"
+require "slice/version"
+
+## Slice::Client
+# A class for API client to send HTTP requests.
+#
+module Slice
+  class Client
+    DEFAULT_ACCEPT = "application/json"
+
+    DEFAULT_HOST = "api.slice.com"
+
+    DEFAULT_USER_AGENT = "Slice Ruby Gem #{Slice::VERSION}"
+
+    DEFAULT_HEADERS = {
+      "Accept" => DEFAULT_ACCEPT,
+      "User-Agent" => DEFAULT_USER_AGENT,
+    }
+
+    include ResourceBasedMethods
+
+    # ### Slice::Client.new(options = {})
+    # Creates a new instance of `Slice::Client` class.
+    # `options` can have following key-values:
+    #
+    # * `access_token` - (String) Access token issued to authenticate and authorize user.
+    # * `host` - (String) Hostname where this client accesses to.
+    #
+    # ```rb
+    # Slice::Client.new
+    # Slice::Client.new(access_token: "...")
+    # ```
+    #
+    def initialize(access_token: nil, host: nil, ssl: true)
+      @access_token = access_token
+      @host = host
+      @ssl = ssl
+    end
+
+    # ### Slice::Client#get(path, params = nil, headers = nil)
+    # Sends GET request with given parameters, then returns a `Slice::Response`.
+    # `params` are url-encoded and used as URI query string.
+    #
+    # ```rb
+    # client.get("/api/v1/items", page: 2)
+    # ```
+    #
+    def get(path, params = nil, headers = nil)
+      process(:get, path, params, headers)
+    end
+
+    # ### Slice::Client#post(path, params = nil, headers = nil)
+    # Sends POST request with given parameters, then returns a Slice::Response.
+    # `params` are JSON-encoded and used as request body.
+    #
+    # ```rb
+    # client.post("/api/v1/items", category: "...", price: "...")
+    # ```
+    #
+    def post(path, params = nil, headers = nil)
+      process(:post, path, params, headers)
+    end
+
+    # ### Slice::Client#patch(path, params = nil, headers = nil)
+    # Sends PATCH request with given parameters, then returns a Slice::Response.
+    # `params` are JSON-encoded and used as request body.
+    #
+    # ```rb
+    # client.patch("/api/v1/items/123", title: "...", body: "...")
+    # ```
+    #
+    def patch(path, params = nil, headers = nil)
+      process(:patch, path, params, headers)
+    end
+
+    # ### Slice::Client#put(path, params = nil, headers = nil)
+    # Sends PUT request, then returns a Slice::Response.
+    # `params` are JSON-encoded and used as request body.
+    #
+    # ```rb
+    # client.put("/api/v1/items/123")
+    # ```
+    #
+    def put(path, params = nil, headers = nil)
+      process(:put, path, params, headers)
+    end
+
+    # ### Slice::Client#delete(path, params = nil, headers = nil)
+    # Sends DELETE request, then returns a Slice::Response.
+    # `params` are url-encoded and used as URI query string.
+    #
+    # ```rb
+    # client.delete("/api/v1/items/123")
+    # ```
+    #
+    def delete(path, params = nil, headers = nil)
+      process(:delete, path, params, headers)
+    end
+
+    # ### Slice::Client#connection
+    # Returns a Faraday::Connection to customize by your favorite middlewares.
+    #
+    # ```rb
+    # client.connection.response :logger
+    # ```
+    #
+    def connection
+      @connection ||= Faraday.new(faraday_client_options) do |connection|
+        connection.request :json
+        connection.response :json
+        connection.adapter Faraday.default_adapter
+      end
+    end
+
+    private
+
+    def default_headers
+      headers = DEFAULT_HEADERS.clone
+      headers["Authorization"] = "Bearer #{@access_token}" if @access_token
+      headers
+    end
+
+    def faraday_client_options
+      {
+        headers: default_headers,
+        ssl: {
+          verify: @ssl,
+        },
+        url: url_prefix,
+      }
+    end
+
+    def host
+      @host || DEFAULT_HOST
+    end
+
+    def process(request_method, path, params, headers)
+      Slice::Response.new(
+        connection.send(
+          request_method,
+          URI.escape(path),
+          params,
+          headers,
+        )
+      )
+    end
+
+    def url_prefix
+      "https://#{host}"
+    end
+  end
+end