xively-cli 0.0.9

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © Heroku 2008 - 2012
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# Xively CLI
+
+A Xively client tool
+
+[![Build Status](https://secure.travis-ci.org/levent/xively-cli.png)](http://travis-ci.org/levent/xively-cli)
+[![Dependency Status](https://gemnasium.com/levent/xively-cli.png)](https://gemnasium.com/levent/xively-cli)
+[![Coverage Status](https://coveralls.io/repos/levent/xively-cli/badge.png)](https://coveralls.io/r/levent/xively-cli)
+
+## Installation
+
+```bash
+gem install xively
+```
+
+## Usage
+
+### Connect to the socket server
+
+You can connect to a feed or datastream and receive realtime json updates in your terminal
+
+```bash
+xively subscribe -k YOUR_API_KEY -f FEED_ID -d DATASTREAM_ID
+```
+

data/bin/xively

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+begin
+  # resolve bin path, ignoring symlinks
+  require "pathname"
+  bin_file = Pathname.new(__FILE__).realpath
+
+  # add self to libpath
+  $:.unshift File.expand_path("../../lib", bin_file)
+
+  # start up the CLI
+  require "xively-cli"
+  Xively::CLI.start(*ARGV)
+rescue Interrupt
+  `stty icanon echo`
+  puts("\n !    Command cancelled.")
+end

data/lib/xively-cli.rb

@@ -0,0 +1,13 @@
+require "xively-cli/command"
+
+module Xively
+  class CLI
+
+    def self.start(*args)
+      command = args.shift.strip rescue "help"
+      Xively::Command.load
+      Xively::Command.run(command, args)
+    end
+
+  end
+end

data/lib/xively-cli/command.rb

@@ -0,0 +1,168 @@
+require 'xively-cli/version'
+require "optparse"
+
+module Xively
+  module Command
+    class CommandFailed  < RuntimeError; end
+
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+        require file
+      end
+    end
+
+    def self.commands
+      @@commands ||= {}
+    end
+
+    def self.command_aliases
+      @@command_aliases ||= {}
+    end
+
+    def self.files
+      @@files ||= Hash.new {|hash,key| hash[key] = File.readlines(key).map {|line| line.strip}}
+    end
+
+    def self.namespaces
+      @@namespaces ||= {}
+    end
+
+    def self.register_command(command)
+      commands[command[:command]] = command
+    end
+
+    def self.register_namespace(namespace)
+      namespaces[namespace[:name]] = namespace
+    end
+
+    def self.current_command
+      @current_command
+    end
+
+    def self.current_command=(new_current_command)
+      @current_command = new_current_command
+    end
+
+    def self.global_options
+      @global_options ||= []
+    end
+
+    def self.invalid_arguments
+      @invalid_arguments
+    end
+
+    def self.shift_argument
+      @invalid_arguments.shift rescue nil
+    end
+
+    def self.validate_arguments!
+      unless invalid_arguments.empty?
+        arguments = invalid_arguments.map {|arg| "\"#{arg}\""}
+        if arguments.length == 1
+          message = "Invalid argument: #{arguments.first}"
+        elsif arguments.length > 1
+          message = "Invalid arguments: "
+          message << arguments[0...-1].join(", ")
+          message << " and "
+          message << arguments[-1]
+        end
+        $stderr.puts(message)
+        run(current_command, ["--help"])
+        exit(1)
+      end
+    end
+
+    def self.warnings
+      @warnings ||= []
+    end
+
+    def self.display_warnings
+      unless warnings.empty?
+        $stderr.puts(warnings.map {|warning| " !    #{warning}"}.join("\n"))
+      end
+    end
+
+    def self.global_option(name, *args, &blk)
+      global_options << { :name => name, :args => args, :proc => blk }
+    end
+
+    global_option :key, "--key API_KEY", "-k"
+    global_option :help,    "--help", "-h"
+
+    def self.prepare_run(cmd, args=[])
+      command = parse(cmd)
+
+      unless command
+        if %w( -v --version ).include?(cmd)
+          command = parse('version')
+        else
+          $stderr.puts(["`#{cmd}` is not a xively command.", "See `xively help` for a list of available commands."].join("\n"))
+          exit(1)
+        end
+      end
+
+      @current_command = cmd
+
+      opts = {}
+      invalid_options = []
+
+      parser = OptionParser.new do |parser|
+        # overwrite OptionParsers Officious['version'] to avoid conflicts
+        # see: https://github.com/ruby/ruby/blob/trunk/lib/optparse.rb#L814
+        parser.on("--version") do |value|
+          invalid_options << "--version"
+        end
+        global_options.each do |global_option|
+          parser.on(*global_option[:args]) do |value|
+            global_option[:proc].call(value) if global_option[:proc]
+            opts[global_option[:name]] = value
+          end
+        end
+        command[:options].each do |name, option|
+          parser.on("-#{option[:short]}", "--#{option[:long]}", option[:desc]) do |value|
+            opts[name.gsub("-", "_").to_sym] = value
+          end
+        end
+      end
+
+      begin
+        parser.order!(args) do |nonopt|
+          invalid_options << nonopt
+        end
+      rescue OptionParser::InvalidOption => ex
+        invalid_options << ex.args.first
+        retry
+      end
+
+      if opts[:help]
+        args.unshift cmd unless cmd =~ /^-.*/
+        cmd = "help"
+        command = parse(cmd)
+      end
+
+      args.concat(invalid_options)
+
+      @current_args = args
+      @current_options = opts
+      @invalid_arguments = invalid_options
+
+      [ command[:klass].new(args.dup, opts.dup), command[:method] ]
+    end
+
+    def self.run(cmd, arguments=[])
+      object, method = prepare_run(cmd, arguments.dup)
+      object.send(method)
+    rescue CommandFailed => e
+      $stderr.puts e.message
+    rescue OptionParser::ParseError
+      commands[cmd] ? run("help", [cmd]) : run("help")
+    ensure
+      display_warnings
+    end
+
+    def self.parse(cmd)
+      commands[cmd] || commands[command_aliases[cmd]]
+    end
+
+  end
+end

data/lib/xively-cli/command/base.rb

@@ -0,0 +1,148 @@
+require "fileutils"
+require "xively-cli/command"
+
+class Xively::Command::Base
+
+  def self.namespace
+    self.to_s.split("::").last.downcase
+  end
+
+  attr_reader :args
+  attr_reader :options
+
+  def initialize(args=[], options={})
+    @args = args
+    @options = options
+  end
+
+protected
+
+  def self.inherited(klass)
+    unless klass == Xively::Command::Base
+      help = extract_help_from_caller(caller.first)
+
+      Xively::Command.register_namespace(
+        :name => klass.namespace,
+        :description => help.first
+      )
+    end
+  end
+
+  def self.method_added(method)
+    return if self == Xively::Command::Base
+    return if private_method_defined?(method)
+    return if protected_method_defined?(method)
+
+    help = extract_help_from_caller(caller.first)
+    resolved_method = (method.to_s == "index") ? nil : method.to_s
+    command = [ self.namespace, resolved_method ].compact.join(":")
+    banner = extract_banner(help) || command
+
+    Xively::Command.register_command(
+      :klass       => self,
+      :method      => method,
+      :namespace   => self.namespace,
+      :command     => command,
+      :banner      => banner.strip,
+      :help        => help.join("\n"),
+      :summary     => extract_summary(help),
+      :description => extract_description(help),
+      :options     => extract_options(help)
+    )
+  end
+
+  def self.alias_command(new, old)
+    raise "no such command: #{old}" unless Xively::Command.commands[old]
+    Xively::Command.command_aliases[new] = old
+  end
+
+  #
+  # Parse the caller format and identify the file and line number as identified
+  # in : http://www.ruby-doc.org/core/classes/Kernel.html#M001397.  This will
+  # look for a colon followed by a digit as the delimiter.  The biggest
+  # complication is windows paths, which have a color after the drive letter.
+  # This regex will match paths as anything from the beginning to a colon
+  # directly followed by a number (the line number).
+  #
+  def self.extract_help_from_caller(line)
+    # pull out of the caller the information for the file path and line number
+    if line =~ /^(.+?):(\d+)/
+      extract_help($1, $2)
+    else
+      raise("unable to extract help from caller: #{line}")
+    end
+  end
+
+  def self.extract_help(file, line_number)
+    buffer = []
+    lines = Xively::Command.files[file]
+
+    (line_number.to_i-2).downto(0) do |i|
+      line = lines[i]
+      case line[0..0]
+        when ""
+        when "#"
+          buffer.unshift(line[1..-1])
+        else
+          break
+      end
+    end
+
+    buffer
+  end
+
+  def self.extract_banner(help)
+    help.first
+  end
+
+  def self.extract_summary(help)
+    extract_description(help).split("\n")[2].to_s.split("\n").first
+  end
+
+  def self.extract_description(help)
+    help.reject do |line|
+      line =~ /^\s+-(.+)#(.+)/
+    end.join("\n")
+  end
+
+  def self.extract_options(help)
+    help.select do |line|
+      line =~ /^\s+-(.+)#(.+)/
+    end.inject({}) do |hash, line|
+      description = line.split("#", 2).last
+      long  = line.match(/--([A-Za-z\- ]+)/)[1].strip
+      short = line.match(/-([A-Za-z ])[ ,]/) && $1 && $1.strip
+      hash.update(long.split(" ").first => { :desc => description, :short => short, :long => long })
+    end
+  end
+
+  def current_command
+    Xively::Command.current_command
+  end
+
+  def extract_option(key)
+    options[key.dup.gsub('-','').to_sym]
+  end
+
+  def invalid_arguments
+    Xively::Command.invalid_arguments
+  end
+
+  def shift_argument
+    Xively::Command.shift_argument
+  end
+
+  def validate_arguments!
+    Xively::Command.validate_arguments!
+  end
+
+  def escape(value)
+    xively.escape(value)
+  end
+end
+
+module Xively::Command
+  unless const_defined?(:BaseWithApp)
+    BaseWithApp = Base
+  end
+end

data/lib/xively-cli/command/feeds.rb

@@ -0,0 +1,46 @@
+require 'xively-cli/command/base'
+require 'xively-rb'
+
+# Create a Xively feed
+#
+class Xively::Command::Feeds < Xively::Command::Base
+
+  # feeds:create [TITLE]
+  #
+  # create a Xively feed
+  #
+  # -k, --key API_KEY     # your api key
+  #
+  #Examples:
+  #
+  # $ xively feeds:create "Home energy monitor" -k ABCD1234
+  #
+  def create
+    title = shift_argument
+    api_key = options[:key]
+    validate_arguments!
+
+    if title.nil?
+      $stderr.puts "Please provide a title"
+      exit(1)
+    end
+
+    if api_key.nil?
+      $stderr.puts Xively::Command::Help.usage_for_command("feeds:create")
+      exit(1)
+    end
+
+    puts "Creating feed \"#{title}\"..."
+
+    feed = Xively::Feed.new
+    feed.title = title
+
+    response = Xively::Client.post('/v2/feeds.json', :headers => {'X-ApiKey' => api_key}, :body => feed.to_json)
+    if response.code == 201
+      puts "Your feed has been created at:"
+      puts response.headers['location']
+    end
+  end
+
+  alias_command "create", "feeds:create"
+end

data/lib/xively-cli/command/help.rb

@@ -0,0 +1,121 @@
+# list commands and display help
+#
+class Xively::Command::Help < Xively::Command::Base
+
+  PRIMARY_NAMESPACES = %w( subscribe )
+
+  # help [COMMAND]
+  #
+  # list available commands or display help for a specific command
+  #
+  #Examples:
+  #
+  # $ xively help
+  # Usage: xively COMMAND [--key API_KEY] [command-specific-options]
+  #
+  # Primary help topics, type "xively help TOPIC" for more details:
+  #
+  #   subscribe    #  subscribe to a datastream
+  #   ...
+  #
+  def index
+    if command = args.shift
+      help_for_command(command)
+    else
+      help_for_root
+    end
+  end
+
+  alias_command "-h", "help"
+  alias_command "--help", "help"
+
+  def self.usage_for_command(command)
+    command = new.send(:commands)[command]
+    "Usage: xively #{command[:help]}" if command
+  end
+
+private
+
+  def commands_for_namespace(name)
+    Xively::Command.commands.values.select do |command|
+      command[:namespace] == name && command[:command] != name
+    end
+  end
+
+  def namespaces
+    namespaces = Xively::Command.namespaces
+    namespaces.delete("app")
+    namespaces
+  end
+
+  def commands
+    Xively::Command.commands
+  end
+
+  def primary_namespaces
+    PRIMARY_NAMESPACES.map { |name| namespaces[name] }.compact
+  end
+
+  def additional_namespaces
+    (namespaces.values - primary_namespaces)
+  end
+
+  def summary_for_namespaces(namespaces)
+    size = (namespaces.map { |n| n[:name] }).map { |i| i.to_s.length }.sort.last
+    namespaces.sort_by {|namespace| namespace[:name]}.each do |namespace|
+      name = namespace[:name]
+      namespace[:description]
+      puts "  %-#{size}s  # %s" % [ name, namespace[:description] ]
+    end
+  end
+
+  def help_for_root
+    puts "Usage: xively COMMAND [--key API_KEY] [command-specific-options]"
+    puts
+    puts "Primary help topics, type \"xively help TOPIC\" for more details:"
+    puts
+    summary_for_namespaces(primary_namespaces)
+    puts
+    puts "Additional topics:"
+    puts
+    summary_for_namespaces(additional_namespaces)
+    puts
+  end
+
+  def help_for_namespace(name)
+    namespace_commands = commands_for_namespace(name)
+
+    unless namespace_commands.empty?
+      size = (namespace_commands.map { |c| c[:banner] }).map { |i| i.to_s.length }.sort.last
+      namespace_commands.sort_by { |c| c[:banner].to_s }.each do |command|
+        next if command[:help] =~ /DEPRECATED/
+        command[:summary]
+        puts "  %-#{size}s  # %s" % [ command[:banner], command[:summary] ]
+      end
+    end
+  end
+
+  def help_for_command(name)
+    if command_alias = Xively::Command.command_aliases[name]
+      puts("Alias: #{name} is short for #{command_alias}")
+      name = command_alias
+    end
+    if command = commands[name]
+      puts "Usage: xively #{command[:banner]}"
+
+      if command[:help].strip.length > 0
+        puts command[:help].split("\n")[1..-1].join("\n")
+      end
+      puts
+    end
+
+    if commands_for_namespace(name).size > 0
+      puts "Additional commands, type \"xively help COMMAND\" for more details:"
+      puts
+      help_for_namespace(name)
+      puts
+    elsif command.nil?
+      puts "#{name} is not a xively command. See `xively help`."
+    end
+  end
+end

data/lib/xively-cli/command/subscribe.rb

@@ -0,0 +1,70 @@
+require 'xively-cli/command/base'
+require 'socket'
+
+# Subscribe to a feed or datastream via the Xively Socket Server
+#
+class Xively::Command::Subscribe < Xively::Command::Base
+
+  # subscribe
+  #
+  # connect to a tcp socket for a feed or datastream
+  #
+  # -k, --key API_KEY        # your api key
+  # -f, --feed FEED          # the feed id
+  # -d, --datastream DATASTREAM  # the datastream id (optional)
+  #
+  #Example:
+  #
+  # $ xively subscribe -k ABCD1234 -f 504 -d 0 # subscribe to datastream
+  # $ xively subscribe -k ABCD1234 -f 504 # subscribe to feed
+  #
+  def index
+    api_key = options[:key]
+    feed_id = options[:feed]
+    datastream_id = options[:datastream]
+
+    validate_arguments!
+
+    unless api_key && feed_id
+      $stderr.puts Xively::Command::Help.usage_for_command("subscribe")
+      exit(1)
+    end
+
+    resource = "/feeds/#{feed_id}"
+    resource += "/datastreams/#{datastream_id}" if datastream_id
+
+    puts "Subscribing to updates for #{resource}"
+
+    subscribe = "{\"method\":\"subscribe\", \"resource\":\"#{resource}\", \"headers\":{\"X-ApiKey\":\"#{api_key}\"}}"
+    s = TCPSocket.new 'api.xively.com', 8081
+    s.puts subscribe
+    while line = s.gets
+      parse_data(line, s)
+    end
+    s.close
+
+    puts "Connection closed"
+
+    # EventMachine.run {
+    #   EventMachine::connect 'api.xively.com', 8081, XivelySocket, options
+    # }
+  rescue Interrupt => e
+    puts "Closing connection"
+    s.close
+    raise e
+  end
+
+  alias_command "sub", "subscribe"
+
+  protected
+
+  def parse_data(string, socket)
+    puts(string)
+    if string =~ /"status":40/
+      socket.close
+      exit(1)
+    end
+  end
+
+end
+

data/lib/xively-cli/command/version.rb

@@ -0,0 +1,23 @@
+require "xively-cli/command/base"
+require "xively-cli/version"
+
+# display version
+#
+class Xively::Command::Version < Xively::Command::Base
+
+  # version
+  #
+  # show xively client version
+  #
+  #Example:
+  #
+  # $ xively version
+  # v0.0.1
+  #
+  def index
+    validate_arguments!
+
+    puts(Xively::VERSION)
+  end
+
+end

data/lib/xively-cli/version.rb

@@ -0,0 +1,5 @@
+module Xively
+  class CLI
+    VERSION = "0.0.9"
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: xively-cli
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+  prerelease: 
+platform: ruby
+authors:
+- Levent Ali
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xively-rb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Xively CLI
+email: lebreeze@gmail.com
+executables:
+- xively
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/xively-cli/cli.rb
+- lib/xively-cli/command/base.rb
+- lib/xively-cli/command/feeds.rb
+- lib/xively-cli/command/help.rb
+- lib/xively-cli/command/subscribe.rb
+- lib/xively-cli/command/version.rb
+- lib/xively-cli/command.rb
+- lib/xively-cli/version.rb
+- lib/xively-cli.rb
+- LICENSE
+- README.md
+- bin/xively
+homepage: https://github.com/levent/xively-cli
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2041254343982566204
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2041254343982566204
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides a client to Xively
+test_files: []
+has_rdoc: