authlete 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9eebbe1dbd1b81cb3acccd34c5d443477d83261
-  data.tar.gz: 8934d99069e18a80605e8568b443d0f6d97e08cc
+  metadata.gz: e7654558117fbc2aa82e0b85086b663f709d162b
+  data.tar.gz: 756edef67e1137db22548eafa97d4a5226faa822
 SHA512:
-  metadata.gz: 0e8c4d385bbfa81dc02b920e35666203547af745a7fb087369b68afb7af464b5d5923b421a2ef9216834017e256e986476e5c8bd93528a6314ac46cbb51ac1b0
-  data.tar.gz: f17bbab7957bad25c342be5cf2d71c58085a53449df19e3c67f688a7e89dec21258fb3a21444d8853fe08e3bdb47947f5e08fc5ebcf4362246a2e37e1848749b
+  metadata.gz: a782c1b18f97515e1e3afab5688dd55b78a10f2524144b60fa249f0d8a425352abea6207d6e83c177e57a372fa945bb2d64455368c4bcea067d428ce67a349ea
+  data.tar.gz: a2b5b0dc9ab9477d95011c29d39eaab24fcc178315123c710b643ab19d3e2f9f6a2ade526814afc35c77731409f2990dbbe2295b4eb56c96a115071781e8cde8

data/lib/authlete.rb

@@ -24,15 +24,18 @@ require 'authlete/version'
 #
 module Authlete
   autoload :AuthenticationServer, 'authlete/authentication-server'
-  autoload :Client, 'authlete/client'
+  autoload :Api, 'authlete/api'
   autoload :Host, 'authlete/host'
   autoload :Utility, 'authlete/utility'
 
   module Model
+    autoload :Client, 'authlete/model/client'
+    autoload :ClientList, 'authlete/model/client-list'
     autoload :Scope, 'authlete/model/scope'
     autoload :Service, 'authlete/model/service'
     autoload :ServiceList, 'authlete/model/service-list'
     autoload :SnsCredentials, 'authlete/model/sns-credentials'
+    autoload :TaggedValue, 'authlete/model/tagged-value'
   end
 
   module Request

data/lib/authlete/{client.rb → api.rb}

@@ -21,11 +21,11 @@ require 'rest-client'
 
 
 module Authlete
-  # == Authlete::Client Module
+  # == Authlete::Api Module
   #
   # A web client that accesses Authlete Web APIs.
   #
-  class Client
+  class Api
     include Authlete::Utility
 
     # The host which provides Authlete Web APIs.
@@ -113,6 +113,10 @@ module Authlete
       call_api(method, path, content_type, payload, @service_owner_api_key, @service_owner_api_secret)
     end
 
+    def call_api_service(method, path, content_type, payload)
+      call_api(method, path, content_type, payload, @service_api_key, @service_api_secret)
+    end
+
     def call_api_json(path, body, user, password)
       call_api(:post, path, 'application/json;charset=UTF-8', JSON.generate(body), user, password)
     end
@@ -159,7 +163,6 @@ module Authlete
 
     public
 
-
     # Call Authlete's /api/service/create API.
     #
     # <tt>service</tt> is the content of a new service to create. The type of
@@ -241,6 +244,78 @@ module Authlete
       Authlete::Model::Service.new(hash)
     end
 
