cosm 0.0.1

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,8 @@
+Cosm CLI
+========
+
+A Cosm CLI which currently allows you to connect to the tcp socket server and subscribe to a datastream
+
+[![Build Status](https://secure.travis-ci.org/levent/cosm.png)](http://travis-ci.org/levent/cosm)
+[![Dependency Status](https://gemnasium.com/levent/cosm.png)](https://gemnasium.com/levent/cosm)
+

data/bin/cosm

@@ -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 "cosm/cli"
+  Cosm::CLI.start(*ARGV)
+rescue Interrupt
+  `stty icanon echo`
+  puts("\n !    Command cancelled.")
+end

data/lib/cosm/cli.rb

@@ -0,0 +1,12 @@
+require "cosm"
+require "cosm/command"
+
+class Cosm::CLI
+
+  def self.start(*args)
+    command = args.shift.strip rescue "help"
+    Cosm::Command.load
+    Cosm::Command.run(command, args)
+  end
+
+end

data/lib/cosm/command/base.rb

@@ -0,0 +1,148 @@
+require "fileutils"
+require "cosm/command"
+
+class Cosm::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 == Cosm::Command::Base
+      help = extract_help_from_caller(caller.first)
+
+      Cosm::Command.register_namespace(
+        :name => klass.namespace,
+        :description => help.first
+      )
+    end
+  end
+
+  def self.method_added(method)
+    return if self == Cosm::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
+
+    Cosm::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 Cosm::Command.commands[old]
+    Cosm::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 = Cosm::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
+    Cosm::Command.current_command
+  end
+
+  def extract_option(key)
+    options[key.dup.gsub('-','').to_sym]
+  end
+
+  def invalid_arguments
+    Cosm::Command.invalid_arguments
+  end
+
+  def shift_argument
+    Cosm::Command.shift_argument
+  end
+
+  def validate_arguments!
+    Cosm::Command.validate_arguments!
+  end
+
+  def escape(value)
+    cosm.escape(value)
+  end
+end
+
+module Cosm::Command
+  unless const_defined?(:BaseWithApp)
+    BaseWithApp = Base
+  end
+end

data/lib/cosm/command/help.rb

@@ -0,0 +1,121 @@
+# list commands and display help
+#
+class Cosm::Command::Help < Cosm::Command::Base
+
+  PRIMARY_NAMESPACES = %w( subscribe )
+
+  # help [COMMAND]
+  #
+  # list available commands or display help for a specific command
+  #
+  #Examples:
+  #
+  # $ cosm help
+  # Usage: cosm COMMAND [--key API_KEY] [command-specific-options]
+  #
+  # Primary help topics, type "cosm 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: cosm #{command[:banner]}" if command
+  end
+
+private
+
+  def commands_for_namespace(name)
+    Cosm::Command.commands.values.select do |command|
+      command[:namespace] == name && command[:command] != name
+    end
+  end
+
+  def namespaces
+    namespaces = Cosm::Command.namespaces
+    namespaces.delete("app")
+    namespaces
+  end
+
+  def commands
+    Cosm::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: cosm COMMAND [--key API_KEY] [command-specific-options]"
+    puts
+    puts "Primary help topics, type \"cosm 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 = Cosm::Command.command_aliases[name]
+      puts("Alias: #{name} is short for #{command_alias}")
+      name = command_alias
+    end
+    if command = commands[name]
+      puts "Usage: cosm #{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 \"cosm help COMMAND\" for more details:"
+      puts
+      help_for_namespace(name)
+      puts
+    elsif command.nil?
+      puts "#{name} is not a cosm command. See `cosm help`."
+    end
+  end
+end

data/lib/cosm/command/subscribe.rb

@@ -0,0 +1,62 @@
+require 'cosm/command/base'
+require 'socket'
+
+# Subscribe to a datastream via the Cosm PAWS (Socket Server)
+#
+class Cosm::Command::Subscribe < Cosm::Command::Base
+
+  # subscribe
+  #
+  # connect to a tcp socket for a datastream
+  #
+  # -k, --key API_KEY        # your api key
+  # -f, --feed FEED          # the feed id
+  # -d, --datastream DATASTREAM  # the datastream id
+  #
+  #Example:
+  #
+  # $ cosm subscribe -k ABCD1234 -f 504 -d 0
+  #
+  def index
+    api_key = options[:key]
+    feed_id = options[:feed]
+    datastream_id = options[:datastream]
+
+    validate_arguments!
+
+    unless api_key && feed_id && datastream_id
+      puts Cosm::Command::Help.usage_for_command("subscribe")
+      exit(1)
+    end
+
+    subscribe = "{\"method\":\"subscribe\", \"resource\":\"/feeds/#{feed_id}/datastreams/#{datastream_id}\", \"headers\":{\"X-ApiKey\":\"#{api_key}\"}}"
+    s = TCPSocket.new 'api.cosm.com', 8081
+    s.puts subscribe
+    while line = s.gets
+      parse_data(line, s)
+    end
+    s.close
+
+    # EventMachine.run {
+    #   EventMachine::connect 'api.cosm.com', 8081, CosmSocket, 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/cosm/command/version.rb

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

data/lib/cosm/command.rb

@@ -0,0 +1,168 @@
+require 'cosm/version'
+require "optparse"
+
+module Cosm
+  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.downcase 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 cosm command.", "See `cosm 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/cosm/version.rb

@@ -0,0 +1,3 @@
+module Cosm
+  VERSION = "0.0.1"
+end

data/lib/cosm.rb

@@ -0,0 +1,2 @@
+module Cosm
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: cosm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Levent Ali
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-09 00:00:00.000000000 Z
+dependencies: []
+description: Cosm CLI
+email: lebreeze@gmail.com
+executables:
+- cosm
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cosm/cli.rb
+- lib/cosm/command/base.rb
+- lib/cosm/command/help.rb
+- lib/cosm/command/subscribe.rb
+- lib/cosm/command/version.rb
+- lib/cosm/command.rb
+- lib/cosm/version.rb
+- lib/cosm.rb
+- LICENSE
+- README.md
+- bin/cosm
+homepage: https://github.com/levent/cosm
+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: 2524522414027022837
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2524522414027022837
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides a client to Cosm
+test_files: []
+has_rdoc: