restapi 0.0.4 → 0.0.5

data/lib/restapi/client/generator.rb

@@ -0,0 +1,104 @@
+#!/bin/env ruby
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'thor'
+require 'thor/group'
+require 'fileutils'
+require 'active_support/inflector'
+
+module Restapi
+  module Client
+
+    class Generator < Thor::Group
+      include Thor::Actions
+      
+      # Define arguments and options
+      argument :name
+
+      attr_reader :doc, :resource
+
+      def initialize(*args)
+        super
+        @doc = Restapi.to_json()[:docs]
+      end
+      
+      def self.source_root
+        File.expand_path("../template", __FILE__)
+      end      
+
+      def self.destination_root
+        File.join(FileUtils.pwd, "client")
+      end
+
+      def self.start(client_name)
+        super([client_name.parameterize.underscore], :destination_root => destination_root)
+      end
+
+      def generate_cli
+        template("README.tt", "README")
+        template("Gemfile.tt", "Gemfile")
+        template("bin.rb.tt", "bin/#{name}-client")
+        chmod("bin/#{name}-client", 0755)
+        template("client.rb.tt", "lib/#{name}_client.rb")
+        template("base.rb.tt", "lib/#{name}_client/base.rb")
+        template("cli_command.rb.tt", "lib/#{name}_client/cli_command.rb")
+        doc[:resources].each do |key, resource|
+          @resource = resource
+          template("cli.rb.tt", "lib/#{name}_client/commands/#{resource_name}.thor")
+          template("resource.rb.tt", "lib/#{name}_client/resources/#{resource_name}.rb")
+        end
+      end
+
+      protected
+
+      def class_base
+        name.camelize
+      end
+
+      def plaintext(text)
+        text.gsub(/<.*?>/, '').gsub("\n",' ').strip
+      end
+
+      # Resource related helper methods:
+      
+      def resource_name
+        resource[:name].gsub(/\s/,"_").downcase.singularize
+      end
+
+      def api(method)
+        method[:apis].first
+      end
+
+      def params_in_path(method)
+        api(method)[:api_url].scan(/:([^\/]*)/).map(&:first)
+      end
+
+      def client_args(method)
+        client_args = params_in_path(method).dup
+        client_args << "params = {}" if method[:params].any?
+        client_args
+      end
+
+      def 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
+      end
+
+      def substituted_url(method)
+        params_in_path(method).reduce(api(method)[:api_url]) { |u, p| u.sub(":#{p}","\#{#{p}}")}
+      end
+
+      def transformation_hash(method)
+        method[:params].find_all { |p| p[:expected_type] == "hash" && !p[:params].nil? }.reduce({}) do |h, p|
+          h.update(p[:name] => p[:params].map { |pp| pp[:name] })
+        end
+      end
+    end
+    
+  end
+end

data/lib/restapi/client/template/Gemfile.tt

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'thor', '0.15.4'
+gem 'json'
+gem 'rest-client', '1.6.1'

data/lib/restapi/client/template/README.tt

@@ -0,0 +1,3 @@
+This is a readme file for this gem.
+
+Let the code be with you!

data/lib/restapi/client/template/base.rb.tt

@@ -0,0 +1,33 @@
+require 'rest_client'
+require 'json'
+
+module <%= class_base %>Client
+  class Base
+    attr_reader :client
+
+    def initialize(config)
+      @client =  RestClient::Resource.new(config[:base_url], :user => config[:username], :password => config[:password])
+    end
+
+    def call(method, path, params = {})
+      ret = client[path].send(method, params)
+      data = JSON.parse(ret.body) rescue ret.body
+      return data, ret
+    end
+
+    def validate_params!(options, valid_keys)
+      return unless options.is_a?(Hash)
+      invalid_keys = options.keys - (valid_keys.is_a?(Hash) ? valid_keys.keys : valid_keys)
+      raise ArgumentError, "Invalid keys: #{invalid_keys.join(", ")}" unless invalid_keys.empty?
+
+      if valid_keys.is_a? Hash
+        valid_keys.each do |key, keys|
+          if options[key]
+            validate_params!(options[key], keys)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/restapi/client/template/bin.rb.tt

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+require "rubygems" # ruby1.9 doesn't "require" it though
+require "pathname"
+require "thor"
+require 'thor/core_ext/file_binary_read'
+
+$: << File.expand_path("../../lib", __FILE__)
+require "<%= name %>_client"
+require "<%= name %>_client/cli_command"
+
+module <%= class_base %>Cli
+  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 "<%= name.capitalize %> CLI"
+        say
+        invoke :commands
+      end
+    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({:username => Thor::Option.parse(%w[username -u], :string),
+                                   :password => Thor::Option.parse(%w[password -p], :string)})
+        opts = parser.parse(given_args)
+        <%= class_base %>Client.client_config[:username] = opts["username"]
+        <%= class_base %>Client.client_config[:password] = opts["password"]
+        #remaining =  parser.instance_variable_get("@unknown") # TODO: this is an ugly hack :(
+        remaining = parser.remaining
+        super(task, remaining, given_options, config)
+      end
+    end
+
+    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
+
+    # 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
+
+    def thorfiles
+      Dir[File.expand_path("../../lib/<%= name %>_client/commands/*.thor", __FILE__)]
+    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, ::<%= class_base %>Client::CliCommand] unless show_internal
+
+      show_modules if with_modules && !thor_yaml.empty?
+
+      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::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
+
+    def display_tasks(namespace, list) #:nodoc:
+      say namespace
+    end
+  end
+
+end
+
+begin
+  <%= class_base %>Cli::Main.start
+rescue RestClient::Exception => e
+  $stderr.puts e.message
+  exit 1
+end

