davetron5000-gliffy 0.1.1

data/README.rdoc

@@ -0,0 +1,52 @@
+<em>The Gliffy API is currently in private beta.  This will be a Ruby implementation to access your Gliffy account.</em>
+
+This consists of a Ruby client for Gliffy as well as a simple command line tool to access your Gliffy account using that client.
+
+== Client Library
+
+Main entry point is Gliffy::Handle, though you should look at Gliffy::Config for configuration options.  Here's an example of getting the list of diagrams and then downloading the first one as a JPEG
+
+    require 'gliffy'
+
+    Gliffy::Config.config.api_key='aa9d0e8d-449b-44ad-904a-bf87deb7c403'
+    Gliffy::Config.config.secret_key='a52585f7-5952-4229-8bbe-b5787521b571'
+    Gliffy::Config.config.account_name='Initech'
+
+    handle = Gliffy::Handle.new('lumberg@initech.com')
+
+    diagrams = handle.get_diagrams
+    diagram_name_safe = diagrams[0].name.gsub(/ /,'_')
+    handle.get_diagram_as_image(diagrams[0].id,:mime_type => :jpeg,:file=>"#{diagram_name_safe}.jpg")
+
+The Gliffy::Handle is a <b>user-session based connection</b> to Gliffy.  You shoudl therefore engineer your application to keep one of these per user who will access Gliffy and *not* make a global instance.
+
+* RDoc is available a http://davetron5000.github.com/gliffy
+* Source is available at http://github.com/davetron5000/gliffy/tree/master
+
+== Command Line Client
+
++gliffy+ +help+ shows a list of commands.  Currently, there are:
+
+[+delete+] Delete a diagram (also: del,rm)
+[+edit+]   Edit a diagram 
+[+get+]    Download a diagram as an image to a file 
+[+help+]   Show commands 
+[+list+]   List all diagrams in the account (also: ls)
+[+new+]    Create a new diagram 
+[+url+]    Get the URL for an image 
+
+=== Configuration
+
+The first time you run the client, it will create a base configuration in your home directory called <tt>.gliffyrc</tt>, and will ask you to provide it with four pieces of information:
+
+[API Key] This is the API Key given to you by Gliffy
+[Secret Key] This is the Secret Key given to you by Gliffy.  <b>Do not check this value into source control</b>
+[Account Name] Your account's name.  This should've been provided with your API Key
+[Username] The username to work under.  The command line client only allows single-user access to your Gliffy account.  If you just signed up for Gliffy, this is probably the email address you used to sign up
+
+If you are not on OS X, you will want to configure two other options, and you can do this by editing your <tt>.gliffyrc</tt> directly:
+
+[<tt>open_image</tt>] Configures the command for opening an image from the command line.  This should be a string of the form <tt>command %s</tt> where <tt>%s</tt> will be replaced with the name of the image file to open.
+[<tt>open_url</tt>] Configures the command for opening an url from the command line.  This should be a string of the form <tt>command %s</tt> where <tt>%s</tt> will be replaced with the name of the url to open.
+
+The other options are all documented in Gliffy::Config.  Note that your most previously received user token is stored here as well, to keep from getting it every time the client is run.

data/bin/gliffy

@@ -0,0 +1,8 @@
+#!/usr/bin/ruby
+#
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib') 
+$: << File.expand_path(File.dirname(__FILE__) + '/../ext') 
+
+require 'gliffy/cli'
+
+Gliffy::Command.execute(ARGV)

data/ext/array_has_response.rb

@@ -0,0 +1,10 @@
+
+class Array
+
+  def success?; @success; end
+  def success=(success); @success = success; end
+
+  def not_modified?; @not_modified; end
+  def not_modified=(not_modified); @not_modified = not_modified; end
+
+end

data/lib/gliffy.rb

@@ -0,0 +1 @@
+require 'gliffy/gliffy'

data/lib/gliffy/account.rb

