noms-command 0.5.0

data/lib/noms/command/urinion/data.rb

@@ -0,0 +1,63 @@
+#!ruby
+
+require 'base64'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::URInion
+
+end
+
+class NOMS::Command::URInion::Data
+
+    attr_accessor :scheme, :host, :port, :fragment, :query, :data, :path,
+        :data_encoding, :mime_type, :user, :password, :raw_data,
+        :character_set
+
+    def self.parse(urltext)
+        self.new(urltext)
+    end
+
+    def initialize(urltext)
+        @host = nil
+        @port = nil
+        @fragment = nil
+        @user = nil
+        @path = nil
+        @password = nil
+        @character_set = nil
+
+        @scheme, rest = urltext.split(':', 2)
+        raise NOMS::Command::Error.new "URL is not data: (scheme = #{@scheme})" unless @scheme == 'data'
+        meta, @raw_data = rest.split(',', 2)
+        fields = meta.split(';')
+        if fields[-1] == 'base64'
+            @data_encoding = fields.pop
+        end
+
+        unless fields[0].nil? or fields[0].empty?
+            @mime_type = fields.shift
+        end
+
+        fields.each do |field|
+            if m = /charset=(.*)/.match(field)
+                @character_set = m[1]
+            end
+        end
+
+        case @data_encoding
+        when 'base64'
+            @data = Base64.urlsafe_decode64
+        else
+            @data = @raw_data
+        end
+
+    end
+
+end

data/lib/noms/command/urinion.rb

@@ -0,0 +1,29 @@
+#!ruby
+
+require 'uri'
+require 'noms/command/urinion/data'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::URInion
+
+    def self.parse(url)
+        if url.respond_to? :scheme
+            url
+        else
+            case url
+            when /^data/
+                NOMS::Command::URInion::Data.parse(url)
+            else
+                URI.parse(url)
+            end
+        end
+    end
+
+end

data/lib/noms/command/useragent.rb

@@ -0,0 +1,134 @@
+#!ruby
+
+require 'noms/command/version'
+
+require 'openssl'
+require 'httpclient'
+require 'uri'
+require 'highline/import'
+
+require 'noms/command/auth'
+require 'noms/command/base'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::UserAgent < NOMS::Command::Base
+
+    def initialize(origin, attrs={})
+        @origin = origin
+        @client = HTTPClient.new :agent_name => "noms/#{NOMS::Command::VERSION}"
+        # TODO Replace with TOFU implementation
+        @client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        @redirect_checks = [ ]
+        @log = attrs[:logger] || default_logger
+
+        @log.debug "(UserAgent) specified identities = #{attrs[:specified_identities]}"
+        @auth = NOMS::Command::Auth.new(:logger => @log,
+                                        :specified_identities => (attrs[:specified_identities] || []))
+        # TODO: Set cookie jar to something origin-specific
+        # TODO: Set user-agent to something nomsy
+        # caching
+        @client.redirect_uri_callback = lambda do |uri, res|
+            raise NOMS::Command::Error.new "Bad redirect URL #{url}" unless check_redirect(uri)
+            @client.default_redirect_uri_callback(uri, res)
+        end
+    end
+
+    def auth
+        @auth
+    end
+
+    def check_redirect(url)
+        @log.debug "Running #{@redirect_checks.size} redirect checks on #{url}" unless @redirect_checks.empty?
+        @redirect_checks.all? { |check| check.call(url) }
+    end
+
+    def origin=(new_origin)
+        @log.debug "Setting my origin to #{new_origin}"
+        @origin = new_origin
+    end
+
+    def absolute_url(url)
+        @log.debug "Calculating absolute url of #{url} in context of #{@origin}"
+        begin
+            url = URI.parse url unless url.respond_to? :scheme
+            url = URI.join(@origin, url) unless url.absolute?
+            url
+        rescue StandardError => e
+            raise NOMS::Command::Error.new "Error parsing URL #{url} in context of #{@origin} (#{e.class}): #{e.message}"
+        end
+    end
+
+    def request(method, url, data=nil, headers={}, tries=10, identity=nil)
+        req_url = absolute_url(url)
+        @log.debug "#{method} #{req_url}" + (headers.empty? ? '' : headers.inspect)
+        response = @client.request(method.to_s.upcase, req_url, '', data, headers)
+        @log.debug "-> #{response.status} #{response.reason} (#{response.content.size} bytes of #{response.contenttype})"
+        @log.debug JSON.pretty_generate(response.headers)
+        case response.status
+        when 401
+            @log.debug "   handling unauthorized"
+            if identity
+                @log.debug "   we have an identity #{identity} but are trying again"
+                if tries > 0
+                    @log.debug "loading authentication identity for #{url}"
+                    identity = @auth.load(url, response)
+                    @client.set_auth(identity['domain'], identity['username'], identity['password'])
+                    response, req_url = self.request(method, url, data, headers, tries - 1, identity)
+                end
+            else
+                identity = @auth.load(url, response)
+                @client.set_auth(identity['domain'], identity['username'], identity['password'])
+                response, req_url = self.request(method, url, data, headers, 2, identity)
+            end
+        when 302, 301
+            new_url = response.header['location'].first
+            if check_redirect new_url
+                @log.debug "redirect to #{new_url}"
+                raise NOMS::Command::Error.new "Can't follow redirect to #{new_url}: too many redirects" if tries <= 0
+                response, req_url = self.request(method, new_url, data, headers, tries - 1)
+            end
+        end
+
+        if identity and response.ok?
+            @log.debug "Login succeeded, saving #{identity}"
+            identity.save
+        end
+
+        @log.debug "<- #{response.status} #{response.reason} <- #{req_url}"
+        [response, req_url]
+    end
+
+    def get(url, headers={})
+        request('GET', url, nil, headers)
+    end
+
+    # Wait for all asynchronous requests to complete.
+    # A stub while these are simulated
+    def wait(on=nil)
+        []
+    end
+
+    def add_redirect_check(&block)
+        @log.debug "Adding #{block} to redirect checks"
+        @redirect_checks << block
+    end
+
+    def clear_redirect_checks
+        @log.debug "Clearing redirect checks"
+        @redirect_checks = [ ]
+    end
+
+    def pop_redirect_check
+        unless @redirect_checks.empty?
+            @log.debug "Popping redirect check: #{@redirect_checks[-1]}"
+            @redirect_checks.pop
+        end
+    end
+end

