aviator 0.0.2 → 0.0.3

data/README.md

@@ -25,7 +25,7 @@ Or install it yourself as:
 ## Usage
 
 ```ruby
-require 'aviator'
+require 'aviator/core'
 
 # Create a new session. See 'Configuration' below for the config file format.
 session = Aviator::Session.new(
@@ -59,6 +59,14 @@ str = session.dump
 # If you employed any form of encryption on the string, make sure to decrypt it first!
 session = Aviator::Session.load(str)
 
+# In some instances, Session::load is inefficient because it creates a new session object
+# each time. In a web app environment, for instance, having to destroy and recreate the
+# session object can take its toll on performance. In such a scenario, use Session#load
+# (instance method, as opposed to class method). This will 'infect' an already existing
+# session object with the supplied session dump and return itself instead of creating
+# a brand new session object.
+session.load(other_session_dump)
+
 # Depending on how old the loaded session dump is, the auth_info may already be expired. 
 # Check if it's still current by calling Session#validate and reauthenticate as needed.
 #

data/aviator.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency 'faraday', '~> 0.8.0'
-  spec.add_dependency 'activesupport', '~> 4.0.0'
+  spec.add_dependency 'activesupport', '>= 3.2.8'
   spec.add_dependency 'thor', '~> 0.18.1'
   
   spec.add_development_dependency "bundler", "~> 1.3"

data/bin/aviator

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
-
 require 'bundler/setup'
 require 'thor'
-require 'aviator/core'
+require 'aviator'
+require 'aviator/core/cli'
 
 module Aviator
 module CLI
@@ -12,98 +12,18 @@ module CLI
     desc 'describe [PROVIDER] [SERVICE] [API_VERSION ENDPOINT_TYPE REQUEST_NAME]', 'Describes various parts of Aviator.'
     def describe(provider=nil, service=nil, api_version=nil, endpoint_type=nil, request=nil)
       if request
-        describe_request provider, service, api_version, endpoint_type, request
+        puts Aviator::Describer.describe_request(provider, service, api_version, endpoint_type, request)
       elsif service
-        describe_service provider, service
+        puts Aviator::Describer.describe_service(provider, service)
       elsif provider
-        describe_provider provider
+        puts Aviator::Describer.describe_provider(provider)
       else
-        list_providers
-      end
-    end
-
-
-    private
-
-
-    def describe_provider(provider)
-      puts "Available services from #{ provider }"
-      
-      Dir[Pathname.new(__FILE__).join('..', '..', 'lib', 'aviator', provider, '**')].each do |d|
-        puts "  #{ Pathname.new(d).basename }"
-      end
-    end
-
-
-    def describe_request(provider, service, api_version, endpoint_type, request_name)
-      endpoints = Service.new(provider: provider, service: service).requests[api_version.to_sym]
-      raise "Invalid API version #{ api_version }" unless endpoints
-      
-      requests = endpoints[endpoint_type.to_sym]
-      raise "Invalid endpoint type #{ endpoint_type }" unless requests
-      
-      request = requests[request_name.to_sym]
-      raise "Could not find request named #{ request_name }. Try a different api version or endpoint" unless request
-      
-      puts "Request: #{ request_name }"
-      
-      params = []
-      
-      request.optional_params.each do |param|
-        params << [param, :optional]
-      end
-      
-      request.required_params.each do |param|
-        params << [param, :required]
+        puts Aviator::Describer.describe_aviator
       end
-
-      params.sort! { |a,b| a[0].to_s <=> b[0].to_s }
-      
-      puts "\nParameters:"
-      params.each do |param_desc|
-        puts "  (#{ param_desc[1] }) #{ param_desc[0] }"
-      end
-      
-      puts "\nSample Code:"
-      print "  session.#{ service }_service.request(:#{ request_name }, endpoint_type: '#{ endpoint_type }')"
-      if params
-        puts " do |params|"
-        params.each do |pair|
-          puts "    params['#{ pair[0] }'] = val"
-        end
-        puts "  end"
-      end
-      
-      puts "\nLinks:"
-      request.links.each do |link|
-        puts "  #{ link[:rel] }:"
-        puts "    #{ link[:href] }\n"
-      end
-    end
-
-
-    def describe_service(provider, service)
-      puts "Available requests for #{ provider } #{ service }:"
-      
-      Service.new(provider: provider, service: service).requests.each do |api_version, endpoints|
-        endpoints.each do |endpoint_type, requests|
-          requests.each do |request_name, request_obj|
-            puts "  #{ api_version} #{ endpoint_type } #{ request_name }"
-          end
-          puts ""
-        end
-      end
-    end
-
-
-    def list_providers
-      puts "Available providers:"
-      puts "  openstack"
     end
 
   end
 
-
 end
 end
 

data/lib/aviator/core/cli/describer.rb

@@ -0,0 +1,95 @@
+module Aviator
+  
+  module Describer
+
+    def self.describe_aviator
+      provider_names = Pathname.new(__FILE__)
+                        .join('..', '..', '..')
+                        .children
+                        .select{|c| c.directory? && c.basename.to_s != 'core' }
+                        .map{|c| c.basename.to_s }
+
+      str = "Available providers:\n"
+
+      provider_names.each do |provider_name|
+        str << "  #{ provider_name }\n"
+      end
+      
+      str
+    end
+
+
+    def self.describe_provider(provider_name)
+      service_names = Pathname.new(__FILE__)
+                        .join('..', '..', '..', provider_name)
+                        .children
+                        .select{|c| c.directory? }
+                        .map{|c| c.basename.to_s }
+
+      str = "Available services for #{ provider_name }:\n"
+
+      service_names.each do |service_name|
+        str << "  #{ service_name }\n"
+      end
+      
+      str
+    end
+
+
+    def self.describe_request(provider_name, service_name, api_version, endpoint_type, request_name)
+      service = Aviator::Service.new provider: provider_name, service: service_name
+      request_class = "Aviator::#{ provider_name.camelize }::#{ service_name.camelize }::"\
+                      "#{ api_version.camelize }::#{ endpoint_type.camelize }::#{ request_name.camelize }".constantize
+                      
+      str = "Request: #{ request_name }\n\n"
+      
+      str << "Parameters:\n"
+
+      params = request_class.optional_params.map{|p| [p, :optional]} + 
+               request_class.required_params.map{|p| [p, :required]}
+      
+      params.sort{|a,b| a[0].to_s <=> b[0].to_s }.each do |param|
+        str << "  (#{ param[1].to_s }) #{ param[0] }\n"
+      end
+      
+      str << "\nSample Code:\n"
+
+      str << "  session.#{ service_name }_service.request(:#{ request_name }, endpoint_type: '#{ request_class.endpoint_type }')"
+      if params
+        str << " do |params|\n"
+        params.each do |pair|
+          str << "     params['#{ pair[0] }'] = value\n"
+        end
+        str << "  end\n"
+      end
+      
+      if request_class.links
+        str << "\nLinks:\n"
+        
+        request_class.links.each do |link|
+          str << "  #{ link[:rel] }:\n"
+          str << "    #{ link[:href] }\n"
+        end
+      end
+      
+      str
+    end
+
+
+    def self.describe_service(provider_name, service_name)
+      service = Aviator::Service.new(provider: provider_name, service: service_name)
+      klasses = service.request_classes
+      
+      str = "Available requests for #{ provider_name } #{ service_name }_service:\n"
+
+      klasses.each do |klass|
+        str << "  #{ klass.api_version } #{ klass.endpoint_type } #{ klass.name.split('::').last.underscore }\n"
+      end
+      
+      str
+    end
+
+
+  end
+  
+end

data/lib/aviator/core/cli.rb

@@ -0,0 +1 @@
+require "aviator/core/cli/describer"

data/lib/aviator/core/request.rb

@@ -1,5 +1,40 @@
 module Aviator
 
+  class << self
+    
+    def define_request(request_name, &block)
+      class_obj = Class.new(Request, &block)
+      
+      set_class_name(
+        Aviator,
+        class_obj,
+        
+        class_obj.provider,
+        class_obj.service,
+        class_obj.api_version,
+        class_obj.endpoint_type,
+        request_name
+      )
+    end
+    
+    
+    private    
+    
+    def set_class_name(base, obj, *hierarchy)
+      const_name = hierarchy.shift.to_s.camelize
+
+      const = if base.const_defined?(const_name)
+                base.const_get(const_name)
+              else
+                base.const_set(const_name, (hierarchy.empty? ? obj : Module.new))
+              end
+      
+      hierarchy.empty? ? const : set_class_name(const, obj, *hierarchy)
+    end
+    
+  end # class << self
+
+
   class Request
 
     class ApiVersionNotDefinedError < StandardError
@@ -40,31 +75,16 @@ module Aviator
     end
 
 
-    def api_version
-      self.class.api_version
-    end
-
-
     def body?
       self.class.body?
     end
 
 
-    def endpoint_type
-      self.class.endpoint_type
-    end
-
-
     def headers?
       self.class.headers?
     end
 
 
-    def http_method
-      self.class.http_method
-    end
-
-
     def links
       self.class.links
     end
@@ -80,11 +100,6 @@ module Aviator
     end
 
 
-    def querystring?
-      self.class.querystring?
-    end
-
-
     def required_params
       self.class.required_params
     end
@@ -100,6 +115,11 @@ module Aviator
     end
 
 
+    def querystring?
+      self.class.querystring?
+    end
+    
+
     def url?
       self.class.url?
     end
@@ -123,22 +143,8 @@ module Aviator
     # within the class and because they don't change between instances anyway.
     class << self
 
-      def anonymous
-        @anonymous = true
-      end
-
-
       def anonymous?
-        @anonymous == true
-      end
-
-
-      def api_version(value=nil)
-        if value
-          @api_version = value
-        else
-          @api_version
-        end
+        respond_to?(:anonymous) && anonymous == true
       end
 
 
@@ -147,33 +153,10 @@ module Aviator
       end
 
 
-      def endpoint_type(value=nil)
-        if value
-          @endpoint_type = value
-        else
-          @endpoint_type
-        end
-      end
-
-
       def headers?
         instance_methods.include? :headers
       end
-
-
-      def http_method(value=nil)
-        if value
-          @http_method = value
-        else
-          @http_method
-        end
-      end
-      
-      
-      def link_to(rel, href)
-        links << { rel: rel, href: href }
-      end
-      
+            
       
       def links
         @links ||= []
@@ -199,12 +182,12 @@ module Aviator
       def querystring?
         instance_methods.include? :querystring
       end
-
+      
 
       def required_params
         @required_params ||= []
       end
-
+      
 
       def url?
         instance_methods.include? :url
@@ -213,13 +196,27 @@ module Aviator
 
       private
 
-      def required_param(param_name)
-        required_params << param_name unless required_params.include?(param_name)
+
+      def link(rel, href)
+        links << { rel: rel, href: href }
       end
 
 
-      def optional_param(param_name)
-        optional_params << param_name unless optional_params.include?(param_name)
+      def meta(attr_name, attr_value)
+        define_singleton_method(attr_name) do
+          attr_value
+        end
+
+        define_method(attr_name) do
+          self.class.send(attr_name)
+        end
+      end
+      
+
+      def param(param_name, opts={})
+        opts  = opts.with_indifferent_access
+        list  = (opts[:required] == false ? optional_params : required_params)
+        list << param_name unless optional_params.include?(param_name)
       end
 
     end

data/lib/aviator/core/service.rb

@@ -45,29 +45,6 @@ module Aviator
       end
     end
 
-    # Because we define requests in a flattened scope, we want to make sure that when each
-    # request is initialized it doesn't get polluted by instance variables and methods
-    # of the containing class. This builder class makes that happen by being a
-    # scope gate for the file. See Metaprogramming Ruby, specifically on blocks and scope
-    class RequestBuilder
-
-      # This method gets called by the request file eval'd in self.build below
-      def define_request(request_name, &block)
-        klass = Class.new(Aviator::Request, &block)
-        return klass, request_name
-      end
-
-
-      def self.build(path_to_request_file)
-        clean_room = new
-        clean_room.instance_eval(File.read(path_to_request_file))
-      end
-
-
-      private_class_method :new
-
-    end
-
 
     attr_accessor :default_session_data
 
@@ -108,8 +85,8 @@ module Aviator
     end
 
 
-    def requests
-      @requests
+    def request_classes
+      @request_classes
     end
     
     
@@ -134,19 +111,27 @@ module Aviator
     # Candidate for extraction to aviator/openstack
     def find_request(name, session_data, endpoint_type=nil)
       endpoint_types = if endpoint_type
-                         [endpoint_type.to_sym]
+                         [endpoint_type.to_s.camelize]
                        else
-                         [:public, :admin]
+                         ['Public', 'Admin']
                        end
 
-      version = infer_version(session_data)
+      namespace = Aviator.const_get(provider.camelize)
+                         .const_get(service.camelize)   
 
-      return nil unless version && requests[version]
+      version = infer_version(session_data).to_s.camelize
+            
+      return nil unless version && namespace.const_defined?(version)
+
+      namespace = namespace.const_get(version)
 
       endpoint_types.each do |endpoint_type|
-        next unless requests[version][endpoint_type]
-        pair = requests[version][endpoint_type].find{ |k, v| k == name }
-        return pair[1] unless pair.nil?
+        name = name.to_s.camelize
+        
+        next unless namespace.const_defined?(endpoint_type)
+        next unless namespace.const_get(endpoint_type).const_defined?(name)
+        
+        return namespace.const_get(endpoint_type).const_get(name)
       end
 
       nil
@@ -182,14 +167,14 @@ module Aviator
                              ).expand_path
                            )
 
-      @requests ||= {}
-
-      request_file_paths.each do |path_to_file|
-        klass, request_name = RequestBuilder.build(path_to_file)
-
-        api_version   = @requests[klass.api_version] ||= {}
-        endpoint_type = api_version[klass.endpoint_type] ||= {}
-        endpoint_type[request_name] = klass
+      request_file_paths.each{ |path| require path }
+      
+      constant_parts = request_file_paths
+                        .map{|rf| rf.to_s.match(/#{provider}\/#{service}\/([\w\/]+)\.rb$/) }
+                        .map{|rf| rf[1].split('/').map{|c| c.camelize }.join('::') }
+      
+      @request_classes = constant_parts.map do |cp| 
+        "Aviator::#{provider.camelize}::#{service.camelize}::#{cp}".constantize
       end
     end
     
@@ -197,7 +182,7 @@ module Aviator
     def log_file
       @log_file
     end
-
+    
   end
 
 end

data/lib/aviator/core/session.rb

@@ -83,6 +83,13 @@ module Aviator
     end
     
     
+    def load(session_dump)
+      initialize_with_dump(session_dump)
+      update_services_session_data
+      self
+    end
+    
+    
     def method_missing(name, *args, &block)
       service_name_parts = name.to_s.match(/^(\w+)_service$/)
       

data/lib/aviator/core.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'active_support/inflector'
+require 'active_support/core_ext/hash/indifferent_access'
 require 'faraday'
 
 require "aviator/version"

data/lib/aviator/openstack/compute/v2/public/list_images.rb

@@ -1,49 +1,58 @@
-define_request :list_images do
-
-  endpoint_type :public
-  api_version   :v2
-  http_method   :get
-
-  link_to 'documentation',
-          'http://docs.openstack.org/api/openstack-compute/2/content/List_Images-d1e4435.html'
-
-  optional_param :details
-  optional_param :server
-  optional_param :name
-  optional_param :status
-  optional_param 'changes-since'
-  optional_param :marker
-  optional_param :limit
-  optional_param :type
-
-
-
-  def url
-    service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == 'compute' }
-    
-    str  = "#{ service_spec[:endpoints][0][:publicURL] }/images"
-    str += "/detail" if params[:details]
-    
-    filters = []
-    
-    (optional_params + required_params - [:details]).each do |param_name|
-      filters << "#{ param_name }=#{ params[param_name] }" if params[param_name]
+module Aviator
+  
+  define_request :list_images do
+
+    meta :provider,      :openstack
+    meta :service,       :compute
+    meta :api_version,   :v2
+    meta :endpoint_type, :public
+
+    link 'documentation',
+         'http://docs.openstack.org/api/openstack-compute/2/content/List_Images-d1e4435.html'
+
+    param :details,        required: false
+    param :server,         required: false
+    param :name,           required: false
+    param :status,         required: false
+    param 'changes-since', required: false
+    param :marker,         required: false
+    param :limit,          required: false
+    param :type,           required: false
+
+
+    def headers
+      h = {}
+
+      unless self.anonymous?
+        h['X-Auth-Token'] = session_data[:access][:token][:id]
+      end
+
+      h
     end
-    
-    str += "?#{ filters.join('&') }" unless filters.empty?
-    
-    str
-  end
 
 
-  def headers
-    h = {}
-    
-    unless self.anonymous?
-      h['X-Auth-Token'] = session_data[:access][:token][:id]
+    def http_method
+      :get
+    end
+
+
+    def url
+      service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == 'compute' }
+
+      str  = "#{ service_spec[:endpoints][0][:publicURL] }/images"
+      str += "/detail" if params[:details]
+
+      filters = []
+
+      (optional_params + required_params - [:details]).each do |param_name|
+        filters << "#{ param_name }=#{ params[param_name] }" if params[param_name]
+      end
+
+      str += "?#{ filters.join('&') }" unless filters.empty?
+
+      str
     end
 
-    h
   end
 
-end
+end