nntp-client 0.0.5

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format specdoc
+--color

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nntp.gemspec
+gem 'rake'
+gem "rspec"
+gem "rspec-core"
+gem "rspec-expectations"
+gem "rspec-mocks"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Michael Westbom
+
+MIT License
+
+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,51 @@
+# NNTPClient
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'NNTPClient'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install NNTPClient
+
+## Usage
+
+### Connection
+Two different methods can be used to connect to a usenet server:
+
+1.  First, by supplying a URL and a port number as hash values:
+    ```ruby
+    nntp = NNTPClient.new(:url => 'nntp.example.org', :port => 119)
+    ```
+    An optional `:socket_factory` value can be included if you'd with for something other than TCPSocket to be used.  
+    Please note that the signature of `::new` must match `TCPSocket::new`'s signature.
+
+2.  By supplying an existing socket:
+```ruby
+my_socket = TCPSocket.new('nntp.example.org', 119)
+nntp = NNTPClient.new(:socket => my_socket)
+```
+
+### Listing Newsgroups
+Upon connecting to a server, a list of valid newsgroups may be retrieved as such:
+```ruby
+groups = nntp.groups
+```
+
+The first time `#groups` is called, it retrieves the list of groups from the server.  Subsequent calls return an instance variable.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/NNTPClient.rb

@@ -0,0 +1,120 @@
+require 'socket'
+require_relative 'group'
+require_relative 'article'
+require "NNTPClient/version"
+
+class NNTPClient
+  attr_reader :socket, :status, :current_group
+
+  def initialize(options = {})
+    @socket = open_socket(options)
+    init_attributes
+  end
+
+  def groups
+    @groups ||= list_groups
+  end
+
+  def group(group)
+    send_message "GROUP #{group}"
+    self.status = get_status
+    if status[:code] == 211
+      self.current_group = create_group(status)
+    end
+  end
+
+  def articles
+    @articles ||= fetch_articles
+  end
+
+  def auth(options = {})
+    send_message "AUTHINFO USER #{options[:user]}"
+    self.status = get_status
+    send_message "AUTHINFO PASS #{options[:pass]}"
+    self.status = get_status
+    if status[:code] == 281
+      true
+    else
+      false
+    end
+  end
+  private
+  def fetch_articles
+    send_message "XHDR Subject #{current_group.first}-"
+    self.status = get_status
+    return nil unless status[:code] == 221
+    get_data_block.map do |line|
+      article_id, article_subject = line.split(' ', 2)
+      NNTP::Article.new(article_id, article_subject)
+    end
+  end
+
+  def init_attributes
+    @current_group = nil
+    @status = nil
+    @groups = nil
+    @articles = nil
+  end
+
+  def create_group(status)
+    params = status[:params]
+    # TODO: This is ugly
+    NNTP::Group.new(*params[1..-1])
+  end
+
+  def open_socket(options)
+    options.fetch(:socket) {
+      url = options.fetch(:url) { raise ArgumentError, ':url is required' }
+      port = options.fetch(:port, 119)
+      socket_factory = options.fetch(:socket_factory) { TCPSocket }
+      socket_factory.new(url, port)
+    }
+  end
+
+  def list_groups
+    send_message "LIST"
+    status = get_status
+    return nil unless status[:code] == 215
+
+    get_data_block
+  end
+
+  def groups=(list=[])
+    @groups = list
+  end
+
+  def status=(status)
+    @status = status
+  end
+
+  def current_group=(group)
+    @current_group = group
+  end
+
+  def get_status
+    line = get_line
+    {
+      :code => line[0..2].to_i,
+      :message => line[3..-1].lstrip,
+      :params => line.split
+    }
+  end
+
+  def get_data_block
+    lines = []
+    current_line = get_line
+    until current_line == '.'
+      lines << current_line
+      current_line = get_line
+    end
+    lines
+  end
+
+  def get_line
+    socket.gets().chomp
+  end
+
+  def send_message(msg)
+    socket.print "#{msg}\r\n"
+  end
+end

data/lib/article.rb

@@ -0,0 +1,7 @@
+module NNTP
+  Article = Struct.new(:number, :subject, :article_id) do
+    def to_s
+      subject
+    end
+  end
+end

data/lib/nntp.rb

@@ -0,0 +1,49 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "nntp/version"
+require "nntp/session"
+require "nntp/connection"
+require 'nntp/ssl_connection'
+
+# The main entry point for this module is the open method.
+#
+# ::open returns an object that is an active NNTP session.
+# If a block is passed to it, the session object is made available
+# therein.
+module NNTP
+  # The main entrypoint to the module.
+  #
+  # @option options :url The URL of the NNTP server.
+  # @option options :port (119/563) The port number of the server.
+  # @option options [Boolean] :ssl (false) Connect via SSL?
+  # @option options [Hash] :auth Authentication credentials and style.
+  # @example Basic connection
+  #   nntp = NNTP.open(
+  #     :url => 'nntp.example.org',
+  #     :auth => {:user => 'mike', :pass => 'soopersecret'}
+  #   )
+  #   nntp.quit
+  # @example Pass a block
+  #   # Automatically closes connection
+  #   NNTP.open(:url => 'nntp.example.org') do |nntp|
+  #     nntp.group = 'alt.bin.foo'
+  #   end
+  # @return [NNTP::Session] the active NNTP session
+  def self.open(options)
+    if options[:ssl]
+      connection = SSLConnection.new(options)
+    else
+      connection = Connection.new(options)
+    end
+
+    session = Session.new(:connection => connection)
+
+    session.auth(options[:auth]) if options[:auth]
+
+    if block_given?
+      yield session
+      session.quit
+    else
+      session
+    end
+  end
+end

data/lib/nntp/connection.rb

@@ -0,0 +1,126 @@
+require 'socket'
+require 'nntp/status'
+
+module NNTP
+  #  Handles communication with the NNTP server.
+  #
+  #  Most communication with an NNTP server happens in a back-and-forth
+  #  style.
+  #
+  #  The client sends a message to the server.  The server will respond with a status response, and sometimes with extra data. See {https://tools.ietf.org/html/rfc3977 RFC 3977} for more details.
+  #
+  #  This class handles this communication by providing two methods,
+  #  one for use when additional data is expected, and one for when it is not.
+  class Connection
+    # @!attribute [r] socket
+    #   The object upon which all IO takes place.
+    #
+    # @!attribute [r] status
+    #   The most status of the most recent command.
+    #   @return [NNTP::Status]
+
+    attr_reader :socket, :status
+
+    # (see #build_socket)
+    def initialize(options)
+      @socket = build_socket(options)
+    end
+
+    # Sends a message to the server, collects the the status and additional data, if successful.
+    # A Hash is returned containing two keys: :status and :data.
+    # :status is an {NNTP::Status}, and :data is an array containing
+    # the lines from the response See example for details.
+    # @example
+    #   nntp.query(:list) do |status, data|
+    #     $stdout.puts status
+    #     data.each? do |line|
+    #       $stdout.puts line
+    #     end
+    #   end
+    #
+    #   => 215 Information follows
+    #   => alt.bin.foo
+    #   => alt.bin.bar
+    # @param query [Symbol, String] The command to send
+    # @param args Any additional parameters are passed along with the command.
+    # @yield The status and data from the server.
+    # @yieldparam status [NNTP::Status]
+    # @yieldparam data [Array<String>, nil] An array with the lines from the server.  Nil if the query failed.
+    # @return [Hash] The status and requested data.
+    def query(query, *args)
+      command = form_message(query, args)
+      send_message(command)
+      status = get_status
+      data = if (400..599).include? status.code
+        nil
+      else
+        get_block_data
+      end
+      yield status, data if block_given?
+      {:status => status, :data => data}
+    end
+
+    # Sends a message to the server and collects the status response.
+    # @param (see #query)
+    # @return [NNTP::Status] The server's response.
+    def command(command, *args)
+      command = form_message(command, args)
+      send_message(command)
+      get_status
+    end
+
+    # Fetch a status line from the server.
+    # @return [NNTP::Status]
+    def get_status
+      code, message = get_line.split(' ', 2)
+      @status = status_factory(code.to_i, message)
+    end
+
+    # Sends "QUIT\\r\\n" to the server, disconnects the socket.
+    # @return [void]
+    def quit
+      command(:quit)
+      socket.close
+    end
+
+    private
+    def form_message(command, *args)
+      message = "#{command.to_s.upcase}"
+      message += " #{args.join(' ')}" unless args.empty?
+    end
+
+    def build_socket(options)
+      options.fetch(:socket) do
+        url = options.fetch(:url) do
+          raise ArgumentError "Must have :url or :socket"
+        end
+        port = options.fetch(:port, 119)
+        socket_factory = options.fetch(:socket_factory) { TCPSocket }
+        socket_factory.new(url, port)
+      end
+    end
+
+    def send_message(message)
+      socket.print "#{message}\r\n"
+    end
+
+    def get_line
+      line = socket.gets
+      line.chomp
+    end
+
+    def get_block_data
+      data = []
+      line = get_line
+      until line == '.'
+        data << line
+        line = get_line
+      end
+      data
+    end
+
+    def status_factory(*args)
+      NNTP::Status.new(*args)
+    end
+  end
+end

