noms-command 0.5.0

data/lib/noms/command/application.rb

@@ -0,0 +1,204 @@
+#!ruby
+
+require 'noms/command/version'
+
+require 'mime-types'
+require 'v8'
+
+require 'noms/command/window'
+require 'noms/command/useragent'
+require 'noms/command/error'
+require 'noms/command/urinion'
+require 'noms/command/formatter'
+require 'noms/command/document'
+require 'noms/command/xmlhttprequest'
+require 'noms/command/base'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::Application < NOMS::Command::Base
+
+    # Should user-agent actually be here?
+    attr_accessor :window, :options,
+        :type, :body, :useragent,
+        :document
+
+    def initialize(origin, argv, attrs={})
+        @document = nil
+        @origin = NOMS::Command::URInion.parse(origin)
+        if @origin.scheme == 'file' and @origin.host.nil?
+            @origin.host = 'localhost'
+        end
+        @argv = argv
+        @options = { }
+        @type = nil
+
+        @log = attrs[:logger] || default_logger
+
+        @window = NOMS::Command::Window.new($0, @origin, :logger => @log)
+
+        @log.debug "Application #{argv[0]} has origin: #{origin}"
+        @useragent = NOMS::Command::UserAgent.new(@origin, :logger => @log,
+                                                  :specified_identities => (attrs[:specified_identities] || []))
+    end
+
+    def fetch!
+        # Get content and build object, set @type
+        case @origin.scheme
+        when 'file'
+            @type = (MIME::Types.of(@origin.path).first || MIME::Types['text/plain'].first).content_type
+            @body = File.open(@origin.path, 'r') { |fh| fh.read }
+        when 'data'
+            @type = @origin.mime_type
+            raise NOMS::Command::Error.new("data URLs must contain application/json") unless @type == 'application/json'
+            @body = @origin.data
+        when /^http/
+            response, landing_url = @useragent.get(@origin)
+            new_url = landing_url
+            @origin = new_url
+            @useragent.origin = new_url
+            @window.origin = new_url
+            @log.debug "Setting origin to: #{@origin}"
+            if response.ok?
+                # Unlike typical ReST data sources, this
+                # should very rarely fail unless there is
+                # a legitimate communication issue.
+                @type = response.contenttype || 'text/plain'
+                @body = response.content
+            else
+                raise NOMS::Command::Error.new("Failed to request #{@origin}: #{response.status} #{response.reason}")
+            end
+        else
+            raise NOMS::Command::Error.new("noms command #{@argv[0].inspect} not found: not a URL or bookmark")
+        end
+
+        case @type
+        when /^(application|text)\/(x-|)json/
+            begin
+                @body = JSON.parse(@body)
+            rescue JSON::ParserError => e
+                raise NOMS::Command::Error.new("JSON error in #{@origin}: #{e.message}")
+            end
+            if @body.respond_to? :has_key? and @body.has_key? '$doctype'
+                @type = @body['$doctype']
+                @log.debug "Treating as #{@type} document"
+                @document = NOMS::Command::Document.new @body
+                @document.argv = @argv
+                @document.exitcode = 0
+            else
+                @log.debug "Treating as raw object (no '$doctype')"
+                @type = 'noms-raw'
+            end
+        end
+    end
+
+    def exitcode
+        @document ? @document.exitcode : 0
+    end
+
+    def render!
+        if @document and @document.script
+            # Crashes when using @window as global object
+            @v8 = V8::Context.new
+            # Set up same-origin context and stuff--need
+            # Ruby objects to do XHR and limit local I/O
+            @window.document = @document
+            @v8[:window] = @window
+            @v8[:document] = @document
+            @v8.eval 'var alert = function (s) { window.alert(s); };'
+            @v8.eval 'var prompt = function (s, echo) { window.prompt(s, echo); };'
+            @v8.eval 'var location = window.location;'
+            @v8.eval 'var console = window.console;'
+            NOMS::Command::XMLHttpRequest.origin = @origin
+            NOMS::Command::XMLHttpRequest.useragent = @useragent
+            @v8[:XMLHttpRequest] = NOMS::Command::XMLHttpRequest
+            script_index = 0
+            @document.script.each do |script|
+                if script.respond_to? :has_key? and script.has_key? '$source'
+                    # Parse relative URL and load
+                    response, landing_url = @useragent.get(script['$source'])
+                    # Don't need landing_url
+                    script_name = File.basename(@useragent.absolute_url(script['$source']).path)
+                    script_ref = "#{script_index},#{script_name}"
+                    if response.ok?
+                        case response.contenttype
+                        when /^(application|text)\/(x-|)javascript/
+                            begin
+                                @v8.eval response.content
+                            rescue StandardError => e
+                                @log.warn "Javascript[#{script_ref}] error: #{e.message}"
+                                @log.debug e.backtrace.join("\n")
+                            end
+                        else
+                            @log.warn "Unsupported script type '#{response.contenttype.inspect}' " +
+                                "for script from #{script['$source'].inspect}"
+                        end
+                    else
+                        @log.warn "Couldn't load script from #{script['$source'].inspect}: #{response.status} #{response.reason}"
+                        @log.debug "Body of unsuccessful request: #{response.body}"
+                    end
+                else
+                    # It's javascript text
+                    script_ref = "#{script_index},\"#{abbrev(script)}\""
+                    begin
+                        @v8.eval script
+                    rescue StandardError => e
+                        @log.warn "Javascript[#{script_ref}] error: #{e.message}"
+                        @log.debug e.backtrace.join("\n")
+                    end
+                end
+                script_index += 1
+            end
+        end
+    end
+
+    def abbrev(s, limit=10)
+        if s.length > (limit - 3)
+            s[0 .. (limit - 3)] + '...'
+        else
+            s
+        end
+    end
+
+    def display
+        case @type
+        when 'noms-v2'
+            NOMS::Command::Formatter.new(_sanitize(@document.body)).render
+        when 'noms-raw'
+            @body.to_yaml
+        when /^text(\/|$)/
+            @body
+        else
+            if @window.isatty
+                # Should this be here?
+                @log.warn "Unknown data of type '#{@type}' not sent to terminal"
+                []
+            else
+                @body
+            end
+        end
+    end
+
+    # Get rid of V8 stuff
+    def _sanitize(thing)
+        if thing.kind_of? V8::Array or thing.respond_to? :to_ary
+            thing.map do |item|
+                _sanitize item
+            end
+        elsif thing.respond_to? :keys
+            Hash[
+                 thing.keys.map do |key|
+                     [key, _sanitize(thing[key])]
+                 end]
+        else
+            thing
+        end
+    end
+
+end

data/lib/noms/command/auth/identity.rb

@@ -0,0 +1,62 @@
+#!ruby
+
+require 'logger'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::Auth < NOMS::Command::Base
+
+end
+
+class NOMS::Command::Auth::Identity < NOMS::Command::Base
+    include Enumerable
+
+    def initialize(auth, h, attrs={})
+        @log = attrs[:logger] || default_logger
+        @auth = auth
+        @data = h
+    end
+
+    def [](key)
+        @data[key]
+    end
+
+    def []=(key, value)
+        @data[key] = value
+    end
+
+    def each
+        @data.each
+    end
+
+    def keys
+        @data.keys
+    end
+
+    def save
+        @log.debug "Saving #{@data['id']}"
+    end
+
+    def id
+        @data['id']
+    end
+
+    def realm
+        @data['realm']
+    end
+
+    def domain
+        @data['domain']
+    end
+
+    def to_s
+        "#{@data['id']}"
+    end
+
+end

data/lib/noms/command/auth.rb

@@ -0,0 +1,117 @@
+#!ruby
+
+require 'noms/command/version'
+
+require 'httpclient'
+require 'etc'
+require 'highline/import'
+require 'json'
+require 'cgi'
+
+require 'noms/command/base'
+require 'noms/command/auth/identity'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::Auth < NOMS::Command::Base
+
+    def initialize(opts={})
+        @log = opts[:logger] || default_logger
+        @loaded = { }
+        (opts[:specified_identities] || []).each do |file|
+            maybe_id = read_identity_from file
+            raise NOMS::Command::Error.now "#{file} contains invalid identity (no 'id')" unless
+                maybe_id['id']
+            @loaded[maybe_id['id']] = maybe_id
+        end
+    end
+
+    def read_identity_from(file)
+        @log.debug "Reading identity file #{file}"
+        begin
+            # TODO: Encryption and passphrases
+            raise NOMS::Command::Error.new "Identity file #{file} does not exist" unless File.exist? file
+            s = File.stat file
+            raise NOMS::Command::Error.new "You don't own identity file #{file}" unless s.owned?
+            raise NOMS::Command::Error.new "Permissions on #{file} are too permissive" unless (s.mode & 077 == 0)
+            contents = File.read file
+            case contents[0].chr
+            when '{'
+                NOMS::Command::Auth::Identity.new(self, JSON.parse(contents))
+            else
+                raise NOMS::Command::Error.new "#{file} contains unsupported or corrupted data"
+            end
+        rescue StandardError => e
+            if e.is_a? NOMS::Command::Error
+                raise e
+            else
+                raise NOMS::Command::Error.new "Couldn't load identity from #{file} (#{e.class}): #{e.message}"
+            end
+        end
+    end
+
+    # TODO: Persistent auth creds
+    # Store like a client certificate: encrypted. Then use an
+    # agent to store by using <agent>-add and typing passphrase
+    # just like a client cert. <agent> expires credentials.
+    # also you can explicitly unencrypt identity file
+
+    def load(url, response)
+        # Prompt
+        auth_header = response.header['www-authenticate']
+        auth_header = (auth_header.respond_to?(:first) ? auth_header.first : auth_header)
+        case auth_header
+        when /Basic/
+            if m = /realm=\"([^\"]*)\"/.match(auth_header)
+                realm = m[1]
+            else
+                realm = ''
+            end
+            domain = [url.scheme, '://', url.host, ':', url.port, '/'].join('')
+            identity_id = CGI.escape(realm) + '=' + domain
+            if saved(identity_id)
+                retrieve(identity_id)
+            else
+                if $stdin.tty?
+                    default_user = Etc.getlogin
+                    prompt = "#{domain} (#{realm}) username: "
+                    user = ask(prompt) { |u| u.default = Etc.getlogin }
+                    pass = ask('Password: ') { |p| p.echo = false }
+                    NOMS::Command::Auth::Identity.new(self, {
+                                                          'id' => identity_id,
+                                                          'realm' => realm,
+                                                          'domain' => domain,
+                                                          'username' => user,
+                                                          'password' => pass
+                                                      })
+                else
+                    @log.warn "Can't prompt for #{domain} (#{realm}) authentication (not a terminal)"
+                    NOMS::Command::Auth::Identity.new({
+                                                         'id' => identity_id,
+                                                         'realm' => realm,
+                                                         'domain' => domain,
+                                                         'username' => '',
+                                                         'password' => ''
+                                                     })
+                end
+            end
+        else
+            raise NOMS::Command::Error.new "Authentication not supported: #{auth_header.inspect}"
+        end
+    end
+
+    def saved(identity_id)
+        @loaded.has_key? identity_id
+    end
+
+    def retrieve(identity_id)
+        @loaded[identity_id]
+    end
+
+end

data/lib/noms/command/base.rb

@@ -0,0 +1,22 @@
+#!ruby
+
+require 'logger'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::Base
+
+    def default_logger
+        log = Logger.new $stdin
+        log.level = Logger::WARN
+        log.level = Logger::DEBUG if ENV['NOMS_DEBUG']
+        log
+    end
+
+end

data/lib/noms/command/document.rb

@@ -0,0 +1,59 @@
+#!ruby
+
+require 'noms/command/error'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::Document
+
+    attr_accessor :exitcode, :argv
+
+    def initialize(doc)
+        raise NOMS::Command::Error.new "Document type '#{docobj['$doctype']}' not understood" unless
+            doc['$doctype'] == 'noms-v2'
+        @doc = doc
+    end
+
+    # Make these synonymous with the keys
+    def body
+        @doc['$body']
+    end
+
+    def body=(rval)
+        @doc['$body'] = rval
+    end
+
+    def script
+        @doc['$script']
+    end
+
+    def script=(rval)
+        @doc['$script'] = rval
+    end
+
+    def argv
+        @doc['$argv']
+    end
+
+    def argv=(rval)
+        @doc['$argv'] = rval
+    end
+
+    def exitcode
+        @doc['$exitcode']
+    end
+
+    def exitcode=(rval)
+        unless rval.respond_to?(:to_int) and rval <= 255 and rval >= 0
+            raise NOMS::Command::Error.new "Exitcode ${rval.inspect} out of range"
+        end
+        @doc['$exitcode'] = rval
+    end
+
+end

data/lib/noms/command/error.rb

@@ -0,0 +1,11 @@
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::Error < StandardError
+
+end

data/lib/noms/command/formatter.rb

@@ -0,0 +1,178 @@
+#!ruby
+
+require 'json'
+require 'yaml'
+require 'csv'
+
+require 'noms/command/error'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::Formatter
+
+    def initialize(data=nil, opt={})
+        @data = data
+        @format_raw_object = opt[:format_raw_object] || lambda { |o| o.to_yaml }
+    end
+
+    def render(item=@data)
+        if item.nil?
+            ''
+        elsif item.respond_to? :to_ary
+            item.map { |it| render it }.join("\n")
+        elsif item.respond_to? :has_key?
+            if item['$type']
+                case item['$type']
+                when 'object-list'
+                    render_object_list item
+                when 'object'
+                    render_object item
+                end
+            else
+                # It's a raw object, do YAML
+                @format_raw_object.call item
+            end
+        else
+            item.to_s
+        end
+    end
+
+    def _fmt(spec)
+        '%' +
+            ((spec['align'] && spec['align'] == 'right') ? '' : '-') +
+            (spec['width'] ? spec['width'].to_s : '') +
+            (spec['maxwidth'] ? '.' + spec['maxwidth'] : '') +
+            's'
+    end
+
+    def _fmth(spec)
+        # Headers are always left-aligned
+        '%-' +
+            (spec['width'] ? spec['width'].to_s : '') +
+            (spec['maxwidth'] ? '.' + spec['maxwidth'] : '') +
+            's'
+    end
+
+    def render_object_list(objlist)
+        objlist['$labels'] ||= true
+        objlist['$format'] ||= 'lines'
+        raise NOMS::Command::Error.new("objectlist ('lines' format) must contain '$columns' list") unless
+            objlist['$columns'] and objlist['$columns'].respond_to? :map
+
+        case objlist['$format']
+        when 'lines'
+            render_object_lines objlist
+        when 'yaml'
+            filter_object_list(objlist).to_yaml
+        when 'json'
+            JSON.pretty_generate(filter_object_list(objlist))
+        when 'csv'
+            render_csv objlist
+        else
+            raise NOMS::Command::Error.new("objectlist format '#{objlist['$format']}' not supported")
+        end
+    end
+
+    def filter_object_list(objlist)
+        columns = normalize_columns objlist['$columns']
+
+        objlist['$data'].map do |object|
+            Hash[columns.map { |c| [c['heading'], object[c['field']]] }]
+        end
+    end
+
+    def normalize_columns(cols)
+        cols.map do |spec|
+            new_spec = { }
+            if spec.respond_to? :has_key?
+                new_spec.merge! spec
+                raise NOMS::Command::Error.new("Column must contain 'field': #{spec.inspect}") unless
+                    spec['field']
+                new_spec['heading'] ||= new_spec['field']
+            else
+                new_spec = {
+                    'field' => spec,
+                    'heading' => spec
+                }
+            end
+            new_spec
+        end
+    end
+
+    def render_csv(objlist)
+        labels = objlist.has_key?('$labels') ? objlist['$labels'] : true
+
+        columns = normalize_columns(objlist['$columns'] || [])
+
+        CSV.generate do |csv|
+            csv << columns.map { |f| f['heading'] } if labels
+            objlist['$data'].each do |object|
+                csv << columns.map { |f| _string(object[f['field']]) }
+            end
+        end.chomp
+
+    end
+
+
+    def render_object_lines(objlist)
+        columns = normalize_columns(objlist['$columns'] || [])
+        labels = objlist.has_key?('$labels') ? objlist['$labels'] : true
+
+        header_fmt = columns.map { |f| _fmth f }.join(' ')
+        fmt = columns.map { |f| _fmt f }.join(' ')
+
+        header_cells = columns.map { |f| f['heading'] }
+        out = labels ? [ sprintf(header_fmt, *header_cells) ] : []
+
+        out += objlist['$data'].map do |object|
+            cells = columns.map { |f| _string(object[f['field']]) }
+            sprintf(fmt, *cells)
+        end
+
+        out.join("\n")
+
+    end
+
+    def _string(datum)
+        datum.kind_of?(Enumerable) ? datum.to_json : datum.to_s
+    end
+
+    def render_object(object)
+        object['$format'] ||= 'record'
+
+        case object['$format']
+        when 'record'
+            render_object_record object
+        when 'json'
+            JSON.pretty_generate(filter_object(object))
+        when 'yaml'
+            filter_object(object).to_yaml
+        else
+            raise NOMS::Command::Error.new("object format '#{object['$format']}' not supported")
+        end
+    end
+
+    def render_object_record(object)
+        labels = object.has_key?('$labels') ? object['$labels'] : true
+        fields = (object['$fields'] || object['$data'].keys).sort
+        data = object['$data']
+        fields.map do |field|
+            (labels ? (field + ': ') : '' ) + _string(data[field])
+        end.join("\n")
+    end
+
+    def filter_object(object)
+        if object['$fields']
+            Hash[object['$fields'].map { |f| [f, object['$data'][f]] }]
+        else
+            object['$data']
+        end
+    end
+
+end