aries 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a721b5050b0c0d62fac4c082a6999db9b0b7fd32
+  data.tar.gz: 83c31100b9aa075a09bad91bfa6215edf82fd5b6
+SHA512:
+  metadata.gz: abbab34967cf7e96b9552886c2f777aeffefd67eca7295e180f871fc468065649a91faf586f58ff56325c5f10962e8ee48d055861b821f320242ceb67d5885aa
+  data.tar.gz: c7fa32042565cc17e52379d51d5c53d7497d228cf7781ef0872d80b3278635dabc6764c0ac320189f969c19abbcb16fb1d527a96659d0e9e5e62ed4b525a1cf2

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

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

data/Gemfile

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

data/README.md

@@ -0,0 +1,102 @@
+# Aries
+
+Aries is a iOS(Swift), Andorid(not yet, but future) HTTP client generator for APIs represented with JSON Schema
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'aries'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install aries
+
+## Usage
+
+### Generate a client
+
+Aries generates an HTTP client from a JSON schema that describes your API. Look at prmd for tooling to help write a JSON schema. When you have a JSON schema prepared you can generate a client for your API
+
+    $ bin/aries generate json-schema.json
+
+### Custom Configuration
+
+Aries can setup costom config for api client class name, base url, output path.
+
+    $ bin/aries generate json-schema.json --name MyApi \
+                                          --url http://api.myapp.com \
+                                          --output /path/to/dir
+
+### Swift(v1,1)
+
+Dependent on [SwiftTask](https://github.com/ReactKit/SwiftTask), [Alamofire](https://github.com/Alamofire/Alamofire), [URITemplate](https://github.com/kylef/URITemplate.swift).
+Aries api client should be used with these libraries, and works like promise style.
+
+Aries api client behaves use the following.
+
+```
+
+Api.TodoItem.Read().success { (value: AnyObject) -> Void in
+    let items = value as [[String:AnyObject]]
+    println(items)
+}.failure { (error, isCancelled) -> Void in
+    return
+}
+
+```
+
+Aries has Custom Delegation for request, response for authenticatin, custom header, etc.
+
+```
+
+@UIApplicationMain
+class AppDelegate: UIResponder, UIApplicationDelegate, AriesApiDelegate {
+
+    self.token: String? = nil
+
+    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
+        AriesApi.delegate = self
+        return true
+    }
+
+    func onFailure(err: NSError) -> NSError {
+        debugPrintln(err)
+        return err
+    }
+
+    func onSuccess(response: AnyObject) -> AnyObject {
+        debugPrintln(response)
+        return response
+    }
+
+    func beforeRequest(request: NSMutableURLRequest) -> NSMutableURLRequest {
+        debugPrintln(request)
+        request.setValue("Bearer \(self.token)", forHTTPHeaderField: "Authorization")
+        return request
+    }
+
+}
+
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/aries/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/aries.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'aries/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aries"
+  spec.version       = Aries::VERSION
+  spec.authors       = ["yss44"]
+  spec.email         = ["nya060@gmail.com"]
+
+  spec.summary       = %q{Aries is a iOS(Swift), Android(java,not yet) API Client generator represented with JSON Schema}
+  spec.description   = %q{Aries is a iOS(Swift), Andorid(not yet, but future) HTTP client generator for APIs represented with JSON Schema}
+  spec.homepage      = "https://github.com/yss44/aries"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "addressable"
+  spec.add_dependency "thor"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "json_schema"
+  spec.add_dependency "erubis"
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rack-json_schema"
+end

data/bin/aries

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "aries"
+
+
+Aries::Cli.start(ARGV)

data/examples/clients/RackJsonSchemaApi.swift

@@ -0,0 +1,277 @@
+//
+//  RackJsonSchemaApi.swift
+//
+//  Auto generated by Aries on 2015/04/11.
+//  Do not modify this file directory
+//
+
+import Alamofire
+import SwiftTask
+import URITemplate
+
+typealias RackJsonSchemaApiResponse = Task<Int,AnyObject,NSError>
+
+protocol RackJsonSchemaApiDelegate {
+    func customReqeust(request: NSMutableURLRequest) -> NSMutableURLRequest
+    func onDefaultSuccess(response: AnyObject) -> AnyObject
+    func onDefaultFailure(err: NSError) -> NSError
+}
+
+class RackJsonSchemaApi {
+
+    private struct BaseUrlStringStruct{ static var url = "http://localhost:5000" }
+    class var BaseUrlString: String {
+        get{ return BaseUrlStringStruct.url }
+        set{ BaseUrlStringStruct.url = newValue }
+    }
+
+    // workaround tips
+    // After updated swift 1.2, use ( static var someVariable: Int = 0 ) instead
+    private struct delegateStruct{ static var detegator: RackJsonSchemaApiDelegate? }
+    class var delegate: RackJsonSchemaApiDelegate? {
+        get{ return delegateStruct.detegator }
+        set{ delegateStruct.detegator = newValue }
+    }
+
+    private class func defaultURLRequest(let path: String, let method: Alamofire.Method) -> NSMutableURLRequest {
+        let URL = NSURL(string: RackJsonSchemaApi.BaseUrlString)!
+        let mutableURLRequest = NSMutableURLRequest(URL: URL.URLByAppendingPathComponent(path))
+
+        mutableURLRequest.HTTPMethod = method.rawValue
+        mutableURLRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        mutableURLRequest.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        if let delegate = self.delegate?{
+            return delegate.customReqeust(mutableURLRequest)
+        }
+
+        return mutableURLRequest
+    }
+
+    private class func generateURI(template: String, params: [String: AnyObject]?) -> String {
+        if let params = params {
+            return URITemplate(template: template).expand(params)
+        }
+        return template
+    }
+
+    class Base {
+
+        private class func request(URLRequest: URLRequestConvertible) -> RackJsonSchemaApiResponse {
+            return RackJsonSchemaApiResponse {(progress, fulfill, reject, configure) in
+                let alam = Alamofire.request(URLRequest)
+                                    .validate()
+                                    .responseJSON({ (req, res, data, err) -> Void in
+
+                    if let err = err {
+                        reject(self.buildErr(res, data: data, err: err))
+                        return
+                    }
+                    fulfill(data!)
+                })
+                debugPrintln(alam)
+                configure.pause  = { [weak alam] in if let alam = alam { alam.suspend() } }
+                configure.resume = { [weak alam] in if let alam = alam { alam.resume() }  }
+                configure.cancel = { [weak alam] in if let alam = alam { alam.cancel() }  }
+            }.then({ (data, errorInfo) -> RackJsonSchemaApiResponse in
+                return RackJsonSchemaApiResponse { (progress, fulfill, reject, configure) in
+                    if(errorInfo == nil){
+                        if let delegate = RackJsonSchemaApi.delegate {
+                            let newData: AnyObject = delegate.onDefaultSuccess(data!)
+                            fulfill(newData)
+                            return
+                        }
+                        fulfill(data!)
+                        return
+                    }else{
+                        let (err, isCancelled) = errorInfo!
+                        if let err = err {
+                            if let delegate = RackJsonSchemaApi.delegate{
+                                let newErr = delegate.onDefaultFailure(err)
+                                reject(newErr)
+                                return
+                            }
+                            reject(err)
+                            return
+                        }
+                    }
+                }
+
+            })
+        }
+
+        private class func buildErr(res: NSHTTPURLResponse?, data: AnyObject?, err: NSError?) -> NSError {
+            var userInfo = [String: AnyObject]()
+            if let res = res {
+                userInfo["statusCode"] = res.statusCode
+            }else{
+                userInfo["statusCode"] = 502
+            }
+            if let data: AnyObject = data {
+                userInfo["response"] = data
+            }
+            if let err = err {
+                userInfo["originalError"] = err
+            }
+            var error = NSError(domain: "com.aries.error", code: -1, userInfo: userInfo)
+            return error
+        }
+
+    }
+
+
+      class App: Base {
+
+
+          class func Create(name: String? = nil) -> RackJsonSchemaApiResponse {
+              var params = [String: AnyObject]()
+
+
+              if let name = name {
+                params["name"] = name
+              }
+
+            return request(Router.Create(params))
+          }
+
+
+          class func Delete(appId: String) -> RackJsonSchemaApiResponse {
+              var params = [String: AnyObject]()
+
+                params["appId"] = appId
+
+
+            return request(Router.Delete(params))
+          }
+
+
+          class func Info(appId: String) -> RackJsonSchemaApiResponse {
+              var params = [String: AnyObject]()
+
+                params["appId"] = appId
+
+
+            return request(Router.Info(params))
+          }
+
+
+          class func Info(appId: String) -> RackJsonSchemaApiResponse {
+              var params = [String: AnyObject]()
+
+                params["appId"] = appId
+
+
+            return request(Router.Info(params))
+          }
+
+
+          class func List() -> RackJsonSchemaApiResponse {
+              var params: [String: AnyObject]? = nil
+
+
+
+            return request(Router.List(params))
+          }
+
+
+          class func Update(appId: String, name: String? = nil) -> RackJsonSchemaApiResponse {
+              var params = [String: AnyObject]()
+
+                params["appId"] = appId
+
+              if let name = name {
+                params["name"] = name
+              }
+
+            return request(Router.Update(params))
+          }
+
+
+          class func Create(appId: String, file: String? = nil) -> RackJsonSchemaApiResponse {
+              var params = [String: AnyObject]()
+
+                params["appId"] = appId
+
+              if let file = file {
+                params["file"] = file
+              }
+
+            return request(Router.Create(params))
+          }
+
+
+        private enum Router: URLRequestConvertible {
+
+              case Create([String: AnyObject]?)
+              case Delete([String: AnyObject]?)
+              case Info([String: AnyObject]?)
+              case Info([String: AnyObject]?)
+              case List([String: AnyObject]?)
+              case Update([String: AnyObject]?)
+              case Create([String: AnyObject]?)
+            var method: Alamofire.Method {
+                switch self {
+                  case .Create:
+                    return .POST
+                  case .Delete:
+                    return .DELETE
+                  case .Info:
+                    return .GET
+                  case .Info:
+                    return .GET
+                  case .List:
+                    return .GET
+                  case .Update:
+                    return .PATCH
+                  case .Create:
+                    return .POST
+                }
+            }
+
+            var path: String {
+                switch self {
+                case .Create(let params):
+                  return RackJsonSchemaApi.generateURI("/apps", params: params)
+                case .Delete(let params):
+                  return RackJsonSchemaApi.generateURI("/apps/{appId}", params: params)
+                case .Info(let params):
+                  return RackJsonSchemaApi.generateURI("/apps/{appId}", params: params)
+                case .Info(let params):
+                  return RackJsonSchemaApi.generateURI("/apps/{appId}/text", params: params)
+                case .List(let params):
+                  return RackJsonSchemaApi.generateURI("/apps", params: params)
+                case .Update(let params):
+                  return RackJsonSchemaApi.generateURI("/apps/{appId}", params: params)
+                case .Create(let params):
+                  return RackJsonSchemaApi.generateURI("/apps/{appId}/files", params: params)
+                }
+            }
+
+            // MARK: URLRequestConvertible
+
+            var URLRequest: NSURLRequest {
+              switch self{
+              case .Create(let parameters):
+                return Alamofire.ParameterEncoding.JSON.encode(RackJsonSchemaApi.defaultURLRequest(path, method: method), parameters: parameters).0
+              case .Delete(let parameters):
+                return Alamofire.ParameterEncoding.JSON.encode(RackJsonSchemaApi.defaultURLRequest(path, method: method), parameters: parameters).0
+              case .Info(let parameters):
+                return Alamofire.ParameterEncoding.URL.encode(RackJsonSchemaApi.defaultURLRequest(path, method: method), parameters: parameters).0
+              case .Info(let parameters):
+                return Alamofire.ParameterEncoding.URL.encode(RackJsonSchemaApi.defaultURLRequest(path, method: method), parameters: parameters).0
+              case .List(let parameters):
+                return Alamofire.ParameterEncoding.URL.encode(RackJsonSchemaApi.defaultURLRequest(path, method: method), parameters: parameters).0
+              case .Update(let parameters):
+                return Alamofire.ParameterEncoding.JSON.encode(RackJsonSchemaApi.defaultURLRequest(path, method: method), parameters: parameters).0
+              case .Create(let parameters):
+                return Alamofire.ParameterEncoding.JSON.encode(RackJsonSchemaApi.defaultURLRequest(path, method: method), parameters: parameters).0
+              }
+            }
+
+        }
+
+
+      }
+
+
+}