apipie-rails 0.0.12 → 0.0.13

data/lib/apipie/client/base.rb

@@ -3,129 +3,131 @@ require 'oauth'
 require 'json'
 require 'apipie/client/rest_client_oauth'
 
-module Apipie::Client
-
-  class Base
-    attr_reader :client, :config
-
-    def initialize(config, options = { })
-      @client = RestClient::Resource.new config[:base_url],
-                                         :user     => config[:username],
-                                         :password => config[:password],
-                                         :oauth    => config[:oauth],
-                                         :headers  => { :content_type => 'application/json',
-                                                        :accept       => 'application/json' }
-      @config = config
-    end
+module Apipie
+  module Client
+
+    class Base
+      attr_reader :client, :config
+
+      def initialize(config, options = { })
+        @client = RestClient::Resource.new config[:base_url],
+                                           :user     => config[:username],
+                                           :password => config[:password],
+                                           :oauth    => config[:oauth],
+                                           :headers  => { :content_type => 'application/json',
+                                                          :accept       => 'application/json' }
+        @config = config
+      end
 
-    def call(method, path, params = { }, headers = { })
-      headers ||= { }
+      def call(method, path, params = { }, headers = { })
+        headers ||= { }
 
-      args = [method]
-      if [:post, :put].include?(method)
-        args << params.to_json
-      else
-        headers[:params] = params if params
-      end
+        args = [method]
+        if [:post, :put].include?(method)
+          args << params.to_json
+        else
+          headers[:params] = params if params
+        end
 
-      args << headers if headers
-      process_data client[path].send(*args)
-    end
+        args << headers if headers
+        process_data client[path].send(*args)
+      end
 
-    def self.doc
-      raise NotImplementedError
-    end
+      def self.doc
+        raise NotImplementedError
+      end
 
-    def self.validation_hash(method)
-      validation_hashes[method.to_s]
-    end
+      def self.validation_hash(method)
+        validation_hashes[method.to_s]
+      end
 
-    def self.method_doc(method)
-      method_docs[method.to_s]
-    end
+      def self.method_doc(method)
+        method_docs[method.to_s]
+      end
 
-    def validate_params!(params, rules)
-      return unless params.is_a?(Hash)
+      def validate_params!(params, rules)
+        return unless params.is_a?(Hash)
 
-      invalid_keys = params.keys.map(&:to_s) - (rules.is_a?(Hash) ? rules.keys : rules)
-      raise ArgumentError, "Invalid keys: #{invalid_keys.join(", ")}" unless invalid_keys.empty?
+        invalid_keys = params.keys.map(&:to_s) - (rules.is_a?(Hash) ? rules.keys : rules)
+        raise ArgumentError, "Invalid keys: #{invalid_keys.join(", ")}" unless invalid_keys.empty?
 
-      if rules.is_a? Hash
-        rules.each do |key, sub_keys|
-          validate_params!(params[key], sub_keys) if params[key]
+        if rules.is_a? Hash
+          rules.each do |key, sub_keys|
+            validate_params!(params[key], sub_keys) if params[key]
+          end
         end
       end
-    end
 
-    protected
+      protected
 
-    def process_data(response)
-      data = begin
-        JSON.parse(response.body)
-      rescue JSON::ParserError
-        response.body
+      def process_data(response)
+        data = begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          response.body
+        end
+        return data, response
       end
-      return data, response
-    end
-
-    def check_params(params, options = { })
-      raise ArgumentError unless (method = options[:method])
-      return unless config[:enable_validations]
 
-      case options[:allowed]
-        when true
-          validate_params!(params, self.class.validation_hash(method))
-        when false
-          raise ArgumentError, "this method '#{method}' does not support params" if params && !params.empty?
-        else
-          raise ArgumentError, "options :allowed should be true or false, it was #{options[:allowed]}"
+      def check_params(params, options = { })
+        raise ArgumentError unless (method = options[:method])
+        return unless config[:enable_validations]
+
+        case options[:allowed]
+          when true
+            validate_params!(params, self.class.validation_hash(method))
+          when false
+            raise ArgumentError, "this method '#{method}' does not support params" if params && !params.empty?
+          else
+            raise ArgumentError, "options :allowed should be true or false, it was #{options[:allowed]}"
+        end
       end