data/lib/nntp/group.rb

@@ -0,0 +1,3 @@
+module NNTP
+  Group = Struct.new(:name, :first_message, :last_message, :num_messages)
+end

data/lib/nntp/message.rb

@@ -0,0 +1,3 @@
+module NNTP
+  Message = Struct.new(:id, :subject, :group, :num)
+end

data/lib/nntp/session.rb

@@ -0,0 +1,139 @@
+require "nntp/group"
+require 'nntp/message'
+
+module NNTP
+  # Most of the action happens here.  This class describes the
+  # object the user interacts with the most.
+  # It is constructed by NNTP::open, but you can build your own
+  # if you like.
+  class Session
+    attr_reader :connection, :group
+    # @option options [NNTP::Connection, NNTP::SSLConnection] :connection
+    #   The connection object.
+    def initialize(options)
+      @group = nil
+      @connection = options.fetch(:connection) do
+        raise ArgumentError ":connection missing"
+      end
+      check_initial_status
+    end
+
+    # Authenticate to the server.
+    #
+    # @option args :user Username
+    # @option args :pass Password
+    # @option args :type (:standard)
+    #   Which authentication type to use.  Currently only
+    #   standard is supported.
+    # @return [NNTP::Status]
+    def auth(args)
+      auth_method = args.fetch(:type, :standard)
+      standard_auth(args) if auth_method == :standard
+    end
+
+    # Fetches and returns the list of groups from the server or, if it
+    # has already been fetched, returns the saved list.
+    # @return [Array<NNTP::Group>]
+    def groups
+      @groups ||= fetch_groups
+    end
+
+    # @!attribute [rw] group
+    #   Retrieves current group, or
+    #   sets current group, server-side, to assigned value.
+    #   @param [String] group_name The name of the group to be selected.
+    #   @return [NNTP::Group] The current group.
+    def group=(group_name)
+      connection.command(:group, group_name)
+      if status[:code] == 211
+        num, low, high, name = status[:msg].split
+        @group = group_factory(name, low.to_i, high.to_i, num.to_i)
+      end
+    end
+
+    # Fetch list of message numbers from a given group.
+    # @param group  The name of the group to list defaults to {#group #group.name}
+    # @param range (nil) If given, specifies the range of messages to retrieve
+    # @return [Array<NNTP::Message>] The list of messages
+    #   (only the message numbers will be populated).
+    # @see https://tools.ietf.org/html/rfc3977#section-6.1.2
+    def listgroup(*args)
+      messages = []
+      connection.query(:listgroup, *args) do |status, data|
+        if status[:code] == 211
+          data.each do |line|
+            message = Message.new
+            message.num = line.to_i
+            messages << message
+          end
+        end
+      end
+      messages
+    end
+
+    # Fetch list of messages from current group.
+    # @return [Array<NNTP::Message>] The list of messages
+    #   (The numbers AND the subjects will be populated).
+    def subjects
+      subjects = []
+      range ="#{group[:first_message]}-"
+      connection.query(:xhdr, "Subject", range) do |status, data|
+        if status[:code] == 221
+          data.each do |line|
+            message = Message.new
+            message.num, message.subject = line.split(' ', 2)
+            subjects << message
+          end
+        end
+      end
+      subjects
+    end
+
+    # The most recent status from the server.
+    def status
+      connection.status
+    end
+
+    # (see NNTP::Connection#quit)
+    def quit
+      connection.quit
+    end
+    private
+    def standard_auth(args)
+      connection.command(:authinfo, "USER #{args[:user]}")
+      if status[:code] == 381
+        connection.command(:authinfo, "PASS #{args[:pass]}")
+      elsif [281, 482, 502].include? status[:code]
+        status
+      end
+    end
+
+    def check_initial_status
+      raise "#{status}" if [400, 502].include? connection.get_status.code
+    end
+
+    def group_from_list(group_string)
+      params = group_string.split
+      name = params[0]
+      high_water_mark = params[1].to_i
+      low_water_mark = params[2].to_i
+      group_factory(name, low_water_mark, high_water_mark)
+    end
+
+    def group_factory(*args)
+      name = args[0]
+      low, high, num = args[1..-1].map { |arg| arg.to_i }
+      NNTP::Group.new(name, low, high, num)
+    end
+
+    def fetch_groups
+      group_list = []
+      connection.query :list do |status, list|
+        list.each do |group|
+          group_list << group_from_list(group)
+        end if status[:code] == 215
+      end
+      group_list
+    end
+  end
+end