+    # Call Authlete's /api/client/create API.
+    #
+    # <tt>client</tt> is the content of a new service to create. The type of
+    # the given object is either <tt>Hash</tt> or any object which
+    # responds to <tt>to_hash</tt>. In normal cases, Authlete::Model::Client
+    # (which responds to <tt>to_hash</tt>) should be used.
+    #
+    # On success, an instance of Authlete::Model::ClientList is returned.
+    # On error, RestClient::Exception (of rest-client GEM) is raised.
+    def client_create(client)
+      if client.kind_of?(Hash) == false
+        if client.respond_to?('to_hash')
+          client = client.to_hash
+        end
+      end
+
+      hash = call_api_json_service("/api/client/create", client)
+
+      Authlete::Model::Client.new(hash)
+    end
+
+    # Call Authlete's /api/client/delete/{clientId} API.
+    #
+    # On error, RestClient::Exception (of rest-client GEM) is raised.
+    def client_delete(clientId)
+      call_api_service(:delete, "/api/client/delete/#{clientId}", nil, nil)
+    end
+
+    # Call Authlete's /api/client/get/{clientId} API.
+    #
+    # On success, an instance of Authlete::Model::Service is returned.
+    # On error, RestClient::Exception (of rest-client GEM) is raised.
+    def client_get(clientId)
+      hash = call_api_service(:get, "/api/client/get/#{clientId}", nil, nil)
+
+      Authlete::Model::Client.new(hash)
+    end
+
+    # Call Authlete's /api/client/get/list API.
+    #
+    # <tt>params</tt> is an optional hash which contains query parameters
+    # for /api/client/get/list API. <tt>:start</tt> and <tt>:end</tt> are
+    # a start index (inclusive) and an end index (exclusive), respectively.
+    #
+    # On success, an instance of Authlete::Model::ClientList is returned.
+    # On error, RestClient::Exception (of rest-client GEM) is raised.
+    def client_get_list(params = nil)
+      hash = call_api_service(:get, "/api/client/get/list#{to_query(params)}", nil, nil)
+
+      Authlete::Model::ClientList.new(hash)
+    end
+
+    # Call Authlete's /api/client/update/{clientId} API.
+    #
+    # <tt>client</tt> is the new content of the client. The type of
+    # the given object is either <tt>Hash</tt> or any object which
+    # responds to <tt>to_hash</tt>. In normal cases, Authlete::Model::Client
+    # (which responds to <tt>to_hash</tt>) should be used.
+    #
+    # On success, an instance of Authlete::Model::Client is returned.
+    # On error, RestClient::Exception (of rest-client GEM) is raised.
+    def client_update(client)
+      if client.kind_of?(Hash) == false
+        if client.respond_to?('to_hash')
+          client = client.to_hash
+        end
+      end
+
+      hash = call_api_json_service("/api/client/update/#{client[:clientId]}", client)
+
+      Authlete::Model::Client.new(hash)
+    end
 
     # Call Authlete's {/auth/introspection}
     # [https://www.authlete.com/authlete_web_apis_introspection.html#auth_introspection]

data/lib/authlete/model/client-list.rb