@@ -0,0 +1,55 @@
+require 'rexml/document'
+require 'array_has_response'
+require 'gliffy/rest'
+
+include REXML
+
+module Gliffy
+
+  # Represents on account
+  class Account < Response
+
+    attr_reader :name
+    attr_reader :id
+    # Either :basic or :premium
+    attr_reader :type
+    attr_reader :max_users
+    # A Time representing the date on which this account expires
+    attr_reader :expiration_date
+
+    attr_reader :users
+
+    def self.from_xml(element)
+      id = element.attributes['id'].to_i
+      type = element.attributes['account-type']
+      if type == 'Basic'
+        type = :basic
+      elsif type == 'Premium'
+        type = :premium
+      else
+        raise "Unknown type #{type}"
+      end
+      max_users = element.attributes['max-users'].to_i
+      expiration_date = Time.at(element.elements['expiration-date'].text.to_i / 1000)
+      name = element.elements['name'].text
+      users = Users.from_xml(element.elements['users'])
+
+      Account.new(id,type,name,max_users,expiration_date,users)
+    end
+
+    protected
+
+    def initialize(id,type,name,max_users,expiration_date,users=nil)
+      super()
+      @id = id
+      @type = type
+      @name = name
+      @max_users = max_users
+      @expiration_date = expiration_date
+      @users = users
+    end
+
+  end
+
+  class Accounts < ArrayResponseParser; end
+end

data/lib/gliffy/cli.rb