data/lib/nntp/ssl_connection.rb

@@ -0,0 +1,22 @@
+require_relative 'connection'
+require 'openssl'
+require 'socket'
+
+module NNTP
+  class SSLConnection < Connection
+    private
+    def build_socket(args)
+      url = args.fetch(:url) do
+        raise ArgumentError ":url missing"
+      end
+      port = args.fetch(:port, 563)
+      socket = ssl_class.new(TCPSocket.new(url, port))
+      socket.connect
+      socket
+    end
+
+    def ssl_class
+      OpenSSL::SSL::SSLSocket
+    end
+  end
+end

data/lib/nntp/status.rb

@@ -0,0 +1,7 @@
+module NNTP
+  Status = Struct.new(:code, :msg) do
+    def to_s
+      "#{self[:code]} #{self[:msg]}"
+    end
+  end
+end

data/lib/nntp/version.rb

@@ -0,0 +1,3 @@
+module NNTP
+  VERSION = "0.0.5"
+end

data/nntp-client.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nntp/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "nntp-client"
+  gem.version       = NNTP::VERSION
+  gem.authors       = ["Michael Westbom"]
+  gem.email         = %w(totallymike@gmail.com)
+  gem.description   = %q{Gem to handle basic NNTP usage}
+  gem.summary       = %q{NNTP Client}
+  gem.homepage      = ""
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = %w(lib)
+
+  gem.add_development_dependency "rake"
+end

data/spec/Status_spec.rb

@@ -0,0 +1,13 @@
+require_relative "spec_helper"
+require "nntp/status"
+
+describe NNTP::Status do
+  describe "#to_s" do
+    it "knows how to render the server response it represents" do
+      foo = NNTP::Status.new(100, "foo")
+      foo.to_s.should eq "100 foo"
+      bar = NNTP::Status.new(200, "bar")
+      bar.to_s.should eq "200 bar"
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,26 @@
+require_relative "spec_helper"
+require 'nntp/connection'
+require 'nntp/status'
+
+describe NNTP::Connection do
+  let(:sock) { double }
+  let(:conn) { NNTP::Connection.new(:socket => sock)}
+
+  describe "#query" do
+    it "should properly break up multi-line data" do
+      sock.stub(:gets).and_return("123 status thing\r\n", "foo\r\n", "bar\r\n", ".\r\n")
+      sock.stub(:print)
+      response = conn.query(:foo)
+      response[:data].should eq %w(foo bar)
+      response[:status][:code].should eq 123
+      response[:status][:msg].should eq "status thing"
+    end
+    it "won't ask for data if an invalid status comes through" do
+      sock.should_receive(:gets).exactly(:once).and_return "400 error"
+      sock.stub(:print)
+      response = conn.query :foo
+      response[:status].should eq NNTP::Status.new(400, "error")
+      response[:data].should be nil
+    end
+  end
+end