-    end
 
-    # @return url and rest of the params
-    def fill_params_in_url(url, params)
-      params          ||= { }
-      # insert param values
-      url_param_names = params_in_path(url)
-      url             = params_in_path(url).inject(url) do |url, param_name|
-        param_value = params[param_name] or
-            raise ArgumentError, "missing param '#{param_name}' in parameters"
-        url.sub(":#{param_name}", param_value.to_s)
-      end
+      # @return url and rest of the params
+      def fill_params_in_url(url, params)
+        params          ||= { }
+        # insert param values
+        url_param_names = params_in_path(url)
+        url             = params_in_path(url).inject(url) do |url, param_name|
+          param_value = params[param_name] or
+              raise ArgumentError, "missing param '#{param_name}' in parameters"
+          url.sub(":#{param_name}", param_value.to_s)
+        end
 
-      return url, params.reject { |param_name, _| url_param_names.include? param_name }
-    end
+        return url, params.reject { |param_name, _| url_param_names.include? param_name }
+      end
 
-    private
+      private
 
-    def self.method_docs
-      @method_docs ||= doc['methods'].inject({ }) do |hash, method|
-        hash[method['name']] = method
-        hash
+      def self.method_docs
+        @method_docs ||= doc['methods'].inject({ }) do |hash, method|
+          hash[method['name']] = method
+          hash
+        end
       end
-    end
 
-    def self.validation_hashes
-      @validation_hashes ||= method_docs.inject({ }) do |hash, pair|
-        name, method_doc = pair
-        hash[name]       = construct_validation_hash method_doc
-        hash
+      def self.validation_hashes
+        @validation_hashes ||= method_docs.inject({ }) do |hash, pair|
+          name, method_doc = pair
+          hash[name]       = construct_validation_hash method_doc
+          hash
+        end
       end
-    end
 
-    def self.construct_validation_hash(method)
-      if method['params'].any? { |p| p['params'] }
-        method['params'].reduce({ }) do |h, p|
-          h.update(p['name'] => (p['params'] ? p['params'].map { |pp| pp['name'] } : nil))
+      def self.construct_validation_hash(method)
+        if method['params'].any? { |p| p['params'] }
+          method['params'].reduce({ }) do |h, p|
+            h.update(p['name'] => (p['params'] ? p['params'].map { |pp| pp['name'] } : nil))
+          end
+        else
+          method['params'].map { |p| p['name'] }
         end
-      else
-        method['params'].map { |p| p['name'] }
       end
-    end
 
-    def params_in_path(url)
-      url.scan(/:([^\/]*)/).map { |m| m.first }
-    end
+      def params_in_path(url)
+        url.scan(/:([^\/]*)/).map { |m| m.first }
+      end
 
+    end
   end
 end

data/lib/apipie/client/cli_command.rb

@@ -1,127 +1,129 @@
-module Apipie::Client
-  class CliCommand < Thor
-    no_tasks do
-      def client
-        resource_class = apipie_options[:client_module]::Resources.const_get(self.class.name[/[^:]*$/])
-        @client        ||= resource_class.new(apipie_options[:config])
-      end
+module Apipie
+  module Client
+    class CliCommand < Thor
+      no_tasks do
+        def client
+          resource_class = apipie_options[:client_module]::Resources.const_get(self.class.name[/[^:]*$/])
+          @client        ||= resource_class.new(apipie_options[:config])
+        end
+
+        def transform_options(inline_params, transform_hash = { })
+          # we use not mentioned params without change
+          transformed_options = (options.keys - transform_hash.values.flatten - inline_params).reduce({ }) { |h, k| h.update(k => options[k]) }
 
-      def transform_options(inline_params, transform_hash = { })
-        # we use not mentioned params without change
-        transformed_options = (options.keys - transform_hash.values.flatten - inline_params).reduce({ }) { |h, k| h.update(k => options[k]) }
+          inline_params.each { |p| transformed_options[p] = options[p] }
 
-        inline_params.each { |p| transformed_options[p] = options[p] }
+          transform_hash.each do |sub_key, params|
+            transformed_options[sub_key] = { }
+            params.each { |p| transformed_options[sub_key][p] = options[p] if options.has_key?(p) }
+          end
 