data/lib/noms/command/version.rb

@@ -0,0 +1,7 @@
+class NOMS
+
+end
+
+class NOMS::Command
+    VERSION = "0.5.0"
+end

data/lib/noms/command/window.rb

@@ -0,0 +1,95 @@
+#!ruby
+
+require 'noms/command/version'
+
+require 'highline/import'
+
+require 'noms/command/base'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::Window < NOMS::Command::Base
+
+    attr_accessor :document, :name, :origin
+    attr_reader :console, :origin, :location
+
+    def initialize(invoker=$0, origin=nil, opt={})
+        @document = nil
+        @origin = origin
+        @name = invoker
+        @log = opt[:logger] || default_logger
+        @console = NOMS::Command::Window::Console.new(@log)
+        @location = NOMS::Command::Window::Location.new(self)
+    end
+
+    def isatty()
+        $stdout.tty?
+    end
+
+    def alert(msg)
+        @log.error msg
+    end
+
+    def prompt(prompt_text, echo=true)
+        echo = true if echo.nil?
+        @log.debug "prompt(#{prompt_text.inspect}, #{echo.inspect})"
+        v = ask(prompt_text) { |p| p.echo = false unless echo }
+        @log.debug "-> #{v}"
+        v
+    end
+
+end
+
+class NOMS::Command::Window::Console < NOMS::Command::Base
+
+    def initialize(logger=nil)
+        @log = logger || default_logger
+    end
+
+    # Some implementations have a kind of format string. I don't
+    def log(*items)
+        @log.debug(items.map { |s| _sanitize(s) }.join(', '))
+    end
+
+    def _sanitize(s)
+        s.respond_to?(:to_str) ? s : s.to_json
+    end
+
+end
+
+class NOMS::Command::Window::Location
+
+    {   :protocol => :scheme,
+        :origin => :to_s,
+        :pathname => :path,
+        :href => :to_s,
+        :hostname => :host,
+        :hash => :fragment,
+        :search => :query,
+        :port => :port
+    }.each do |loc_attr, uri_attr|
+        define_method(loc_attr) do
+            self.field uri_attr
+        end
+    end
+
+    def initialize(window)
+        @window = window
+        # Setup simple equivalences
+    end
+
+    def field(name)
+        @window.origin.send(name) if @window.origin.respond_to? name
+    end
+
+    def host
+        [self.hostname, self.port].join(':')
+    end
+
+end