data/spec/nntp_spec.rb

@@ -0,0 +1,73 @@
+require_relative 'spec_helper'
+require "nntp"
+require 'openssl'
+
+describe "NNTP" do
+
+  describe "::open" do
+    let(:sock) { double() }
+
+    describe "parameters" do
+      it "accepts an open socket in the parameter hash" do
+        conn = NNTP.open(:socket => sock)
+        conn.should_not be nil
+      end
+
+      it "will open its own socket if given a url and a port number" do
+        TCPSocket.should_receive(:new).with("nntp.example.org", 120)
+        conn = NNTP.open(:url => 'nntp.example.org', :port => 120)
+        conn.should_not be nil
+      end
+
+      it "uses port number 119 as a default if no port is specified" do
+        TCPSocket.should_receive(:new).with("nntp.example.org", 119)
+        NNTP.open(:url => 'nntp.example.org')
+      end
+
+      it "can take a class as :socket_factory alongside the url and port" do
+        foo = double()
+        foo.should_receive(:new).with('nntp.example.org', 119)
+        NNTP.open(:url => 'nntp.example.org', :socket_factory => foo)
+      end
+
+      describe ":ssl => true" do
+        let(:ssl_double) do
+          socket = double()
+          socket.stub(:connect)
+          socket
+        end
+        before(:each) do
+          OpenSSL::SSL::SSLSocket.should_receive(:new).and_return { ssl_double }
+        end
+
+        it "builds an SSL connection if :ssl => true" do
+          TCPSocket.stub(:new) { double() }
+          NNTP.open(:url => 'ssl-nntp.example.org', :ssl => true)
+        end
+
+        it 'uses port 563 as default' do
+          TCPSocket.should_receive(:new).with('ssl-nntp.example.org', 563)
+
+          NNTP.open(:url => 'ssl-nntp.example.org', :ssl => true)
+        end
+      end
+    end
+
+    describe "yield behavior" do
+      it "yields the session object if a block is given" do
+        sock.stub(:print)
+        sock.stub(:gets).and_return("205 closing connection\r\n")
+        sock.stub(:close)
+        expect { |b| NNTP.open( {:socket => sock}, &b ) }.to yield_control
+      end
+
+      it "automatically closes the connection if a block is given" do
+        conn = double()
+        conn.should_receive(:quit)
+        NNTP.open(:socket => sock) do |nntp|
+          nntp.stub(:connection) { conn }
+        end
+      end
+    end
+  end
+end

data/spec/session_spec.rb

