apipie-rails 0.0.7

data/lib/apipie/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/apipie/client/template/README.tt

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

data/lib/apipie/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/apipie/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/apipie/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/apipie/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/apipie/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/apipie/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

data/lib/apipie/dsl_definition.rb

@@ -0,0 +1,139 @@
+# Apipie DSL functions.
+
+module Apipie
+
+  # DSL is a module that provides #api, #error, #param, #error.
+  module DSL
+
+    private
+
+    # Describe whole resource
+    #
+    # Example:
+    # api :desc => "Show user profile", :path => "/users/", :version => '1.0 - 3.4.2012'
+    # param :id, Fixnum, :desc => "User ID", :required => true
+    # desc <<-EOS
+    #   Long description...
+    # EOS
+    def resource_description(options = {}, &block) #:doc:
+      return unless Apipie.active_dsl?
+      Apipie.remove_resource_description(self)
+      Apipie.define_resource_description(self, &block) if block_given?
+    end
+
+    # Declare an api.
+    #
+    # Example:
+    #   api :GET, "/resource_route", "short description",
+    #
+    def api(method, path, desc = nil) #:doc:
+      return unless Apipie.active_dsl?
+      Apipie.add_method_description_args(method, path, desc)
+    end
+
+    # Describe the next method.
+    #
+    # Example:
+    #   desc "print hello world"
+    #   def hello_world
+    #     puts "hello world"
+    #   end
+    #
+    def desc(description) #:doc:
+      return unless Apipie.active_dsl?
+      if Apipie.last_description
+        raise "Double method description."
+      end
+      Apipie.last_description = description
+    end
+    alias :description :desc
+
+    # Reference other similar method
+    #
+    #   api :PUT, '/articles/:id'
+    #   see "articles#create"
+    #   def update; end
+    def see(method_key)
+      return unless Apipie.active_dsl?
+      raise "'See' method called twice." if Apipie.last_see
+      Apipie.last_see = method_key
+    end
+
+    # Show some example of what does the described
+    # method return.
+    def example(example) #:doc:
+      return unless Apipie.active_dsl?
+      Apipie.add_example(example)
+    end
+
+    # Describe possible errors
+    #
+    # Example:
+    #   error :desc => "speaker is sleeping", :code => 500
+    #   error 500, "speaker is sleeping"
+    #   def hello_world
+    #     return 500 if self.speaker.sleeping?
+    #     puts "hello world"
+    #   end
+    #
+    def error(*args) #:doc:
+      return unless Apipie.active_dsl?
+      Apipie.last_errors << Apipie::ErrorDescription.new(args)
+    end
+
+    # Describe method's parameter
+    #
+    # Example:
+    #   param :greeting, String, :desc => "arbitrary text", :required => true
+    #   def hello_world(greeting)
+    #     puts greeting
+    #   end
+    #
+    def param(param_name, *args, &block) #:doc:
+      return unless Apipie.active_dsl?
+      Apipie.last_params << Apipie::ParamDescription.new(param_name, *args, &block)
+    end
+
+    # create method api and redefine newly added method
+    def method_added(method_name) #:doc:
+      super
+
+      return unless Apipie.active_dsl?
+      return unless Apipie.apipie_provided?
+
+      # remove method description if exists and create new one
+      Apipie.remove_method_description(self, method_name)
+      description = Apipie.define_method_description(self, method_name)
+
+      # redefine method only if validation is turned on
+      if Apipie.configuration.validate == true
+
+        old_method = instance_method(method_name)
+
+        define_method(method_name) do |*args|
+
+          if Apipie.configuration.validate == true
+            description.params.each do |_, param|
+
+              # check if required parameters are present
+              if param.required && !params.has_key?(param.name)
+                raise ArgumentError.new("Expecting #{param.name} parameter.")
+              end
+
+              # params validations
+              if params.has_key?(param.name)
+                param.validate(params[:"#{param.name}"])
+              end
+
+            end
+          end
+
+          # run the original method code
+          old_method.bind(self).call(*args)
+        end
+
+      end
+
+    end # def method_added
+  end # module DSL
+end # module Apipie