data/lib/noms/command/xmlhttprequest.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env
+
+require 'noms/command/urinion'
+require 'noms/command/useragent'
+require 'noms/command/error'
+
+require 'httpclient'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+# Implements a subset of the XMLHttpRequest interface. This
+# class is exposed as a constructor function in the Javascript
+# VM. It uses NOMS::Command::UserAgent for HTTP conversations,
+# adding checks for the same-origin policy.
+class NOMS::Command::XMLHttpRequest
+
+    OPENED = 1
+    HEADERS_RECEIVED = 2
+    LOADING = 3
+    DONE = 4
+
+    @@origin = nil
+    @@ua = nil
+
+    def self.origin
+        @@origin
+    end
+
+    def self.origin=(origin)
+        @@origin = NOMS::Command::URInion.parse(origin)
+    end
+
+    def self.useragent
+        @@ua
+    end
+
+    # Set the class attribute for the UserAgent; ideally
+    # this is shared among everything in one *noms*
+    # invocation.
+    def self.useragent=(ua)
+        @@ua = ua
+    end
+
+    attr_accessor :responseText, :headers
+
+    def initialize()
+        @origin = @@origin
+        @ua = @@ua || NOMS::Command::UserAgent.new(@origin)
+        @headers = { }
+        @readyState = 0
+    end
+
+    def useragent
+        @ua
+    end
+
+    # Checks whether the URL has the same origin
+    # as the "origin" URL
+    def same_origin?(other)
+        other = NOMS::Command::URInion.parse(other)
+        return false unless @origin.scheme == other.scheme
+        return false unless @origin.host == other.host
+        return false unless @origin.port == other.port
+        return true
+    end
+
+    def open(method, url, async=true, user=nil, password=nil)
+        raise NOMS::Command::Error.new "origin of #{url} doesn't match application origin (#{@origin})" unless
+            same_origin? @ua.absolute_url(url)
+        # Should we run onreadystatechange when resetting this? Not doing it for now.
+        @readyState = 0
+        @responseText = ''
+        @response = nil
+        @method = method
+        @url = url
+        @async = async
+        @user = user
+        @password = password
+    end
+
+    def onreadystatechange
+        @onreadystatechange
+    end
+
+    def onreadystatechange=(callback)
+        @onreadystatechange = callback
+    end
+
+    def readyState
+        @readyState
+    end
+
+    def readyState=(value)
+        @readyState = value
+        unless @onreadystatechange.nil?
+            @onreadystatechange.methodcall self
+        end
+        @readyState
+    end
+
+    def setRequestHeader(header, value)
+        @headers[header] = value
+    end
+
+    def OPENED
+        OPENED
+    end
+
+    def HEADERS_RECEIVED
+       HEADERS_RECEIVED
+    end
+
+    def LOADING
+        LOADING
+    end
+
+    def DONE
+        DONE
+    end
+
+    # This problematic implementations attempts to "guess"
+    # when Object#send is intended, and when the Javascript-
+    # style xhr.send() is desired. The one ambiguous situation
+    # it can't recover from is when there is one string argument,
+    # this is a valid invocation of XMLHttpRequest#send as well
+    # as Object#send, and we settle on XMLHttpRequest#send.
+    def send(*vary)
+        if vary.size == 0 or (vary.size == 1 and ! vary[0].is_a? Symbol)
+            do_send(*vary)
+        else
+            super
+        end
+    end
+
+    # NOMS::Command::UserAgent doesn't do async
+    # calls (yet) since httpclient doesn't do
+    # anything special with them and you can
+    # only busy-wait on them. So they're "simulated",
+    # and by "simulated" I mean "performed synchronously".
+    def do_send(data=nil)
+        # @async ignored
+        @ua.add_redirect_check do |url|
+            self.same_origin? url
+        end
+        @response, landing_url = @ua.request(@method, @url, data, @headers)
+        # We don't need the 'landing' URL
+        @ua.pop_redirect_check
+        self.readyState = OPENED
+        self.readyState = HEADERS_RECEIVED
+        self.readyState = LOADING
+        @responseText = @response.content
+        self.readyState = DONE
+    end
+
+    def status
+        @response.status.to_i unless @response.nil?
+    end
+
+    def statusText
+        @response.status + ' ' + @response.reason unless @response.nil?
+    end
+
+    def getResponseHeader(header)
+        @response.header[header.downcase] unless @response.nil?
+    end
+
+    def getAllResponseHeaders
+        lambda { || @response.headers.map { |h, v| "#{h}: #{v}" }.join("\n") + "\n" }
+    end
+
+    def abort()
+        lambda { || @readyState = 0 }
+    end
+
+end

data/lib/noms/command.rb