@@ -0,0 +1,181 @@
+# :nodoc:
+#
+# Copyright (C) 2015 Authlete, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'set'
+
+
+module Authlete
+  module Model
+    class ClientList
+      # The start index (inclusive) of the clients in this list.
+      attr_accessor :start
+
+      # The end index (exclusive) of the clients in this list.
+      attr_accessor :end
+
+      # The total count of clients.
+      attr_accessor :totalCount
+      alias_method  :total_count,  :totalCount
+      alias_method  :total_count=, :totalCount=
+
+      # The list of clients.
+      attr_accessor :clients
+
+      private
+
+      # Integer attributes.
+      INTEGER_ATTRIBUTES = ::Set.new([:start, :end, :totalCount])
+
+      # Mapping from snake cases to camel cases.
+      SNAKE_TO_CAMEL = { :total_count => :totalCount }
+
+      # The constructor
+      def initialize(hash = nil)
+        # Set default values to integer attributes.
+        INTEGER_ATTRIBUTES.each do |attr|
+          send("#{attr}=", 0)
+        end
+
+        @clients = nil
+
+        # Set attribute values using the given hash.
+        authlete_model_clientList_update(hash)
+      end
+
+      def authlete_model_clientList_to_key(key)
+        key = key.to_sym
+
+        # Convert snakecase to camelcase, if necessary.
+        if SNAKE_TO_CAMEL.has_key?(key)
+          key = SNAKE_TO_CAMEL[key]
+        end
+
+        return key
+      end
+
+      def authlete_model_clientList_simple_attribute?(key)
+        INTEGER_ATTRIBUTES.include?(key)
+      end
+
+      def authlete_model_clientList_update(hash)
+        if hash.nil?
+          return
+        end
+
+        hash.each do |key, value|
+          key = authlete_model_clientList_to_key(key)
+
+          # If the attribute is a simple one.
+          if authlete_model_clientList_simple_attribute?(key)
+            send("#{key}=", value)
+            next
+          end
+
+          if key == :clients
+            # The attribute 'clients'.
+            @clients = authlete_model_clientList_parse_array(value) do |element|
+              Authlete::Model::Client.parse(element)
+            end
+          end
+        end
+
+        return self
+      end
+
+      def authlete_model_clientList_parse_array(array)
+        if array.nil? or (array.kind_of?(Array) == false) or (array.length == 0)
+          return nil
+        end
+
+        elements = []
+
+        array.each do |element|
+          parsed_element = yield(element)
+
+          if parsed_element.nil? == false
+            elements.push(parsed_element)
+          end
+        end
+
+        if elements.length == 0
+          return nil
+        end
+
+        return elements
+      end
+
+      public
+
+      # Construct an instance from the given hash.
+      #
+      # If the given argument is nil or is not a Hash, nil is returned.
+      # Otherwise, ClientList.new(hash) is returned.
+      def self.parse(hash)
+        if hash.nil? or (hash.kind_of?(Hash) == false)
+          return nil
+        end
+
+        return ClientList.new(hash)
+      end
+
+      # Set attribute values using the given hash.
+      def update(hash)
+        authlete_model_clientList_update(hash)
+      end
+
+      # Convert this object into a hash.
+      def to_hash
+        hash = {}
+
+        instance_variables.each do |var|
+          key = var.to_s.delete("@").to_sym
+          val = instance_variable_get(var)
+
+          if authlete_model_clientList_simple_attribute?(key) or val.nil?
+            hash[key] = val
+          elsif val.kind_of?(Array)
+            hash[key] = val.map {|element| element.to_hash}
+          end
+        end
+
+        return hash
+      end
+
+      def [](key)
+        key = authlete_model_clientList_to_key(key)
+
+        if respond_to?(key)
+          return send(key)
+        else
+          return nil
+        end
+      end
+
+      def []=(key, value)
+        key = authlete_model_clientList_to_key(key)
+        method = "#{key}="
+
+        if respond_to?(method)
+          return send(method, value)
+        else
+          return nil
+        end
+      end
+    end
+  end
+end
+

data/lib/authlete/model/client.rb

@@ -0,0 +1,492 @@
+# :nodoc:
+#
+# Copyright (C) 2015 Authlete, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'set'
+
+
+module Authlete
+  module Model
+    class Client
+      # The sequential number of the client application. (Integer)
+      attr_accessor :number
+
+      # The sequential number of the service of the client application.
+      # (Integer)
+      attr_accessor :serviceNumber
+      alias_method  :service_number,  :serviceNumber
+      alias_method  :service_number=, :serviceNumber=
+
+      # The developer of the client application. (String)
+      attr_accessor :developer
+
+      # The client ID. (Integer)
+      attr_accessor :clientId
+      alias_method  :client_id, :clientId
+      alias_method  :client_id=, :clientId=
+
+      # The client secret. (String)
+      attr_accessor :clientSecret
+      alias_method  :client_secret, :clientSecret
+      alias_method  :client_secret=, :clientSecret=
+
+      # The client type. (String)
+      attr_accessor :clientType
+      alias_method  :client_type,  :clientType
+      alias_method  :client_type=, :clientType=
+
+      # Redirect URIs that the client application uses to receive a response
+      # from the authorization endpoint. (URI array)
+      attr_accessor :redirectUris
+      alias_method  :redirect_uris,  :redirectUris
+      alias_method  :redirect_uris=, :redirectUris=
+
+      # A string array of response types which the client application declares
+      # that it will restrict itself to using (String array)
+      attr_accessor :responseTypes
+      alias_method  :response_types,  :responseTypes
+      alias_method  :response_types=, :responseTypes=
+
+      # A string array of grant types which the client application declares
+      # that it will restrict itself to using. (String array)
+      attr_accessor :grantTypes
+      alias_method  :grant_types,  :grantTypes
+      alias_method  :grant_types=, :grantTypes=
+
+      # The application type. (String)
+      attr_accessor :applicationType
+      alias_method  :application_type,  :applicationType
+      alias_method  :application_type=, :applicationType=
+
+      # An array of email addresses of people responsible for the client application.
+      # (String array)
+      attr_accessor :contacts
+
+      # The name of the client application. (String)
+      attr_accessor :clientName
+      alias_method  :client_name,  :clientName
+      alias_method  :client_name=, :clientName=
+
+      # Client names with language tags. (TaggedValue array)
+      attr_accessor :clientNames
+      alias_method  :client_names,  :clientNames
+      alias_method  :client_names=, :clientNames=
+
+      # The URL pointing to the logo image of the client application. (URI)
+      attr_accessor :logoUri
+      alias_method  :logo_uri,  :logoUri
+      alias_method  :logo_uri=, :logoUri=
+
+      # Logo image URLs with language tags. (TaggedValue array)
+      attr_accessor :logoUris
+      alias_method  :logo_uris,  :logoUris
+      alias_method  :logo_uris=, :logoUris=
+
+      # The URL pointing to the home page of the client application. (URI)
+      attr_accessor :clientUri
+      alias_method  :client_uri,  :clientUri
+      alias_method  :client_uri=, :clientUri=
+
+      # Home page URLs with language tags. (TaggedValue array)
+      attr_accessor :clientUris
+      alias_method  :client_uris,  :clientUris
+      alias_method  :client_uris=, :clientUris=
+
+      # The URL pointing to the page which describes the policy
+      # as to how end-users' profile data are used. (URI)
+      attr_accessor :policyUri
+      alias_method  :policy_uri,  :policyUri
+      alias_method  :policy_uri=, :policyUri=
+
+      # URLs of policy pages with language tags. (TaggedValue array)
+      attr_accessor :policyUris
+      alias_method  :policy_uris,  :policyUris
+      alias_method  :policy_uris=, :policyUris=
+
+      # The URL pointing to the "Terms Of Service" page. (URI)
+      attr_accessor :tosUri
+      alias_method  :tos_uri,  :tosUri
+      alias_method  :tos_uri=, :tosUri=
+
+      # URLs of "Terms Of Service" pages with language tags.
+      # (TaggedValue array)
+      attr_accessor :tosUris
+      alias_method  :tos_uris,  :tosUris
+      alias_method  :tos_uris=, :tosUris=
+
+      # The URL pointing to the JWK Set of the client application. (URI)
+      attr_accessor :jwksUri
+      alias_method  :jwks_uri,  :jwksUri
+      alias_method  :jwks_uri=, :jwksUri=
+
+      # The content of the JWK Set of the client application. (String)
+      attr_accessor :jwks
+
+      # The sector identifier which is a URL starting with https. (URI)
+      attr_accessor :sectorIdentifier
+      alias_method  :sector_identifier,  :sectorIdentifier
+      alias_method  :sector_identifier=, :sectorIdentifier=
+
+      # The subject type that the client application requests. (URI)
+      attr_accessor :subjectType
+      alias_method  :subject_type,  :subjectType
+      alias_method  :subject_type=, :subjectType=
+
+      # The value of alg header parameter of JWS that the client application
+      # requires the service to use for signing an ID token. (String)
+      attr_accessor :idTokenSignAlg
+      alias_method  :id_token_sign_alg,  :idTokenSignAlg
+      alias_method  :id_token_sign_alg=, :idTokenSignAlg=
+
+      # The value of alg header parameter of JWE that the client application
+      # requires the service to use for encrypting an ID token. (String)
+      attr_accessor :idTokenEncryptionAlg
+      alias_method  :id_token_encryption_alg,  :idTokenEncryptionAlg
+      alias_method  :id_token_encryption_alg=, :idTokenEncryptionAlg=
+
+      # The value of enc header parameter of JWE that the client application
+      # requires the service to use for encrypting an ID token. (String)
+      attr_accessor :idTokenEncryptionEnc
+      alias_method  :id_token_encryption_enc,  :idTokenEncryptionEnc
+      alias_method  :id_token_encryption_enc=, :idTokenEncryptionEnc=
+
+      # The value of alg header parameter of JWS that the client application
+      # requires the service to use for signing the JWT returned from the user
+      # info endpoint. One of the values listed in JWS Algorithm. (String)
+      attr_accessor :userInfoSignAlg
+      alias_method  :user_info_sign_alg,  :userInfoSignAlg
+      alias_method  :user_info_sign_alg=, :userInfoSignAlg=
+
+      # The value of alg header parameter of JWE that the client application
+      # requires the service to use for encrypting the JWT returned from
+      # the user info endpoint. (String)
+      attr_accessor :userInfoEncryptionAlg
+      alias_method  :user_info_encryption_alg,  :userInfoEncryptionAlg
+      alias_method  :user_info_encryption_alg=, :userInfoEncryptionAlg=
+
+      # The value of enc header parameter of JWE that the client application
+      # requires the service to use for encrypting the JWT returned from
+      # the user info endpoint. (String)
+      attr_accessor :userInfoEncryptionEnc
+      alias_method  :user_info_encryption_enc,  :userInfoEncryptionEnc
+      alias_method  :user_info_encryption_enc=, :userInfoEncryptionEnc=
+
+      # The value of alg header parameter of JWS that the client application
+      # uses for signing a request object. (String)
+      attr_accessor :requestSignAlg
+      alias_method  :request_sign_alg,  :requestSignAlg
+      alias_method  :request_sign_alg=, :requestSignAlg=
+
+      # The value of alg header parameter of JWE that the client application
+      # uses for encrypting a request object. (String)
+      attr_accessor :requestEncryptionAlg
+      alias_method  :request_encryption_alg,  :requestEncryptionAlg
+      alias_method  :request_encryption_alg=, :requestEncryptionAlg=
+
+      # The value of enc header parameter of JWE that the client application
+      # uses for encrypting a request object. (String)
+      attr_accessor :requestEncryptionEnc
+      alias_method  :request_encryption_enc,  :requestEncryptionEnc
+      alias_method  :request_encryption_enc=, :requestEncryptionEnc=
+
+      # The client authentication method that the client application
+      # declares that it uses at the token endpoint. (String)
+      attr_accessor :tokenAuthMethod
+      alias_method  :token_auth_method,  :tokenAuthMethod
+      alias_method  :token_auth_method=, :tokenAuthMethod=
+
+      # The value of alg header parameter of JWS which is used
+      # for client authentication at the token endpoint. (String)
+      attr_accessor :tokenAuthSignAlg
+      alias_method  :token_auth_sign_alg,  :tokenAuthSignAlg
+      alias_method  :token_auth_sign_alg=, :tokenAuthSignAlg=
+
+      # The default maximum authentication age in seconds. (Integer)
+      attr_accessor :defaultMaxAge
+      alias_method  :default_max_age,  :defaultMaxAge
+      alias_method  :default_max_age=, :defaultMaxAge=
+
+      # The default ACRs (Authentication Context Class References). (String array)
+      attr_accessor :defaultAcrs
+      alias_method  :default_acrs,  :defaultAcrs
+      alias_method  :default_acrs=, :defaultAcrs=
+
+      # The flag showing the client application requires the auth_time claim
+      # to be in an ID token. (Boolean)
+      attr_accessor :authTimeRequired
+      alias_method  :auth_time_required,  :authTimeRequired
+      alias_method  :auth_time_required=, :authTimeRequired=
+
+      # The URL which a third party can use to initiate a login by the client
+      # application. (URI)
+      attr_accessor :loginUri
+      alias_method  :login_uri,  :loginUri
+      alias_method  :login_uri=, :loginUri=
+
+      # An array of URLs each of which points to a request object.
+      # (URI array)
+      attr_accessor :requestUris
+      alias_method  :request_uris,  :requestUris
+      alias_method  :request_uris=, :requestUris=
+
+      # The description about the client application. At most 200 letters in unicode.
+      # (String)
+      attr_accessor :description
+
+      # Descriptions about the client application with language tags. (TaggesValue array)
+      attr_accessor :descriptions
+
+      # The timestamp at which the client was created. (Integer)
+      attr_accessor :createdAt
+      alias_method  :created_at, :createdAt
+      alias_method  :created_at=, :createdAt=
+
+      # The timestamp at which the client was modified. (Integer)
+      attr_accessor :modifiedAt
+      alias_method  :modified_at, :modifiedAt
+      alias_method  :modified_at=, :modifiedAt=
+
+      private
+
+      # Integer attributes.
+      INTEGER_ATTRIBUTES = ::Set.new([
+        :number, :serviceNumber, :clientId, :defaultMaxAge, :createdAt, :modifiedAt
+      ])
+
+      # Boolean attributes.
+      BOOLEAN_ATTRIBUTES = ::Set.new([ :authTimeRequired ])
+
+      # String attributes.
+      STRING_ATTRIBUTES = ::Set.new([
+        :developer, :clientSecret, :clientType, :responseTypes, :applicationType,
+        :clientName, :logoUri, :clientUri, :policyUri, :tosUri, :jwksUri, :jwks,
+        :sectorIdentifier, :subjectType, :idTokenSignAlg, :idTokenEncryptionAlg,
+        :idTokenEncryptionEnc, :userInfoSignAlg, :userInfoEncryptionAlg, :userInfoEncryptionEnc,
+        :requestSignAlg, :requestEncryptionAlg, :requestEncryptionEnc, :tokenAuthMethod,
+        :tokenAuthSignAlg, :loginUri, :description
+      ])
+
+      # String array attributes.
+      STRING_ARRAY_ATTRIBUTES = ::Set.new([
+        :redirectUris, :responseTypes, :grantTypes, :contacts, :defaultAcrs, :requestUris
+      ])
+
+      # Tagged value array atributes.
+      TAGGED_VALUE_ARRAY_ATTRIBUTES = ::Set.new([
+        :clientNames, :logoUris, :clientUris, :policyUris, :tosUris, :descriptions
+      ])
+
+      # Mapping from snake cases to camel cases.
+      SNAKE_TO_CAMEL = {
+        :service_number           => :serviceNumber,
+        :client_id                => :clientId,
+        :client_secret            => :clientSecret,
+        :client_type              => :clientType,
+        :redirect_uris            => :redirectUris,
+        :response_types           => :responseTypes,
+        :grant_types              => :grantTypes,
+        :application_type         => :applicationType,
+        :client_name              => :clientName,
+        :client_names             => :clientNames,
+        :logo_uri                 => :logoUri,
+        :logo_uris                => :logoUris,
+        :client_uri               => :clientUri,
+        :client_uris              => :clientUris,
+        :policy_uri               => :policyUri,
+        :policy_uris              => :policyUris,
+        :tos_uri                  => :tosUri,
+        :tos_uris                 => :tosUris,
+        :jwks_uri                 => :jwksUri,
+        :sector_identifier        => :sectorIdentifier,
+        :subject_type             => :subjectType,
+        :id_token_sign_alg        => :idTokenSignAlg,
+        :id_token_encryption_alg  => :idTokenEncryptionAlg,
+        :id_token_encryption_enc  => :idTokenEncryptionEnc,
+        :user_info_sign_alg       => :userInfoSignAlg,
+        :user_info_encryption_alg => :userInfoEncryptionAlg,
+        :user_info_encryption_enc => :userInfoEncryptionEnc,
+        :request_sign_alg         => :requestSignAlg,
+        :request_encryption_alg   => :requestEncryptionAlg,
+        :request_encryption_enc   => :requestEncryptionEnc,
+        :token_auth_method        => :tokenAuthMethod,
+        :token_auth_sign_alg      => :tokenAuthSignAlg,
+        :default_max_age          => :defaultMaxAge,
+        :default_acrs             => :defaultAcrs,
+        :auth_time_required       => :authTimeRequired,
+        :login_uri                => :loginUri,
+        :request_uris             => :requestUris,
+        :created_at               => :createdAt,
+        :modified_at              => :modifiedAt
+      }
+
+      # The constructor
+      def initialize(hash = nil)
+        # Set default values to integer attributes.
+        INTEGER_ATTRIBUTES.each do |attr|
+          send("#{attr}=", 0)
+        end
+
+        # Set default values to boolean attributes.
+        BOOLEAN_ATTRIBUTES.each do |attr|
+          send("#{attr}=", false)
+        end
+
+        # Set default values to string attributes.
+        STRING_ATTRIBUTES.each do |attr|
+          send("#{attr}=", nil)
+        end
+
+        # Set default values to string array attributes.
+        STRING_ARRAY_ATTRIBUTES.each do |attr|
+          send("#{attr}=", nil)
+        end
+
+        # Set default values to tagged value array attributes.
+        TAGGED_VALUE_ARRAY_ATTRIBUTES.each do |attr|
+          send("#{attr}=", nil)
+        end
+
+        # Set attribute values using the given hash.
+        authlete_model_service_update(hash)
+      end
+
+      def authlete_model_service_to_key(key)
+        key = key.to_sym
+
+        # Convert snakecase to camelcase, if necessary.
+        if SNAKE_TO_CAMEL.has_key?(key)
+          key = SNAKE_TO_CAMEL[key]
+        end
+
+        return key
+      end
+
+      def authlete_model_client_simple_attribute?(key)
+        INTEGER_ATTRIBUTES.include?(key) or
+        BOOLEAN_ATTRIBUTES.include?(key) or
+        STRING_ATTRIBUTES.include?(key) or
+        STRING_ARRAY_ATTRIBUTES.include?(key)
+      end
+
+      def authlete_model_client_update(hash)
+        if hash.nil?
+          return
+        end
+
+        hash.each do |key, value|
+          key = authlete_model_client_to_key(key)
+
+          # If the attribute is a simple one.
+          if authlete_model_client_simple_attribute?(key)
+            send("#{key}=", value)
+            next
+          end
+
+          # If the attribute is an array of tagged values.
+          if TAGGED_VALUE_ARRAY_ATTRIBUTES.include?(key)
+            parsed = authlete_model_client_parse_array(value) do |element|
+              Authlete::Model::TaggedValue.parse(element)
+            end
+
+            send("#{key}=", parsed)
+          end
+        end
+
+        return self
+      end
+
+      def authlete_model_client_parse_array(array)
+        if array.nil? or (array.kind_of?(Array) == false) or (array.length == 0)
+          return nil
+        end
+
+        elements = []
+
+        array.each do |element|
+          parsed_element = yield(element)
+
+          if parsed_element.nil? == false
+            elements.push(parsed_element)
+          end
+        end
+
+        if elements.length == 0
+          return nil
+        end
+
+        return elements
+      end
+
+      public
+
+      # Construct an instance from the given hash.
+      #
+      # If the given argument is nil or is not a Hash, nil is returned.
+      # Otherwise, Service.new(hash) is returned.
+      def self.parse(hash)
+        if hash.nil? or (hash.kind_of?(Hash) == false)
+          return nil
+        end
+
+        return Client.new(hash)
+      end
+
+      # Set attribute values using the given hash.
+      def update(hash)
+        authlete_model_client_update(hash)
+      end
+
+      # Convert this object into a hash.
+      def to_hash
+        hash = {}
+
+        instance_variables.each do |var|
+          key = var.to_s.delete("@").to_sym
+          val = instance_variable_get(var)
+
+          if authlete_model_client_simple_attribute?(key) or val.nil?
+            hash[key] = val
+          elsif val.kind_of?(Array)
+            hash[key] = val.map {|element| element.to_hash}
+          end
+        end
+
+        return hash
+      end
+
+      def [](key)
+        key = authlete_model_client_to_key(key)
+
+        if respond_to?(key)
+          return send(key)
+        else
+          return nil
+        end
+      end
+
+      def []=(key, value)
+        key = authlete_model_client_to_key(key)
+        method = "#{key}="
+
+        if respond_to?(method)
+          return send(method, value)
+        else
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/authlete/model/tagged-value.rb