@@ -0,0 +1,103 @@
+require_relative 'spec_helper'
+require 'nntp'
+
+describe NNTP::Session do
+  let(:sock) { double() }
+  let(:nntp) { NNTP.open(:socket => sock) }
+
+  describe "#initialize" do
+    it "will raise ArgumentError if no connection is found" do
+      expect { NNTP::Session.new() }.to raise_error(ArgumentError)
+    end
+
+    it "raises an error if the server presents an error message on connection" do
+      NNTP::Session.any_instance.unstub(:check_initial_status)
+      sock.stub(:gets) { "502 Permanently unavailable\r\n" }
+      expect { NNTP.open(:socket => sock) }.to raise_error
+    end
+  end
+
+  describe "authorization" do
+    it "will use authinfo style authentication if a user and pass are provided" do
+      NNTP::Session.any_instance.should_receive(:auth).
+          with({:user => 'foo', :pass => 'bar'}).and_call_original
+      NNTP::Session.any_instance.should_receive(:standard_auth)
+      NNTP.open(
+          :socket => sock,
+          :auth => {:user => 'foo', :pass => 'bar'}
+      )
+    end
+  end
+
+  describe "#groups" do
+    before(:each) do
+      @connection = double()
+      nntp.stub(:connection) { @connection }
+    end
+    it "should return a list of groups" do
+      @connection.stub(:query).and_yield({:code=>215}, ["alt.bin.foo 2 1 y", "alt.bin.bar 2 1 n"])
+      groups = [ NNTP::Group.new('alt.bin.foo', 1, 2), NNTP::Group.new('alt.bin.bar', 1, 2)]
+      nntp.groups.should eq groups
+    end
+
+    it "will return an empty list if there are no groups" do
+      @connection.stub(:query).and_yield({:code => 215}, [])
+      nntp.groups.should eq []
+    end
+  end
+
+  describe "#group=" do
+    before(:each) do
+      sock.stub(:print) {}
+      sock.stub(:gets) { "211 2 1 2 alt.bin.foo\r\n"}
+    end
+
+    it "can change current newsgroup with the assignment operator and a string" do
+      nntp.group = "alt.bin.foo"
+      nntp.group.should eq NNTP::Group.new("alt.bin.foo", 1, 2, 2)
+    end
+    it "does not change the current group if the new one is not found" do
+      sock.stub(:gets) { "411 group not found\r\n" }
+      nntp.group.should eq nil
+      nntp.group = "alt.does.not.exist"
+      nntp.group.should eq nil
+    end
+  end
+
+  describe "#messages" do
+    it "retrieves the list of messages in the current group" do
+      sock.stub(:print)
+      NNTP::Connection.any_instance.stub(:get_status) do
+        NNTP::Status.new(211, "2 1 2 alt.bin.foo list follows")
+      end
+      NNTP::Connection.any_instance.stub(:get_block_data) { %w(1 2) }
+      nntp.stub(:group) { NNTP::Group.new("alt.bin.foo", 1, 2, 2) }
+
+      message_numbers(nntp.listgroup).should eq [1, 2]
+    end
+    it "retrieves the list of messages from a given group" do
+      sock.stub(:print)
+      NNTP::Connection.any_instance.should_receive(:query).with(:listgroup, "alt.bin.bar").
+          and_call_original
+      NNTP::Connection.any_instance.stub(:get_status) do
+        NNTP::Status.new(211, "3 1 3 alt.bin.bar list follows")
+      end
+      NNTP::Connection.any_instance.stub(:get_block_data) { %w(1 2 3) }
+
+      message_numbers(nntp.listgroup("alt.bin.bar")).should eq [1, 2, 3]
+    end
+  end
+  describe "subjects" do
+    let(:subjects) { ["1 Foo bar", "2 Baz bang"] }
+    it "retrieves a list of subjects from the current group" do
+      sock.stub(:print)
+      NNTP::Connection.any_instance.stub(:get_status) do
+        NNTP::Status.new(221, "Header follows")
+      end
+      NNTP::Connection.any_instance.stub(:get_block_data) { subjects }
+      nntp.stub(:group) { NNTP::Group.new("alt.bin.foo", 1, 2, 2) }
+
+      message_subjects(nntp.subjects).should eq ['Foo bar', 'Baz bang']
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "rspec"
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+RSpec.configure do |config|
+  config.before(:each) do
+    NNTP::Session.any_instance.stub(:check_initial_status) { nil }
+  end
+end
+
+def message_numbers(list)
+  list.map { |msg| msg.num }
+end
+
+def message_subjects(list)
+  list.map {|msg| msg.subject }
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: nntp-client
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Michael Westbom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem to handle basic NNTP usage
+email:
+- totallymike@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/NNTPClient.rb
+- lib/article.rb
+- lib/nntp.rb
+- lib/nntp/connection.rb
+- lib/nntp/group.rb
+- lib/nntp/message.rb
+- lib/nntp/session.rb
+- lib/nntp/ssl_connection.rb
+- lib/nntp/status.rb
+- lib/nntp/version.rb
+- nntp-client.gemspec
+- spec/Status_spec.rb
+- spec/connection_spec.rb
+- spec/nntp_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: NNTP Client
+test_files:
+- spec/Status_spec.rb
+- spec/connection_spec.rb
+- spec/nntp_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+has_rdoc: