atom-tools 1.0.0 → 2.0.0

metadata

@@ -1,39 +1,35 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: atom-tools
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2007-11-10 00:00:00 -07:00
-summary: Tools for working with Atom Entries, Feeds and Collections
-require_paths: 
-- lib
-email: 
-homepage: 
-rubyforge_project: 
-description: 
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 2.0.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Brendan Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-03-28 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
 files: 
 - COPYING
 - README
 - Rakefile
 - setup.rb
-- bin/atom-client.rb
+- bin/atom-grep
+- bin/atom-post
+- bin/atom-purge
+- bin/atom-cp
 - test/test_constructs.rb
 - test/runtests.rb
 - test/test_feed.rb
@@ -48,26 +44,40 @@ files:
 - test/test_http.rb
 - test/test_general.rb
 - lib/atom
-- lib/atom/yaml.rb
+- lib/atom/cache.rb
 - lib/atom/feed.rb
 - lib/atom/text.rb
 - lib/atom/collection.rb
 - lib/atom/service.rb
 - lib/atom/entry.rb
-- lib/atom/xml.rb
+- lib/atom/tools.rb
 - lib/atom/element.rb
 - lib/atom/http.rb
-test_files: 
-- test/runtests.rb
+has_rdoc: true
+homepage: 
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: 
-- README
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Tools for working with Atom Entries, Feeds and Collections
+test_files: 
+- test/runtests.rb

data/bin/atom-client.rb

@@ -1,275 +0,0 @@
-#!/usr/bin/ruby
-
-require "optparse"
-
-options = {}
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: #{$0} [options]"
-
-  opts.on("-c", "--coll-url [URL]", "URL of the collection you would like to manipulate") do |url|
-    options[:url] = url
-  end
-
-  opts.on("-u", "--user [USERNAME]", "Username to authenticate with") do |user|
-    options[:user] = user
-  end
-
-  opts.on("-p", "--password [PASSWORD]", "Password to authenticate with") do |pass|
-    options[:pass] = pass
-  end
-
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-end.parse!
-
-require "tempfile"
-
-require "atom/yaml"
-require "atom/service"
-require "atom/http"
-
-require "rubygems"
-require "bluecloth"
-
-require "time"
-
-require 'yaml'
-
-class Tempfile
-  def edit_externally
-    self.close
-
-    system("#{EDITOR} #{self.path}")
-
-    self.open
-  end
-end
-
-class String
-  def edit_externally
-    tempfile = Tempfile.new("entry")
-    tempfile.puts self
-
-    tempfile.edit_externally
-
-    ret = tempfile.read
-    tempfile.delete
-
-    ret
-  end
-end
-
-class Atom::Entry
-  def prepare_for_output
-    filter_hook
-
-    updated!
-  end
-
-  def filter_hook
-    # so much for actual text content...
-    if @content and @content["type"] == "text"
-      self.content = BlueCloth.new( @content.to_s ).to_html
-      @content["type"] = "xhtml"
-    end
-  end
-
-  def edit
-    yaml = YAML.load(self.to_yaml)
-   
-    # human readability
-    yaml.delete "id"
-
-    if yaml["links"]
-      yaml["links"].find_all { |l| l["rel"] == "alternate" or l["rel"] == "edit" }.each { |l| yaml["links"].delete(l) }
-      yaml.delete("links") if yaml["links"].empty?
-    end
-    
-    new_yaml, entry = write_entry(yaml.to_yaml)
-    
-    entry.id = self.id
-
-    [new_yaml["slug"], entry]
-  end
-end
-
-# maybe this should handle displaying the list too.
-def choose_from list
-  item = nil
-  itemno = nil
-
-  # oh wow this is pathetic
-  until item
-    if itemno
-      puts "try picking a number on the list."
-    end
-
-    print "? "
-    itemno = $stdin.gets.chomp
-
-    item = list[itemno.to_i]
-  end
-
-  item
-end
-
-def choose_entry_url coll
-  puts "which entry?"
-
-  coll.entries.each_with_index do |entry, index|
-    puts "#{index}: #{entry.title}"
-  end
-
-  entry = choose_from coll.entries
-
-  edit_link = entry.links.find do |link|
-    link["rel"] = "edit"
-  end
-
-  edit_link["href"]
-end
-
-def write_entry(editstring = "")
-  begin
-    edited = editstring.edit_externally
-
-    if edited == editstring
-      puts "You didn't edit anything, aborting."
-      exit
-    end
-
-    yaml = YAML.load(edited)
-
-    entry = Atom::Entry.from_yaml yaml
-
-    entry.prepare_for_output
-
-    # XXX disabled until the APP WG can decide what a valid entry is
-=begin
-    valid, message = entry.valid?
-    unless valid
-      print "entry is invalid (#{message}). post anyway? (y/n)? "
-      (gets.chomp == "y") || (raise Atom::InvalidEntry.new)
-    end
-=end
-
-    # this has to be here ATM to we can detect malformed atom:content
-    puts entry.to_s
-  rescue ArgumentError,REXML::ParseException => e
-    puts e
-    
-    puts "press enter to edit again..."
-    $stdin.gets
-
-    editstring = edited
-
-    retry
-  rescue Atom::InvalidEntry
-    editstring = edited
-    retry
-  end
-
-  [yaml, entry]
-end
-
-module Atom
-  class InvalidEntry < RuntimeError; end
-end
-
-EDITOR = ENV["EDITOR"] || "env vim"
-
-http = Atom::HTTP.new
-
-url = if options[:url]
-  options[:url]
-else
-  yaml = YAML.load(File.read("#{ENV["HOME"]}/.atom-client"))
-  collections = yaml["collections"]
-
-  puts "which collection?"
-
-  collections.keys.each_with_index do |name,index|
-    puts "#{index}: #{name}"
-  end
-
-  tmp = choose_from collections.values
-
-  http.user = tmp["user"] if tmp["user"]
-  http.pass = tmp["pass"] if tmp["pass"]
-
-  tmp["url"]
-end
-
-http.user = options[:user] if options[:user]
-http.pass = options[:pass] if options[:pass]
-
-# this is where all the Atom stuff starts
-
-coll = Atom::Collection.new(url, http)
-
-# XXX generate a real id
-CLIENT_ID = "http://necronomicorp.com/nil"
-
-new = lambda do
-  entry = Atom::Entry.new
-  
-  entry.title = ""
-  entry.content = ""
-
-  slug, entry = entry.edit
-
-  entry.id = CLIENT_ID
-  entry.published = Time.now.iso8601
-
-  res = coll.post! entry, slug
-
-  # XXX error recovery here, lost updates suck
-  puts res.body
-end
-
-edit = lambda do
-  coll.update!
-
-  coll.entries.each_with_index do |entry,idx|
-    puts "#{idx}: #{entry.title}"
-  end
-
-  entry = choose_from(coll.entries) { |entry| entry.title }
-
-  url = entry.edit_url
-
-  raise "this entry has no edit link" unless url
-
-  entry = http.get_atom_entry url
-
-  slug, new_entry = entry.edit
-
-  res = coll.put! new_entry, url
-
-  # XXX error recovery here, lost updates suck
-  puts res.body
-end
-
-delete = lambda do
-  coll.update!
-
-  coll.entries.each_with_index do |entry,idx|
-    puts "#{idx} #{entry.title}"
-  end
-
-  entry = choose_from(coll.entries)
-  res = coll.delete! entry
-
-  puts res.body
-end
-
-actions = [ new, edit, delete ]
-
-puts "0: new entry"
-puts "1: edit entry"
-puts "2: delete entry"
-
-choose_from(actions).call

data/lib/atom/xml.rb

@@ -1,213 +0,0 @@
-require "atom/entry"
-require "atom/feed"
-require "uri"
-
-class Atom::ParseError < StandardError; end
-
-# Two big, interrelated problems:
-#
-# * I probably shouldn't be playing around in REXML's namespace
-# * REXML isn't a great parser, and other options would be nice
-#
-# This shouldn't be hard to do, it's just tedious and non-critical
-module REXML # :nodoc: all
-  class Document
-    def to_atom_entry base = ""
-      raise Atom::ParseError unless self.root
-      self.root.to_atom_entry base
-    end
-    def to_atom_feed base = ""
-      raise Atom::ParseError unless self.root
-      self.root.to_atom_feed base
-    end
-  end
-  class Element
-    def get_atom_element name
-      XPath.first(self, "./atom:#{name}", { "atom" => Atom::NS })
-    end
-    
-    def each_atom_element name
-      XPath.each(self, "./atom:#{name}", { "atom" => Atom::NS }) do |elem|
-        yield elem
-      end
-    end
-   
-    def copy_extensions(coll)
-      # XXX also look for attributes
-      children.find_all do |child| 
-        child.respond_to? :namespace and child.namespace != Atom::NS 
-      end.each do |elem|
-        e = elem.dup
-
-        # because namespaces might be defined on parents
-        unless e.prefix.empty?
-          e.add_namespace e.prefix, e.namespace
-        end
-
-        coll << e
-      end
-    end
-
-    # get the text content of a descendant element in the Atom namespace
-    def get_atom_text name
-      elem = get_atom_element name
-      if elem
-        elem.text
-      else
-        nil
-      end
-    end
-  
-    # a workaround for the odd way in which REXML handles namespaces
-    # returns the value of the attribute +name+ that's in the same namespace as this element
-    def ns_attr name
-      if not self.prefix.empty?
-        attr = self.prefix + ":" + name
-      else
-        attr = name
-      end
-
-      self.attributes[attr]
-    end
-
-    def fill_text_construct(entry, name)
-      text = get_atom_element(name)
-      if text
-        type = text.ns_attr("type")
-        src = text.ns_attr("src")
-
-        if src and name == :content
-          # the only content is out of line
-          entry.send( "#{name}=".to_sym, "")
-          entry.send(name.to_sym)["src"] = src
-        elsif type == "xhtml"
-          div = XPath.first(text, "./xhtml:div", { "xhtml" => XHTML::NS })
-          unless div
-            raise Atom::ParseError, "Refusing to parse type='xhtml' with no <div/> wrapper"
-          end
-
-          # content is the serialized content of the <div> wrapper
-          entry.send( "#{name}=".to_sym, div )
-        else
-          raw = text.text || ""
-          entry.send( "#{name}=", raw )
-        end
-
-        if text.attributes["xml:base"]
-          entry.send(name.to_sym).base = text.attributes["xml:base"]
-        end
-
-        if type and type != "text"
-          entry.send(name.to_sym)["type"] = type
-        end
-      end
-    end
-
-    def fill_elem_element(top, kind)
-      each_atom_element(kind) do |elem|
-        person = top.send("#{kind}s".to_sym).new
-
-        ["name", "uri", "email"].each do |name|
-          person.send("#{name}=".to_sym, elem.get_atom_text(name))
-        end
-      end
-    end
-
-    def fill_attr_element(top, array, kind)
-      each_atom_element(kind) do |elem|
-        thing = array.new
-
-        thing.class.attrs.each do |name,req|
-          value = elem.ns_attr name.to_s
-          if value and name == :href
-            begin
-              thing[name.to_s] = (top.base.to_uri + value).to_s
-            rescue URI::BadURIError
-              raise "Document contains relative URIs and no xml:base. You must pass a base URI to #parse()"
-            end
-          elsif value
-            thing[name.to_s] = value
-          end
-        end
-      end
-    end
-
-    # 'base' is the URI that you fetched this document from.
-    def to_atom_entry base = ""
-      unless self.name == "entry" and self.namespace == Atom::NS
-        raise Atom::ParseError, "this isn't an atom:entry! (name: #{self.name}, ns: #{self.namespace})"
-      end
-
-      entry = Atom::Entry.new
-
-      entry.base = if attributes["xml:base"]
-        (URI.parse(base) + attributes["xml:base"]).to_s
-      else
-        # go with the URL we were passed in
-        base
-      end
-
-      # Text constructs
-      entry.class.elements.find_all { |n,k,r| k.ancestors.member? Atom::Text }.each do |n,k,r|
-        fill_text_construct(entry, n)
-      end
-
-      ["id", "published", "updated"].each do |name|
-        entry.send("#{name}=".to_sym, get_atom_text(name))
-      end
-
-      ["author", "contributor"].each do |type|
-        fill_elem_element(entry, type)
-      end
-
-      {"link" => entry.links, "category" => entry.categories}.each do |k,v|
-        fill_attr_element(entry, v, k)
-      end
-      
-      copy_extensions(entry.extensions)
-
-      entry
-    end
-
-    # 'base' is the URI that you fetched this document from.
-    def to_atom_feed base = ""
-      unless self.name == "feed" and self.namespace == Atom::NS
-        raise Atom::ParseError, "this isn't an atom:feed! (name: #{self.name}, ns: #{self.namespace})"
-      end
-
-      feed = Atom::Feed.new
-      
-      feed.base = if attributes["xml:base"]
-        (URI.parse(base) + attributes["xml:base"]).to_s
-      else
-        # go with the URL we were passed in
-        base
-      end
-      
-      # Text constructs
-      feed.class.elements.find_all { |n,k,r| k.ancestors.member? Atom::Text }.each do |n,k,r|
-        fill_text_construct(feed, n)
-      end
-
-      ["id", "updated", "generator", "icon", "logo"].each do |name|
-        feed.send("#{name}=".to_sym, get_atom_text(name))
-      end
-
-      ["author", "contributor"].each do |type|
-        fill_elem_element(feed, type)
-      end
-
-      {"link" => feed.links, "category" => feed.categories}.each do |k,v|
-        fill_attr_element(feed, v, k)
-      end
-     
-      each_atom_element("entry") do |elem|
-        feed << elem.to_atom_entry(feed.base)
-      end
-
-      copy_extensions(feed.extensions)
-
-      feed
-    end
-  end
-end