@@ -0,0 +1,107 @@
+#!ruby
+
+require 'noms/command/version'
+
+require 'trollop'
+require 'logger'
+
+require 'noms/command/window'
+require 'noms/command/application'
+require 'noms/command/formatter'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+    def self.run(argv)
+        runner = self.new(argv)
+        runner.run
+    end
+
+    def initialize(argv)
+        @argv = argv
+        @log = Logger.new($stderr)
+        @log.formatter = lambda { |sev, timestamp, prog, msg| msg[-1].chr == "\n" ? msg : msg + "\n" }
+    end
+
+    def run
+        # Find my own configuration for bookmarks and stuff
+        # Interpret either environment variables or (maybe) initial options
+        parser = Trollop::Parser.new do
+            version NOMS::Command::VERSION
+            banner <<-USAGE.gsub(/^\s{16}/,'')
+                Usage:
+                  noms [noms-options] { bookmark | url } [options] [arguments]
+                  noms-options:
+            USAGE
+            opt :identity, "Identity file", :type => :string, :multi => true
+            opt :verbose,  "Enable verbose output"
+            opt :list,     "List bookmarks"
+            opt :bookmarks, "Bookmark file location (can be specified multiple times)",
+                :type => :string,
+                :multi => true
+            opt :nodefault_bookmarks, "Don't consult default bookmarks files",
+                :short => '-X',
+                :long => '--nodefault-bookmarks'
+            opt :debug,    "Enable debug output"
+            stop_on_unknown
+        end
+
+        @opt = Trollop::with_standard_exception_handling parser do
+            parser.parse(@argv)
+        end
+
+        Trollop::with_standard_exception_handling parser do
+            raise Trollop::HelpNeeded if @argv.empty? and ! @opt[:list]
+        end
+
+        @opt[:debug] = true if ENV['NOMS_DEBUG'] and ! ENV['NOMS_DEBUG'].empty?
+
+        default_bookmarks =
+            [ File.join(ENV['HOME'], '.noms/bookmarks.json'),
+            '/usr/local/etc/noms/bookmarks.json',
+            '/etc/noms/bookmarks.json'].select { |f| File.exist? f }
+
+        @opt[:bookmarks].concat default_bookmarks unless @opt[:nodefault_bookmarks]
+
+        @log.level = Logger::WARN
+        @log.level = Logger::INFO if @opt[:verbose]
+        @log.level = Logger::DEBUG if @opt[:debug]
+
+        @bookmark = @opt[:bookmarks].map do |file|
+            begin
+                File.open(file, 'r') { |fh| JSON.load fh }
+            rescue JSON::ParserError => j
+                @log.warn "Couldn't load bookmarks from invalid JSON file #{file.inspect}"
+                @log.debug "JSON error: #{file.inspect}:#{j.message}"
+                nil
+            rescue StandardError => e
+                @log.warn "Couldn't open #{file.inspect} (#{e.class}): #{e.message}"
+                @log.debug "Error opening #{file.inspect}: #{e.backtrace.join("\n")}"
+                nil
+            end
+        end.compact.reverse.inject({}) { |h1, h2| h1.merge h2 }
+
+        if @opt[:list]
+            puts @bookmark.map { |pair| '%-15s -> %s' % pair }
+            return 0
+        end
+
+        begin
+            origin = @bookmark[@argv[0].split('/').first] || @argv[0]
+            app = NOMS::Command::Application.new(origin, @argv, :logger => @log,
+                                                 :specified_identities => @opt[:identity])
+            app.fetch!                    # Retrieve page
+            app.render!                   # Run scripts
+            out = app.display
+            puts out unless out.empty?
+            app.exitcode                  # Return exitcode
+        rescue NOMS::Command::Error => e
+            @log.error "noms error: #{e.message}"
+            255
+        end
+    end
+
+end

data/noms-command.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'noms/command/version'
+
+Gem::Specification.new do |spec|
+    spec.name          = "noms-command"
+    spec.version       = NOMS::Command::VERSION
+    spec.authors       = ["Jeremy Brinkley"]
+    spec.email         = ["jbrinkley@evernote.com"]
+    spec.summary       = %q{Interpreter for server-defined command-line interfaces}
+    spec.homepage      = "http://github.com/en-jbrinkley/noms-command"
+    spec.license       = "Apache-2"
+
+    spec.files         = `git ls-files -z`.split("\x0")
+    spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+    spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+    spec.require_paths = ["lib"]
+
+    spec.add_runtime_dependency "therubyracer"
+    spec.add_runtime_dependency "mime-types"
+    spec.add_runtime_dependency "httpclient"
+    spec.add_runtime_dependency "json"
+    spec.add_runtime_dependency "trollop"
+    spec.add_runtime_dependency "highline"
+
+    spec.add_development_dependency "bundler", "~> 1.7"
+    spec.add_development_dependency "rake", "~> 10.0"
+    spec.add_development_dependency "sinatra"
+end

data/spec/01noms-command_spec.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require 'noms/command'
+
+describe NOMS::Command do
+
+    before(:all) do
+        setup_fixture 'test'
+        File.open('test/foo.txt', 'w') do |fh|
+            fh << <<-TEXT.gsub(/^\s+/,'')
+                1: Test output
+                2: from foo.txt
+            TEXT
+        end
+    end
+
+    after(:all)  { teardown_fixture 'test' }
+
+    describe '.run' do
+        context 'with one file argument' do
+            it 'shows the file contents' do
+                file = 'file://' + File.join(Dir.pwd, 'test', 'foo.txt')
+                expect { NOMS::Command.run([file]) }.to output(/from foo.txt/).to_stdout
+            end
+        end
+    end
+
+end