Module: Arcus::Api

Included in:

Cli

Defined in:

lib/arcus/api.rb

Defined Under Namespace

Classes: Action, Request, Scope, Settings, Target

Constant Summary

@@targets =

[]

@@settings =

Settings.new

Class Method Summary

• .configure {|self.settings| ... } ⇒ Object
• .load_config_file(api_xml) ⇒ Object
• .parse_action(name) ⇒ Object
• .settings ⇒ Object
• .settings=(val) ⇒ Object
• .targets ⇒ Object

Instance Method Summary

• #scoped(options = {}) {|Scope.new(options = {})| ... } ⇒ Object

Class Method Details

.configure {|self.settings| ... } ⇒ Object

Yields:

• (self.settings)

# File 'lib/arcus/api.rb', line 203

def self.configure
  Arcus.log = Logger.new(STDOUT)
  Arcus.log.level = Logger::DEBUG
  Arcus.log.formatter = proc do |severity, datetime, progname, msg|
    "#{severity} - #{datetime}: #{msg}\n"
  end

  yield(self.settings)

  self.settings.api_xml || (raise ArgumentError, "api_xml file: commands.xml file location required")
  self.settings.api_uri || (raise ArgumentError, "api_uri: URI of API required")

  api_config = self.load_config_file(self.settings.api_xml)

  api_config["commands"]["command"].each do |c|
    command_name = c["name"]
    command_desc = c["description"]
    command_async = c["isAsync"] == "true" ? true : false

    action, target = parse_action(command_name)

    if c["request"] != nil
      all_args = c["request"]["arg"] || []
    else
      all_args = []
    end

    if all_args.is_a?(Hash)
      all_args = [all_args]
    end
    all_args.push({"name" => "response", "description" => "valid response types are yaml, xml, prettyxml, json, prettyjson (json is default)", "required" => "false"})

    required_args = all_args.select { |a| a["required"] == "true" }
    optional_args = all_args.select { |a| a["required"] == "false" }

    def self.class_exists?(class_name)
      c = self.const_get(class_name)
      return c.is_a?(Class)
    rescue NameError
      return false
    end

    def self.get_class(class_name)
      self.const_get(class_name)
    end

    def self.create_class(class_name, superclass, &block)
      c = Class.new superclass, &block
      self.const_set class_name, c
      c
    end

    if !self.class_exists?(target)
      target_clazz = self.create_class(target, Target) do
        cattr_accessor :actions
        self.actions = []
      end
      @@targets << target_clazz

    else
      target_clazz = self.get_class(target)
    end

    target_clazz.class_eval do

      if !class_exists?(action.capitalize)
        action_clazz = create_class(action.capitalize, Action) do
          cattr_accessor :name, :description, :is_async,
                         :required_args, :optional_args,
                         :action_name, :sync

          self.name = command_name
          self.description = command_desc
          self.action_name = action
          self.required_args = required_args
          self.optional_args = optional_args
          self.is_async = command_async
          self.sync = false

          def prepare!(params = {}, callbacks = {})
            check_args(params, all_names, required_names)
            prepare(params, callbacks)
          end

          def prepare(params = {}, callbacks = {})
            params[:response] ||= Arcus::Api.settings.default_response
            Request.new(self.name, params, callbacks)
          end
        end
        target_clazz.actions << action_clazz

        target_clazz.instance_eval do
          define_method(action.to_sym) do |params = {}, callbacks = {}|
              action_clazz.new.prepare(params, callbacks)
          end
          define_method("#{action}!".to_sym) do |params = {}, callbacks = {}|
              action_clazz.new.prepare(params, callbacks)
          end
        end
      end
    end
  end
end

.load_config_file(api_xml) ⇒ Object

# File 'lib/arcus/api.rb', line 179

def self.load_config_file(api_xml)
  contents = File.read(api_xml).to_s
  md5 = Digest::MD5.hexdigest(contents)
  api_xml_basename = File.basename(api_xml)
  md5_file = Dir::home() + "/.#{api_xml_basename}.md5"
  cache_file = Dir::home() + "/.#{api_xml_basename}.cache"
  if File::exists?(md5_file) && File::read(md5_file).to_s == md5 && File::exists?(cache_file)
    config = Marshal.restore(File::read(cache_file))
  else
    config = Nori.parse(contents)
    File::open(md5_file, "w+") do |file|
      file.print md5
    end
    File::open(cache_file, "w+") do |file|
      file.print Marshal.dump(config)
    end
  end
  config
end

.parse_action(name) ⇒ Object

# File 'lib/arcus/api.rb', line 172

def self.parse_action(name)
  action, target = name.split(/([A-Z].*)/, 2)
  target = "User" if %w(login logout).include?(action)
  target = target.singularize
  [action, target]
end

.settings ⇒ Object

# File 'lib/arcus/api.rb', line 39

def self.settings
  @@settings
end

.settings=(val) ⇒ Object

# File 'lib/arcus/api.rb', line 43

def self.settings=(val)
  @@settings = val
end

.targets ⇒ Object

# File 'lib/arcus/api.rb', line 47

def self.targets
  @@targets
end

Instance Method Details

#scoped(options = {}) {|Scope.new(options = {})| ... } ⇒ Object

Yields:

• (Scope.new(options = {}))

# File 'lib/arcus/api.rb', line 199

def scoped(options = {})
  yield Scope.new(options = {})
end