@@ -0,0 +1,135 @@
+# :nodoc:
+#
+# Copyright (C) 2015 Authlete, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'set'
+
+
+module Authlete
+  module Model
+    class TaggedValue
+      # The language tag part. (String)
+      attr_accessor :tag
+
+      # The value part. (String)
+      attr_accessor :value
+
+
+      private
+
+      # String attributes.
+      STRING_ATTRIBUTES = ::Set.new([:tag, :value])
+
+      # The constructor
+      def initialize(hash = new)
+        # Set default values to string attributes.
+        STRING_ATTRIBUTES.each do |attr|
+          send("#{attr}=", nil)
+        end
+
+        # Set attribute values using the given hash.
+        authlete_model_taggedValue_update(hash)
+      end
+
+      def authlete_model_taggedValue_to_key(key)
+        key = key.to_sym
+
+        # Convert snakecase to camelcase, if necessary.
+        if SNAKE_TO_CAMEL.has_key?(key)
+          key = SNAKE_TO_CAMEL[key]
+        end
+
+        return key
+      end
+
+      def authlete_model_taggedValue_simple_attribute?(key)
+        STRING_ATTRIBUTES.include?(key)
+      end
+
+      def authlete_model_taggedValue_update(hash)
+        if hash.nil?
+          return
+        end
+
+        hash.each do |key, value|
+          key = authlete_model_taggedValue_to_key(key)
+
+          # If the attribute is a simple one.
+          if authlete_model_taggedValue_simple_attribute?(key)
+            send("#{key}=", value)
+            next
+          end
+        end
+
+        return self
+      end
+
+      public
+
+      # Construct an instance from the given hash.
+      #
+      # If the given argument is nil or is not a Hash, nil is returned.
+      # Otherwise, TaggedValue.new(hash) is returned.
+      def self.parse(hash)
+        if hash.nil? or (hash.kind_of?(Hash) == false)
+          return nil
+        end
+
+        return Authlete::Model::TaggedValue.new(hash)
+      end
+
+      # Set attribute values using the given hash.
+      def update(hash)
+        authlete_model_taggedValue_update(hash)
+      end
+
+      # Convert this object into a hash.
+      def to_hash
+        hash = {}
+
+        instance_variables.each do |var|
+          key = var.to_s.delete("@").to_sym
+          val = instance_variable_get(var)
+
+          hash[key] = val
+        end
+
+        return hash
+      end
+
+      def [](key)
+        key = authlete_model_taggedValue_to_key(key)
+
+        if respond_to?(key)
+          return send(key)
+        else
+          return nil
+        end
+      end
+
+      def []=(key, value)
+        key = authlete_model_taggedValue_to_key(key)
+        method = "#{key}="
+
+        if respond_to?(method)
+          return send(method, value)
+        else
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/authlete/version.rb

@@ -1,3 +1,3 @@
 module Authlete
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: authlete
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Takahiko Kawasaki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-07 00:00:00.000000000 Z
+date: 2015-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -67,13 +67,16 @@ files:
 - Rakefile
 - authlete.gemspec
 - lib/authlete.rb
+- lib/authlete/api.rb
 - lib/authlete/authentication-server.rb
-- lib/authlete/client.rb
 - lib/authlete/host.rb
+- lib/authlete/model/client-list.rb
+- lib/authlete/model/client.rb
 - lib/authlete/model/scope.rb
 - lib/authlete/model/service-list.rb
 - lib/authlete/model/service.rb
 - lib/authlete/model/sns-credentials.rb
+- lib/authlete/model/tagged-value.rb
 - lib/authlete/request/authentication-callback-request.rb
 - lib/authlete/response/authentication-callback-response.rb
 - lib/authlete/response/base-response.rb