-        transform_hash.each do |sub_key, params|
-          transformed_options[sub_key] = { }
-          params.each { |p| transformed_options[sub_key][p] = options[p] if options.has_key?(p) }
+          return transformed_options
         end
 
-        return transformed_options
-      end
+        def print_data(data)
+          case data
+            when Array
+              print_big_table(table_from_array(data))
+            when Hash
+              print_table(table_from_hash(data))
+            else
+              print_unknown(data)
+          end
+        end
 
-      def print_data(data)
-        case data
-          when Array
-            print_big_table(table_from_array(data))
-          when Hash
-            print_table(table_from_hash(data))
+        # unifies the data for further processing. e.g.
+        #
+        #     { "user" => {"username" => "test", "password" => "changeme" }
+        #
+        # becomes:
+        #
+        #     { "username" => "test", "password" => "changeme" }
+        def normalize_item_data(item)
+          if item.size == 1 && item.values.first.is_a?(Hash)
+            item.values.first
           else
-            print_unknown(data)
+            item
+          end
         end
-      end
 
-      # unifies the data for further processing. e.g.
-      #
-      #     { "user" => {"username" => "test", "password" => "changeme" }
-      #
-      # becomes:
-      #
-      #     { "username" => "test", "password" => "changeme" }
-      def normalize_item_data(item)
-        if item.size == 1 && item.values.first.is_a?(Hash)
-          item.values.first
-        else
-          item
+        def table_from_array(data)
+          return [] if data.empty?
+          table   = []
+          items   = data.map { |item| normalize_item_data(item) }
+          columns = items.first.keys
+          table << columns
+          items.each do |item|
+            row = columns.map { |c| item[c] }
+            table << row.map(&:to_s)
+          end
+          return table
         end
-      end
 
-      def table_from_array(data)
-        return [] if data.empty?
-        table   = []
-        items   = data.map { |item| normalize_item_data(item) }
-        columns = items.first.keys
-        table << columns
-        items.each do |item|
-          row = columns.map { |c| item[c] }
-          table << row.map(&:to_s)
+        def table_from_hash(data)
+          return [] if data.empty?
+          table = []
+          normalize_item_data(data).each do |k, v|
+            table << ["#{k}:", v].map(&:to_s)
+          end
+          table
         end
-        return table
-      end
 
-      def table_from_hash(data)
-        return [] if data.empty?
-        table = []
-        normalize_item_data(data).each do |k, v|
-          table << ["#{k}:", v].map(&:to_s)
+        def print_unknown(data)
+          say data
         end
-        table
-      end
 
-      def print_unknown(data)
-        say data
-      end
+        def print_big_table(table, options={ })
+          return if table.empty?
 
-      def print_big_table(table, options={ })
-        return if table.empty?
+          formats, ident, colwidth = [], options[:ident].to_i, options[:colwidth]
+          options[:truncate] = terminal_width if options[:truncate] == true
 
-        formats, ident, colwidth = [], options[:ident].to_i, options[:colwidth]
-        options[:truncate] = terminal_width if options[:truncate] == true
+          formats << "%-#{colwidth + 2}s" if colwidth
+          start = colwidth ? 1 : 0
 
-        formats << "%-#{colwidth + 2}s" if colwidth
-        start = colwidth ? 1 : 0
+          start.upto(table.first.length - 2) do |i|
+            maxima ||= table.max { |a, b| a[i].size <=> b[i].size }[i].size
+            formats << "%-#{maxima + 2}s"
+          end
 
-        start.upto(table.first.length - 2) do |i|
-          maxima ||= table.max { |a, b| a[i].size <=> b[i].size }[i].size
-          formats << "%-#{maxima + 2}s"
-        end
+          formats << "%s"
+          formats[0] = formats[0].insert(0, " " * ident)
 
-        formats << "%s"
-        formats[0] = formats[0].insert(0, " " * ident)
+          header_printed = false
+          table.each do |row|
+            sentence = ""
 
-        header_printed = false
-        table.each do |row|
-          sentence = ""
+            row.each_with_index do |column, i|
+              sentence << formats[i] % column.to_s
+            end
 
-          row.each_with_index do |column, i|
-            sentence << formats[i] % column.to_s
+            sentence = truncate(sentence, options[:truncate]) if options[:truncate]
+            $stdout.puts sentence
+            say(set_color("-" * sentence.size, :green)) unless header_printed
+            header_printed = true
           end
-
-          sentence = truncate(sentence, options[:truncate]) if options[:truncate]
-          $stdout.puts sentence
-          say(set_color("-" * sentence.size, :green)) unless header_printed
-          header_printed = true
         end
+
       end
 
-    end
+      class << self
+        def help(shell, subcommand = true)
+          list = self.printable_tasks(true, subcommand)
+          Thor::Util.thor_classes_in(self).each do |klass|
+            list += printable_tasks(false)
+          end
+          list.sort! { |a, b| a[0] <=> b[0] }
 
-    class << self
-      def help(shell, subcommand = true)
-        list = self.printable_tasks(true, subcommand)
-        Thor::Util.thor_classes_in(self).each do |klass|
-          list += printable_tasks(false)
+          shell.say
+          shell.print_table(list, :indent => 2, :truncate => true)
+          shell.say
+          Thor.send(:class_options_help, shell)
         end
-        list.sort! { |a, b| a[0] <=> b[0] }
 
-        shell.say
-        shell.print_table(list, :indent => 2, :truncate => true)
-        shell.say
-        Thor.send(:class_options_help, shell)
-      end
-
-      def banner(task, namespace = nil, subcommand = false)
-        task.name
+        def banner(task, namespace = nil, subcommand = false)
+          task.name
+        end
       end
     end
   end

data/lib/apipie/client/main.rb

@@ -1,97 +1,99 @@
 require "apipie/client/thor"
 require "apipie/client/cli_command"
 
-module Apipie::Client
-  class Main < Thor
-
-    def help(meth = nil)
-      if meth && !self.respond_to?(meth)
-        initialize_thorfiles(meth)
-        klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
-        self.class.handle_no_task_error(task, false) if klass.nil?
-        klass.start(["-h", task].compact, :shell => self.shell)
-      else
-        say "#{apipie_options[:name].capitalize} CLI"
-        say
-        invoke :commands
+module Apipie
+  module Client
+    class Main < Thor
+
+      def help(meth = nil)
+        if meth && !self.respond_to?(meth)
+          initialize_thorfiles(meth)
+          klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
+          self.class.handle_no_task_error(task, false) if klass.nil?
+          klass.start(["-h", task].compact, :shell => self.shell)
+        else
+          say "#{apipie_options[:name].capitalize} CLI"
+          say
+          invoke :commands
+        end
       end
-    end
 
-    desc "commands [SEARCH]", "List the available commands"
-    def commands(search="")
-      initialize_thorfiles
-      klasses = Thor::Base.subclasses
-      display_klasses(false, false, klasses)
-    end
+      desc "commands [SEARCH]", "List the available commands"
+      def commands(search="")
+        initialize_thorfiles
+        klasses = Thor::Base.subclasses
+        display_klasses(false, false, klasses)
+      end
 
-    class << self
-      private
-      def dispatch(task, given_args, given_options, config)
-        parser = Thor::Options.new :auth => Thor::Option.parse(%w[auth -a], :string)
-        opts   = parser.parse(given_args)
-        if opts['auth']
-          username, password                 = opts['auth'].split(':')
-          apipie_options[:config][:username] = username
-          apipie_options[:config][:password] = password
+      class << self
+        private
+        def dispatch(task, given_args, given_options, config)
+          parser = Thor::Options.new :auth => Thor::Option.parse(%w[auth -a], :string)
+          opts   = parser.parse(given_args)
+          if opts['auth']
+            username, password                 = opts['auth'].split(':')
+            apipie_options[:config][:username] = username
+            apipie_options[:config][:password] = password
+          end
+          remaining = parser.remaining
+
+          super(task, remaining, given_options, config)
         end
-        remaining = parser.remaining
-
-        super(task, remaining, given_options, config)
       end
-    end
 
-    private
+      private
 
-    def method_missing(meth, *args)
-      meth = meth.to_s
-      initialize_thorfiles(meth)
-      klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
-      args.unshift(task) if task
-      klass.start(args, :shell => self.shell)
-    end
+      def method_missing(meth, *args)
+        meth = meth.to_s
+        initialize_thorfiles(meth)
+        klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
+        args.unshift(task) if task
+        klass.start(args, :shell => self.shell)
+      end
 