@@ -0,0 +1,260 @@
+$:.unshift File.dirname(__FILE__)
+require 'fileutils'
+require 'yaml'
+require 'gliffy'
+require 'logger'
+
+module Gliffy
+  extend self
+
+  # A command line option to the gliffy command line client
+  class Command
+
+    # Global flags
+    GLOBAL_FLAGS = {
+      '-v' => 'be more verbose (overrides config)',
+    }
+    
+    # Global access to all configured commands
+    def self.commands
+      @@commands ||= {}
+    end
+
+    def self.aliases
+      @@aliases ||= {}
+    end
+
+    # The name of the command
+    attr_reader :name
+    # a short description
+    attr_reader :description
+    # a usage statement
+    attr_reader :usage
+
+    # Create a new command
+    #
+    # [+name+] the name of the command (should be short, no spaces)
+    # [+description+] short description of the command
+    # [+offline+] true if this command doesn't require a connection to Gliffy
+    # [+usage+] usage statement
+    # [+block+] A block that represents the command itself.  This block will take  the gliffy handle and the args array as arguments *or* just the arguments if it is an "offline"
+    # command
+    def initialize(name,description,offline,usage,block)
+      @name = name
+      @description = description
+      @block = block
+      @offline = offline
+      @usage = usage ? usage : ""
+    end
+
+    # Runs the command with the given arguments
+    def run(args)
+      if (@offline)
+        @block.call(args)
+      else
+        previous_token = CLIConfig.instance.config[:current_token]
+        handle = Gliffy::Handle.new(CLIConfig.instance.config[:username],previous_token)
+        @block.call(handle,args)
+        CLIConfig.instance.config[:current_token] = handle.current_token
+        CLIConfig.instance.save
+      end
+    end
+
+    # Executes the command line that was given
+    def self.execute(argv)
+      globals = Hash.new
+      command = argv.shift
+      while !command.nil? && (command =~ /^-/) && !argv.empty?
+        globals[command] = true
+        command = argv.shift
+      end 
+      Gliffy::Config.config.log_level = Logger::DEBUG if globals['-v']
+      cmd = Gliffy::Command.commands[command.to_sym]
+      if cmd
+        cmd.run argv
+      else
+        puts "Unknown command #{command}"
+        Gliffy::Command.commands[:help].run []
+      end
+    end
+  end
+
+  # Represents the configuration for the command line client.
+  # This is a singleton
+  class CLIConfig
+
+    @@instance = nil
+
+    # Access to the singleton
+    def self.instance 
+      @@instance = CLIConfig.new if !@@instance
+      @@instance
+    end
+
+    # Returns the config hash
+    attr_reader :config
+
+    # Loads the user's rc file if it exists, creating it if not
+    def load
+      if !File.exist?(@config_file_name)
+        puts "#{@config_file_name} not found.  Create? [y/n]"
+        answer = STDIN.gets
+        if answer =~ /^[Yy]/
+          save
+        else
+          puts "Aborting..."
+          return false
+        end
+      end
+      yaml_config = File.open(@config_file_name) { |file| YAML::load(file) }
+      if (yaml_config)
+        @config = yaml_config
+      end
+      @config[:open_url] = default_open_url if !@config[:open_url]
+      @config[:open_image] = default_open_image if !@config[:open_image]
+      read_config_from_user('API Key',:api_key)
+      read_config_from_user('Secret Key',:secret_key)
+      read_config_from_user('Account Name',:account_name)
+      read_config_from_user('Username',:username)
+      save
+      config = Gliffy::Config.config
+      @config.each() do |key,value|
+        method = key.to_s + "="
+        if config.respond_to? method.to_sym
+          if (method == 'log_device=')
+            if (value == 'STDERR')
+              config.log_device = STDERR
+            elsif (value == 'STDOUT')
+              config.log_device = STDOUT
+            else
+              config.log_device = value
+            end
+          else
+            config.send(method.to_sym,value)
+          end
+        end
+      end
+    end
+
+    # Saves the configration to the user's config file name as YAML
+    def save
+      fp = File.open(@config_file_name,'w') { |out| YAML::dump(@config,out) }
+    end
+
+    private
+    def read_config_from_user(name,symbol)
+      if (!@config[symbol])
+        puts "No #{name} configured.  Enter #{name}"
+        @config[symbol] = STDIN.gets.chomp!
+      end
+    end
+
+    def initialize
+      @config_file_name = File.expand_path("~/.gliffyrc")
+      @config = {
+        :log_level => Gliffy::Config.config.log_level,
+        :log_device => Gliffy::Config.config.log_device.to_s,
+        :gliffy_app_root => Gliffy::Config.config.gliffy_app_root,
+        :gliffy_rest_context => Gliffy::Config.config.gliffy_rest_context,
+        :protocol => Gliffy::Config.config.protocol,
+      }
+    end
+
+    def default_open_url
+      # Cheesy defaults
+      if RUBY_PLATFORM =~ /win32/
+        # not sure, acutally
+        nil
+      elsif RUBY_PLATFORM =~ /linux/
+        'firefox "%s"'
+      elsif RUBY_PLATFORM =~ /darwin/
+        'open "%s"'
+      else
+        nil
+      end
+    end
+
+    def default_open_image
+      # Cheesy defaults
+      if RUBY_PLATFORM =~ /win32/
+        # not sure, acutally
+        nil
+      elsif RUBY_PLATFORM =~ /linux/
+        # not sure
+        nil
+      elsif RUBY_PLATFORM =~ /darwin/
+        'open "%s"'
+      else
+        nil
+      end
+    end
+
+
+  end
+
+  # For defining commands, this specifies the description of the next command defined
+  def desc(description)
+    @next_desc = description
+  end
+
+  # For defining commands, this specifies if the next defined command is "offline"
+  def offline(bool)
+    @next_offline = bool
+  end
+
+  # For defining commands, specifies the usage statement of the next command
+  def usage(usage='')
+    @next_usage = usage
+  end
+
+  # defines a command.  The only options supported is ":aliases" which is an array of aliases
+  # for the command
+  def command(name,options={},&block)
+    Command.commands[name] = Command.new(name,@next_desc,@next_offline,@next_usage,block)
+    if options[:aliases]
+      options[:aliases].each() do |a|
+        Command.commands[a] = Command.commands[name]
+        Command.aliases[a] = true
+      end
+    end
+    @next_usage = nil
+    @next_offline = false
+    @next_desc = nil
+  end
+
+  def parse_options(args)
+    options = Hash.new
+    return options if !args
+    i = 0
+    while i < args.length
+      inc = 2
+      if args[i] =~ /^-/
+        arg = args[i].gsub(/^-/,'')
+        if !args[i+1] || (args[i+1] =~ /^-/)
+          inc = 1
+          options[arg] = true
+        else
+          options[arg] = args[i+1]
+        end
+      else
+        break
+      end
+      i += inc
+    end
+    i.times { args.shift }
+    options
+  end
+
+  def format_date(date)
+    date.strftime('%m/%d/%y %H:%M')
+  end
+
+end
+
+include Gliffy
+require 'gliffy/commands/commands'
+if !CLIConfig.instance.load
+  exit -1
+end
+
+

data/lib/gliffy/commands/commands.rb

@@ -0,0 +1,149 @@
+desc 'List all diagrams in the account'
+usage <<eos
+[-l]
+
+  -l - show all information
+eos
+command :list, :aliases => [:ls] do |gliffy,args|
+  diagrams = gliffy.get_diagrams
+  options = parse_options(args)
+  if options['l']
+    max = diagrams.inject(0) { |max,diagram| diagram.name.length > max ? diagram.name.length : max }
+    diagrams.sort.each do |diagram|
+      printf "%8d %s %-#{max}s %-3d %s  %s %s\n",
+        diagram.id,
+        diagram.is_public? ? "P" : "-",
+        diagram.name,
+        diagram.num_versions,
+        format_date(diagram.create_date),
+        format_date(diagram.mod_date),
+        diagram.owner_username
+    end
+  else
+    printf_string = "%d %s\n"
+    diagrams.sort.each { |diagram| printf printf_string,diagram.id,diagram.name }
+  end
+end
+
+desc 'Delete a diagram'
+usage 'diagram_id'
+command :delete, :aliases => [:del,:rm] do |gliffy,args|
+  gliffy.delete_diagram(args[0])
+end
+
+desc 'Get the URL for an image'
+usage <<eos
+[-o] diagram_id
+
+  -o - open diagram's URL with configured :open_url command
+eos
+command :url do |gliffy,args|
+  open = args[0] == '-o'
+  args.shift if open
+  url = gliffy.get_diagram_as_url(args[0])
+  if open
+    if CLIConfig.instance.config[:open_image]
+      system(sprintf(CLIConfig.instance.config[:open_image],url))
+    else
+      puts "Nothing configured for #{:open_image.to_s} to open the image"
+      puts url
+    end
+  else
+    puts url
+  end
+end
+
+desc 'Download a diagram as an image to a file'
+usage <<eos 
+[-v version_num] [-f filename] [-t image_type] diagram_id
+
+   image_type can be :jpeg, :png, :svg, or :xml
+eos
+command :get do |gliffy,args|
+
+  options = parse_options(args)
+  diagram_id = args.shift
+
+  version_number = options['v'].to_i if options['v']
+  filename = options['f'] if options['f']
+  type = options['t'].to_sym if options['t']
+  type = :jpeg if !type
+  if !filename
+    if version_number
+      filename = "#{diagram_id}_v#{version_number}.#{type.to_s}"
+    else
+      filename = "#{diagram_id}.#{type.to_s}"
+    end
+  end
+
+  get_options = { :mime_type => type, :file => filename }
+  get_options[:version] = version_number if version_number
+  gliffy.get_diagram_as_image(diagram_id,get_options)
+  puts filename
+end
+
+desc 'Edit a diagram'
+usage 'diagram_id'
+command :edit do |gliffy,args|
+  return_link = gliffy.get_diagram_as_url(args[0])
+  link = gliffy.get_edit_diagram_link(args[0],return_link,"Done")
+  if CLIConfig.instance.config[:open_url]
+    system(sprintf(CLIConfig.instance.config[:open_url],link.full_url))
+  else
+    puts "Nothing configured for #{:open_url.to_s} to open the url"
+    puts link.full_url
+  end
+end
+
+desc 'Create a new diagram'
+usage <<eos
+[-e] diagram_name
+
+  -e edit the diagram after creating it
+eos
+command :new do |gliffy,args|
+  edit = args[0] == '-e'
+  args.shift if edit
+  diagram = gliffy.create_diagram(args[0])
+  if edit
+    Gliffy::Command.commands[:edit].run [diagram.id]
+  else
+    puts "#{diagram.name} created with id #{diagram.id}"
+  end
+end
+
+desc 'Show commands'
+offline true
+usage 'command'
+command :help do |args|
+  if args[0]
+    command = Command.commands[args[0].to_sym]
+    if command
+      printf "%s - %s\n",args[0],command.description
+      printf "usage: %s %s\n",args[0],command.usage
+    else
+      puts "No such command #{args[0]}"
+    end
+  else
+    command_string = "   %-6s   %s %s\n"
+    puts 'usage: gliffy [global_options] command [command_options]'
+    puts 'global_options:'
+    Command::GLOBAL_FLAGS.keys.sort.each do |flag|
+      printf command_string,flag,Command::GLOBAL_FLAGS[flag],''
+    end
+    puts
+    puts 'command:'
+    command_names = Command.commands.keys.sort { |a,b| a.to_s <=> b.to_s }
+    command_names.each() do |name|
+      command = Command.commands[name]
+      if !Command.aliases[name]
+        aliases = Array.new
+        Command.aliases.keys.each() do |a| 
+          aliases << a if Command.commands[a] == command 
+        end
+        alias_string = '(also: ' + aliases.join(',') + ')' if aliases.length > 0
+        printf command_string,name.to_s, command.description,alias_string
+      end
+    end
+  end
+end