spark_api 1.0.0

data/lib/spark_api/cli.rb~

@@ -0,0 +1,158 @@
+require 'optparse'
+
+if ENV["SPARK_API_CONSOLE"].nil?
+  require 'spark_api'
+else
+  puts "Enabling console mode for local gem"
+  Bundler.require(:default, "development") if defined?(Bundler)
+  path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
+  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  require path + '/spark_api'
+end
+
+module SparkApi
+  module CLI
+    class ConsoleCLI
+      OPTIONS_ENV = {
+        :endpoint          => "API_ENDPOINT",
+        # OAUTH2 Options
+        :access_uri  => "ACCESS_URI",
+        :username=> "USERNAME",
+        :password=> "PASSWORD",
+        :client_id=> "CLIENT_ID",
+        :client_secret=> "CLIENT_SECRET",
+        # API AUTH Options
+        :api_key => "API_KEY", 
+        :api_secret => "API_SECRET",
+        :api_user => "API_USER",
+        # OTHER
+        :debug=> "DEBUG",
+        :console => "SPARK_API_CONSOLE"  # not a public option, meant to distinguish bin/spark_api and script/console
+      }
+      
+      def self.execute(stdout, arguments=[])
+        options = setup_options(stdout,arguments)
+        libs =  " -r irb/completion"
+        # Perhaps use a console_lib to store any extra methods I may want available in the cosole
+        libs << (options[:oauth2] ? setup_oauth2 : setup_api_auth)
+        
+        bundler = (options[:console] ? "bundle exec" : "")  
+        cmd = "#{export_env(options)} #{bundler} #{irb} #{libs} --simple-prompt"
+        puts "Loading spark_api gem..."
+        exec "#{cmd}"
+      end
+      
+      def self.irb()
+        RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+      end
+      
+      private
+      def self.setup_options(stdout,arguments)
+        env_options = {
+          :oauth2            => false,
+          :endpoint          => ENV[OPTIONS_ENV[:endpoint]],
+          # OAUTH2 Options
+          :access_uri  => ENV[OPTIONS_ENV[:access_uri]],
+          :username=> ENV[OPTIONS_ENV[:username]],
+          :password=> ENV[OPTIONS_ENV[:password]],
+          :client_id=> ENV[OPTIONS_ENV[:client_id]],
+          :client_secret=> ENV[OPTIONS_ENV[:client_secret]],
+          # API AUTH Options
+          :api_key => ENV[OPTIONS_ENV[:api_key]], 
+          :api_secret => ENV[OPTIONS_ENV[:api_secret]],
+          :api_user => ENV[OPTIONS_ENV[:api_user]],
+          :console => ENV[OPTIONS_ENV[:console]]
+        }
+        cli_options = {}
+        file_options = {}
+        parser = OptionParser.new do |opts|
+          opts.banner = <<-BANNER.gsub(/^          /,'')
+            #{version}
+            SparkApi Client Console - http://www.flexmls.com/developers/api/
+            
+            Usage: #{File.basename($0)} [options]
+            
+            Environment Variables: some options (as indicated below), will default to values of keys set in the environment. 
+        
+            Options are:
+          BANNER
+          opts.separator ""
+          opts.on("-o","--oauth2",
+                  "Run the API using OAuth2 credentials.  The client defaults to using the Spark API authentication mode for access. ",
+                  "See http://www.flexmls.com/developers/api/api-services/authentication/ for more information on authentication types.",
+                  "Default: false") { |arg| cli_options[:oauth2] = arg }
+          opts.on("-e","--endpoint ENDPOINT",
+                  "URI of the API.",
+                  "Default: ENV['#{OPTIONS_ENV[:endpoint]}']") { |arg| cli_options[:endpoint] = arg }
+
+          # OAUTH2
+          opts.on("--client_id CLIENT_ID",
+                  "OAuth2 client id",
+                  "Default: ENV['#{OPTIONS_ENV[:client_id]}']") { |arg| cli_options[:client_id] = arg }
+          opts.on("--client_secret CLIENT_SECRET",
+                  "OAuth2 client secret",
+                  "Default: ENV['#{OPTIONS_ENV[:client_secret]}']") { |arg| cli_options[:client_secret] = arg }
+          opts.on("-u","--username USERNAME",
+                  "OAuth2 username",
+                  "Default: ENV['#{OPTIONS_ENV[:username]}']") { |arg| cli_options[:username] = arg }
+          opts.on("-p","--password PASSWORD",
+                  "OAuth2 password",
+                  "Default: ENV['#{OPTIONS_ENV[:password]}']") { |arg| cli_options[:password] = arg }
+          opts.on("--access_uri ACCESS_URI",
+                  "OAuth2 path for granting access to the application",
+                  "Default: ENV['#{OPTIONS_ENV[:access_uri]}']") { |arg| cli_options[:access_uri] = arg }
+                    
+          # API AUTH
+          opts.on("--api_key API_KEY",
+                  "Authentication key for running the api using the default api authentication",
+                  "Default: ENV['#{OPTIONS_ENV[:api_key]}']") { |arg| cli_options[:api_key] = arg }
+          opts.on("--api_secret API_SECRET",
+                  "API secret for the api key",
+                   "Default: ENV['#{OPTIONS_ENV[:api_secret]}']") { |arg| cli_options[:api_secret] = arg }
+          opts.on("--api_user API_USER",
+                  "ID of the Spark user to run the client as.",
+                  "Default: ENV['#{OPTIONS_ENV[:api_user]}']") { |arg| cli_options[:api_user] = arg }
+                    
+          opts.on("-f", "--file FILE",
+                  "Load configuration for yaml file.") { |arg| file_options = parse_file_options(arg) }
+          opts.on("-d", "--debug",
+                  "Show detailed request logging information.") { |arg| cli_options[:debug] = arg }
+          opts.on("-v", "--version",
+                  "Show client version.") { stdout.puts version; exit }
+          opts.on("-h", "--help",
+                  "Show this help message.") { stdout.puts opts; exit }
+          opts.parse!(arguments)
+        
+        end
+        options = env_options.merge(file_options.merge(cli_options))
+        return options
+      end
+      
+      def self.setup_api_auth
+        " -r #{File.dirname(__FILE__) + '/../../lib/spark_api/cli/api_auth.rb'}"
+      end
+  
+      def self.setup_oauth2
+        " -r #{File.dirname(__FILE__) + '/../../lib/spark_api/cli/oauth2.rb'}"
+      end
+      
+      def self.export_env(options)
+        run_env = ""
+        OPTIONS_ENV.each do |k,v|
+          run_env << " #{v}=\"#{options[k]}\"" unless options[k].nil?
+        end
+        run_env
+      end
+      
+      private 
+      def self.parse_file_options(file)
+        yaml = SparkApi::Configuration::YamlConfig.new(file)
+        return {:oauth2 => yaml.oauth2}.merge(yaml.client_keys.merge(yaml.oauth2_keys))
+      end
+      
+      def self.version
+        "SparkApi v#{SparkApi::VERSION}"
+      end
+    end
+  end
+end

data/lib/spark_api/cli/api_auth.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/../cli/setup"
+
+SparkApi.configure do |config|
+  config.api_key = ENV["API_KEY"] 
+  config.api_secret = ENV["API_SECRET"]
+  config.api_user = ENV["API_USER"] if ENV["API_USER"]
+  config.endpoint = ENV["API_ENDPOINT"] if ENV["API_ENDPOINT"]
+end

data/lib/spark_api/cli/api_auth.rb~

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/../cli/setup"
+
+FlexmlsApi.configure do |config|
+  config.api_key = ENV["API_KEY"] 
+  config.api_secret = ENV["API_SECRET"]
+  config.api_user = ENV["API_USER"] if ENV["API_USER"]
+  config.endpoint = ENV["API_ENDPOINT"] if ENV["API_ENDPOINT"]
+end

data/lib/spark_api/cli/oauth2.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/../cli/setup"
+
+SparkApi.configure do |config|
+  config.oauth2_provider = SparkApi::Authentication::OAuth2Impl::PasswordProvider.new(
+                            :authorization_uri=> ENV["AUTH_URI"],
+                            :access_uri  => ENV["ACCESS_URI"],
+                            :username=> ENV["USERNAME"],
+                            :password=> ENV["PASSWORD"],
+                            :client_id=> ENV["CLIENT_ID"],
+                            :client_secret=> ENV["CLIENT_SECRET"]
+                          ) 
+  config.authentication_mode = SparkApi::Authentication::OAuth2
+  config.endpoint = ENV["API_ENDPOINT"] if ENV["API_ENDPOINT"]
+end

data/lib/spark_api/cli/oauth2.rb~

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/../cli/setup"
+
+FlexmlsApi.configure do |config|
+  config.oauth2_provider = FlexmlsApi::Authentication::OAuth2Impl::PasswordProvider.new(
+                            :authorization_uri=> ENV["AUTH_URI"],
+                            :access_uri  => ENV["ACCESS_URI"],
+                            :username=> ENV["USERNAME"],
+                            :password=> ENV["PASSWORD"],
+                            :client_id=> ENV["CLIENT_ID"],
+                            :client_secret=> ENV["CLIENT_SECRET"]
+                          ) 
+  config.authentication_mode = FlexmlsApi::Authentication::OAuth2
+  config.endpoint = ENV["API_ENDPOINT"] if ENV["API_ENDPOINT"]
+end

data/lib/spark_api/cli/setup.rb

@@ -0,0 +1,47 @@
+require "rubygems"
+require 'pp'
+require 'irb/ext/save-history'
+IRB.conf[:SAVE_HISTORY] = 1000
+IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.spark-api-history"
+
+if ENV["SPARK_API_CONSOLE"].nil?
+  require 'spark_api'
+else
+  puts "Enabling console mode for local gem"
+  Bundler.require(:default, "development") if defined?(Bundler)
+  path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
+  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  require path + '/spark_api'
+end
+
+IRB.conf[:AUTO_INDENT]=true
+IRB.conf[:PROMPT][:SPARK]= {
+  :PROMPT_I => "SparkApi:%03n:%i> ",
+  :PROMPT_S => "SparkApi:%03n:%i%l ",
+  :PROMPT_C => "SparkApi:%03n:%i* ",
+  :RETURN => "%s\n"
+} 
+
+IRB.conf[:PROMPT_MODE] = :SPARK
+
+path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
+$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+require path + '/spark_api'
+
+module SparkApi
+  def self.logger
+    if @logger.nil?
+      @logger = Logger.new(STDOUT)
+      @logger.level = ENV["DEBUG"].nil? ? Logger::WARN : Logger::DEBUG
+    end
+    @logger
+  end
+end
+
+SparkApi.logger.info("Client configured!")
+
+include SparkApi::Models
+
+def c
+  SparkApi.client
+end

data/lib/spark_api/cli/setup.rb~

@@ -0,0 +1,47 @@
+require "rubygems"
+require 'pp'
+require 'irb/ext/save-history'
+IRB.conf[:SAVE_HISTORY] = 1000
+IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.flexmls-api-history"
+
+if ENV["FLEXMLS_API_CONSOLE"].nil?
+  require 'flexmls_api'
+else
+  puts "Enabling console mode for local gem"
+  Bundler.require(:default, "development") if defined?(Bundler)
+  path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
+  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  require path + '/flexmls_api'
+end
+
+IRB.conf[:AUTO_INDENT]=true
+IRB.conf[:PROMPT][:FLEXMLS]= {
+  :PROMPT_I => "flexmlsApi:%03n:%i> ",
+  :PROMPT_S => "flexmlsApi:%03n:%i%l ",
+  :PROMPT_C => "flexmlsApi:%03n:%i* ",
+  :RETURN => "%s\n"
+} 
+
+IRB.conf[:PROMPT_MODE] = :FLEXMLS
+
+path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
+$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+require path + '/flexmls_api'
+
+module FlexmlsApi
+  def self.logger
+    if @logger.nil?
+      @logger = Logger.new(STDOUT)
+      @logger.level = ENV["DEBUG"].nil? ? Logger::WARN : Logger::DEBUG
+    end
+    @logger
+  end
+end
+
+FlexmlsApi.logger.info("Client configured!")
+
+include FlexmlsApi::Models
+
+def c
+  FlexmlsApi.client
+end

data/lib/spark_api/client.rb

@@ -0,0 +1,27 @@
+module SparkApi
+  # =API Client
+  # Main class to setup and run requests on the API.  A default client is accessible globally as 
+  # SparkApi::client if the global configuration has been set as well.  Otherwise, this class may 
+  # be instanciated separately with the configuration information.
+  class Client
+    include Connection
+    include Authentication
+    include Request
+    
+    attr_accessor :authenticator
+    attr_accessor *Configuration::VALID_OPTION_KEYS
+    
+    # Constructor bootstraps the client with configuration and authorization class.
+    # options - see Configuration::VALID_OPTION_KEYS
+    # auth_klass - subclass of Authentication::BaseAuth Defaults to the original api auth system.
+    def initialize(options={}, auth_klass=ApiAuth)
+      options = SparkApi.options.merge(options)
+      Configuration::VALID_OPTION_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+      # Instanciate the authenication class passed in.
+      @authenticator = authentication_mode.send("new", self)
+    end
+    
+  end
+end