data/lib/restapi/client/template/cli.rb.tt

@@ -0,0 +1,25 @@
+class <%= resource_name.camelize %> < <%= class_base %>Client::CliCommand
+
+<% resource[:methods].each do |method| -%>
+  desc '<%= method[:name] %>', '<%= api(method)[:short_description] %>'
+<%   params_in_path(method).each do |param| -%>
+  method_option :<%= param %>, :required => 'true'
+<%   end
+     method[:params].map {|p| p[:expected_type] == "hash" ? (p[:params] || p) : p}.flatten.each do |param| -%>
+  method_option :<%= param[:name] %>, :required => <%= param[:required] ? 'true' : 'false' %>, :desc => '<%= plaintext(param[:description]) %>', :type => :<%= param[:expected_type] %>
+<%   end -%>
+  def <%= method[:name] %>
+<%   if params_in_path(method).any? || transformation_hash(method).any?
+       transform_options_params = [params_in_path(method).inspect]
+       transform_options_params << transformation_hash(method).inspect if transformation_hash(method).any? -%>
+    <%= (params_in_path(method) + ["options"]).join(", ") %>, *_ = transform_options(<%= transform_options_params.join(", ").html_safe %>)
+<%   end
+
+  client_args = params_in_path(method).dup
+  client_args << "options" if method[:params].any? -%>
+    data, resp = client.<%= method[:name] %><%= "(#{client_args.join(", ")})" if client_args.any? %>
+    print_data(data)
+  end
+
+<% end -%>
+end

data/lib/restapi/client/template/cli_command.rb.tt

@@ -0,0 +1,129 @@
+module <%= class_base %>Client
+  class CliCommand < Thor
+    no_tasks do
+      def client
+        resource_class = <%= class_base %>Client::Resources.const_get(self.class.name[/[^:]*$/])
+        @client ||= resource_class.new(<%= class_base %>Client.client_config)
+      end
+
+      def transform_options(inline_params, transform_hash = {})
+        ret = inline_params.map { |p| options[p] }
+
+        # 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]) }
+
+        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
+
+        ret << transformed_options
+        return *ret
+      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
+
+      # 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
+        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)
+        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)
+        end
+        table
+      end
+
+      def print_unknown(data)
+        say data
+      end
+
+      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 << "%-#{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
+
+        formats << "%s"
+        formats[0] = formats[0].insert(0, " " * ident)
+
+        header_printed = false
+        table.each do |row|
+          sentence = ""
+
+          row.each_with_index do |column, i|
+            sentence << formats[i] % column.to_s
+          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] }
+
+        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
+      end
+    end
+  end
+end

data/lib/restapi/client/template/client.rb.tt

@@ -0,0 +1,10 @@
+require '<%= name %>_client/base'
+
+resource_files = Dir[File.expand_path('../<%= name %>_client/resources/*.rb', __FILE__)]
+resource_files.each { |f| require f }
+
+module <%= class_base %>Client
+  def self.client_config
+    @client_config ||= {:base_url => "http://localhost:3000"}
+  end
+end

data/lib/restapi/client/template/resource.rb.tt

@@ -0,0 +1,17 @@
+module <%= class_base %>Client
+  module Resources
+    class <%= resource_name.camelize %> < <%= class_base %>Client::Base
+<% resource[:methods].each do |method| -%>
+
+      def <%= method[:name] %><%= "(#{ client_args(method).join(", ") })" if client_args(method).any? %>
+<% if method[:params].any? -%>
+        validate_params!(params, <%= validation_hash(method).inspect.html_safe %>)
+<% end -%>
+        call(:<%= api(method)[:http_method].downcase %>, "<%= substituted_url(method) %>"<%= 
+        (api(method)[:http_method].downcase == 'get' ? ", :params => params" : ", params") if method[:params].any? %>)
+      end
+<% end -%>
+
+    end
+  end
+end