-    # Load the thorfiles. If relevant_to is supplied, looks for specific files
-    # in the thor_root instead of loading them all.
-    #
-    # By default, it also traverses the current path until find Thor files, as
-    # described in thorfiles. This look up can be skipped by suppliying
-    # skip_lookup true.
-    #
-    def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
-      thorfiles.each do |f|
-        Thor::Util.load_thorfile(f, nil, options[:debug])
+      # Load the thorfiles. If relevant_to is supplied, looks for specific files
+      # in the thor_root instead of loading them all.
+      #
+      # By default, it also traverses the current path until find Thor files, as
+      # described in thorfiles. This look up can be skipped by suppliying
+      # skip_lookup true.
+      #
+      def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
+        thorfiles.each do |f|
+          Thor::Util.load_thorfile(f, nil, options[:debug])
+        end
       end
-    end
 
-    def thorfiles
-      Dir[File.expand_path("*/commands/*.thor", apipie_options[:root])]
-    end
+      def thorfiles
+        Dir[File.expand_path("*/commands/*.thor", apipie_options[:root])]
+      end
 
-    # Display information about the given klasses. If with_module is given,
-    # it shows a table with information extracted from the yaml file.
-    #
-    def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
-      klasses -= [Thor, Main, ::Apipie::Client::CliCommand, ::Thor] unless show_internal
+      # Display information about the given klasses. If with_module is given,
+      # it shows a table with information extracted from the yaml file.
+      #
+      def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
+        klasses -= [Thor, Main, ::Apipie::Client::CliCommand, ::Thor] unless show_internal
 
-      show_modules if with_modules && !thor_yaml.empty?
+        show_modules if with_modules && !thor_yaml.empty?
 
-      list   = Hash.new { |h, k| h[k] = [] }
-      groups = []
+        list   = Hash.new { |h, k| h[k] = [] }
+        groups = []
 
-      # Get classes which inherit from Thor
-      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_tasks(false) }
+        # Get classes which inherit from Thor
+        (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_tasks(false) }
 
-      # Get classes which inherit from Thor::Base
-      groups.map! { |k| k.printable_tasks(false).first }
-      list["root"] = groups
+        # Get classes which inherit from Thor::Base
+        groups.map! { |k| k.printable_tasks(false).first }
+        list["root"] = groups
 
-      # Order namespaces with default coming first
-      list         = list.sort { |a, b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
-      list.each { |n, tasks| display_tasks(n, tasks) unless tasks.empty? }
-    end
+        # Order namespaces with default coming first
+        list         = list.sort { |a, b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
+        list.each { |n, tasks| display_tasks(n, tasks) unless tasks.empty? }
+      end
 
-    def display_tasks(namespace, list) #:nodoc:
-      say namespace
+      def display_tasks(namespace, list) #:nodoc:
+        say namespace
+      end
     end
   end
 

data/lib/apipie/client/thor.rb

@@ -1,19 +1,21 @@
-module Apipie::Client
-  class Thor < ::Thor
+module Apipie
+  module Client
+    class Thor < ::Thor
 
-    def self.apipie_options
-      Apipie::Client::Thor.instance_variable_get :@apipie_options
-    end
+      def self.apipie_options
+        Apipie::Client::Thor.instance_variable_get :@apipie_options
+      end
 
-    no_tasks do
-      def apipie_options
-        self.class.apipie_options
+      no_tasks do
+        def apipie_options
+          self.class.apipie_options
+        end
       end
-    end
 
-    def self.apipie_options=(options)
-      Apipie::Client::Thor.instance_variable_set :@apipie_options, options
-    end
+      def self.apipie_options=(options)
+        Apipie::Client::Thor.instance_variable_set :@apipie_options, options
+      end
 
+    end
   end
 end

data/lib/apipie/version.rb

@@ -1,3 +1,3 @@
 module Apipie
-  VERSION = '0.0.12'
+  VERSION = '0.0.13'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: apipie-rails
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 0
   - 0
-  - 12
-  version: 0.0.12
+  - 13
+  version: 0.0.13
 platform: ruby
 authors: 
 - Pavel Pokorny
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-09 00:00:00 Z
+date: 2012-10-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec-rails