data/lib/spark_api/configuration.rb

@@ -0,0 +1,54 @@
+module SparkApi
+  module Configuration
+    
+    # valid configuration options
+    VALID_OPTION_KEYS = [:api_key, :api_secret, :api_user, :endpoint, :user_agent, :version, :ssl, :oauth2_provider, :authentication_mode].freeze
+    OAUTH2_KEYS = [:authorization_uri, :access_uri, :client_id, :client_secret,
+      # Requirements for authorization_code grant type
+      :redirect_uri,  
+      # Requirements for password grant type
+      :username, :password
+    ]
+      
+    require File.expand_path('../configuration/yaml', __FILE__)
+    
+    DEFAULT_API_KEY = nil
+    DEFAULT_API_SECRET = nil
+    DEFAULT_API_USER = nil
+    DEFAULT_ENDPOINT = 'https://api.sparkapi.com'
+    DEFAULT_VERSION = 'v1'
+    DEFAULT_USER_AGENT = "Spark API Ruby Gem #{VERSION}"
+    DEFAULT_SSL = true
+    DEFAULT_OAUTH2 = nil
+    
+    X_SPARK_API_USER_AGENT = "X-SparkApi-User-Agent"
+
+    attr_accessor *VALID_OPTION_KEYS
+    def configure
+      yield self
+    end
+
+    def self.extended(base)
+      base.reset_configuration
+    end
+
+    def options
+      VALID_OPTION_KEYS.inject({}) do |opt,key|
+        opt.merge(key => send(key))
+      end
+    end
+
+    def reset_configuration
+      self.api_key     = DEFAULT_API_KEY
+      self.api_secret  = DEFAULT_API_SECRET
+      self.api_user    = DEFAULT_API_USER
+      self.authentication_mode = SparkApi::Authentication::ApiAuth
+      self.endpoint    = DEFAULT_ENDPOINT
+      self.oauth2_provider = DEFAULT_OAUTH2
+      self.user_agent  = DEFAULT_USER_AGENT
+      self.ssl         = DEFAULT_SSL
+      self.version     = DEFAULT_VERSION
+      self
+    end
+  end
+end

data/lib/spark_api/configuration.rb~

@@ -0,0 +1,54 @@
+module SparkApi
+  module Configuration
+    
+    # valid configuration options
+    VALID_OPTION_KEYS = [:api_key, :api_secret, :api_user, :endpoint, :user_agent, :version, :ssl, :oauth2_provider, :authentication_mode].freeze
+    OAUTH2_KEYS = [:authorization_uri, :access_uri, :client_id, :client_secret,
+      # Requirements for authorization_code grant type
+      :redirect_uri,  
+      # Requirements for password grant type
+      :username, :password
+    ]
+      
+    require File.expand_path('../configuration/yaml', __FILE__)
+    
+    DEFAULT_API_KEY = nil
+    DEFAULT_API_SECRET = nil
+    DEFAULT_API_USER = nil
+    DEFAULT_ENDPOINT = 'https://api.sparkapi.com'
+    DEFAULT_VERSION = 'v1'
+    DEFAULT_USER_AGENT = "Spark API Ruby Gem #{VERSION}"
+    DEFAULT_SSL = true #false
+    DEFAULT_OAUTH2 = nil
+    
+    X_SPARK_API_USER_AGENT = "X-SparkApi-User-Agent"
+
+    attr_accessor *VALID_OPTION_KEYS
+    def configure
+      yield self
+    end
+
+    def self.extended(base)
+      base.reset_configuration
+    end
+
+    def options
+      VALID_OPTION_KEYS.inject({}) do |opt,key|
+        opt.merge(key => send(key))
+      end
+    end
+
+    def reset_configuration
+      self.api_key     = DEFAULT_API_KEY
+      self.api_secret  = DEFAULT_API_SECRET
+      self.api_user    = DEFAULT_API_USER
+      self.authentication_mode = SparkApi::Authentication::ApiAuth
+      self.endpoint    = DEFAULT_ENDPOINT
+      self.oauth2_provider = DEFAULT_OAUTH2
+      self.user_agent  = DEFAULT_USER_AGENT
+      self.ssl         = DEFAULT_SSL
+      self.version     = DEFAULT_VERSION
+      self
+    end
+  end
+end