console_update 0.1.2

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2009 Gabriel Horner
+
+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.rdoc

@@ -0,0 +1,112 @@
+== Description
+
+Updates records from the console via your preferred editor. You can update a record's columns as
+well as <i>any attribute</i> that has accessor methods.  Records are edited via a temporary file and
+once saved, the records are updated. Records go through a filter before and after editing the file. Yaml is
+the default filter, but you can define your own filter simply with a module and 2 expected methods.
+See ConsoleUpdate::Filter for more details.
+
+== Install
+
+Install as a gem
+
+    bash> gem install console_update
+
+    # add in config/environment.rb
+    config.gem "console_update"
+
+Or as a plugin
+
+    bash> script/plugin install git://github.com/cldwalker/console_update.git
+
+== Examples
+
+For a given model Url, update your records as you please:
+
+  bash> script/console
+
+  # Update a record from the object
+  >> Url.first.console_update
+
+  # Update a group of records
+  >> records = Url.all :limit=>10
+  >> Url.console_update records
+
+  # Find and update by a given id
+  >> Url.find_and_console_update 10
+
+  # Update through any named_scope ie tagged_with()
+  >> Url.tagged_with("sweetness").console_update
+  
+== Setup
+
+Define your editor if not already picked up by environment variable $EDITOR:
+
+  ConsoleUpdate.editor = 'vim'
+
+Configure model(s) to update from the console:
+
+  class Url
+    can_console_update
+  end
+
+By default, can_console_update() has sensical defaults for what attributes to update.
+But you can setup your own defaults as needed:
+
+  can_console_update :only=>%w{column1 column2 relation_accessor1}
+  can_console_update :except=>%w{column2}
+
+To use the named_scope chaining, enable it once.
+  ConsoleUpdate.enable_named_scope
+
+== More Examples
+
+Although console_update() uses the default editable columns, it can take options to override
+these as needed. Note these options can be passed to any of the console_update-like methods shown
+above:
+
+  records = Url.all :limit=>100
+  # Only edit this one attribute
+  Url.console_update records, :only=>%w{description}
+  # Edit all the default attributes except this one
+  Url.console_update records, :except=>%w{description}
+
+As mentioned above, any attribute can be edited. This means it's possible to edit associated
+values as well as column values.
+
+Say we have a Url that has many tags and accessor methods to edit them ie tag_list() and
+tag_list=():
+
+  @url.tag_list = ['tag1', 'tag2']
+  @url.save
+  @url.tag_list # =>['tag1', 'tag2']
+
+By simply passing 'tag_list' as another attribute to console_update() or can_console_update(),
+we can edit these associated values:
+   class Url
+     can_console_update :only=>%w{column1 column2 tag_list}
+   end
+
+   Url.console_update records, :only=>%w{column1 column2 tag_list}
+
+== Caveats
+So should you be updating production records with this plugin? Yes and no.
+Yes, if you're updating some simple string/text values. If editing more complex objects
+ie non-string objects and associated objects, try edge cases to ensure the updates work as expected.
+Although this plugin already comes with decent tests, I'm always open to patches for edge cases I
+may have missed.
+
+== Motivation
+The need for editing speed in my {console-based project}[http://github.com/cldwalker/tag-tree].
+
+== Issues/Bugs
+Please report them {on github}[http://github.com/cldwalker/console_update/issues].
+
+== Links
+* http://tagaholic.me/2009/02/28/Console-Update-With-Your-Editor.html
+
+== Todo
+
+* Have a config file as an alternative configuration method which
+  doesn't clutter models with can_console_update() calls.
+* Make ORM-agnostic.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
+    t.verbose = true
+  end
+rescue LoadError
+  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "console_update"
+    s.summary = "A rails plugin which allows you to edit your database records via the console and your favorite editor."
+    s.description = "Updates records from the console via your preferred editor. You can update a record's columns as well as any attribute that has accessor methods. Records are edited via a temporary file and once saved, the records are updated. Records go through a filter before and after editing the file. Yaml is the default filter, but you can define your own filters."
+    s.email = "gabriel.horner@gmail.com"
+    s.homepage = "http://tagaholic.me/console_update/"
+    s.authors = ["Gabriel Horner"]
+    s.rubyforge_project = 'tagaholic'
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+    s.files = FileList["Rakefile", "VERSION.yml", "README.rdoc", "init.rb", "LICENSE.txt", "{rails,lib,test}/**/*"]
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 2

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'rails', 'init.rb')

data/lib/console_update/filter/yaml.rb

@@ -0,0 +1,16 @@
+require 'yaml'
+
+module ConsoleUpdate
+  class Filter    
+    module Yaml
+      def string_to_hashes(string)
+        YAML::load(string)
+      end
+    
+      def hashes_to_string(hashes)
+        hashes.to_yaml
+      end
+    end
+  end
+end
+  

data/lib/console_update/filter.rb

@@ -0,0 +1,40 @@
+require 'console_update/filter/yaml'
+
+module ConsoleUpdate
+  # A filter converts database records to a string and vice versa.
+  # A database record is represented as a hash of attributes with stringified keys.
+  # Each hash should have an id attribute to map it to its database record.
+  # To create your own filter, create a module in the ConsoleUpdate::Filter namespace.
+  # Although the name of the module can be anything, if only the first letter is capitalized
+  # then a simple lowercase name of the filter can be used with ConsoleUpdate.filter() (ie :yaml
+  # instead of Yaml). For now, new filters have to be manually loaded/required.
+  #
+  # A filter should have two methods defined, string_to_hashes() and hashes_to_string().
+  # For a good example of a filter see ConsoleUpdate::Filter::Yaml.
+  #
+  class Filter
+    class AbstractMethodError < StandardError; end
+    class FilterNotFoundError < StandardError; end
+    
+    # Creates a filter given a type.
+    def initialize(filter_type)
+      @filter_type = filter_type
+      begin
+        filter_module = self.class.const_get(filter_type.to_s.gsub(/^([a-z])/) {|e| $1.upcase })
+        self.extend(filter_module)
+      rescue NameError
+        raise FilterNotFoundError
+      end
+    end
+    
+    # Takes an an array of hashes representing database records and converts them to a string for editing.
+    def hashes_to_string(hashes)
+      raise AbstractMethodError
+    end
+    
+    # Takes the string from the updated file and converts back to an array of hashes.
+    def string_to_hashes(string)
+      raise AbstractMethodError
+    end
+  end
+end

data/lib/console_update/named_scope.rb

@@ -0,0 +1,21 @@
+module ConsoleUpdate
+  
+  # Adds a global scoped method, console_update(), which can be chained
+  # to the end of any named scopes.
+  # For example, if Url has a named scope :tagged_with:
+  #   Url.tagged_with('physics').console_update
+  def self.enable_named_scope  
+    ActiveRecord::NamedScope::Scope.send :include, NamedScope
+  end
+  
+  module NamedScope #:nodoc:
+    def console_update(options={})
+      records = send(:proxy_found)
+      unless records.empty?
+        records[0].class.console_update(records, options)
+      else
+        []
+      end
+    end
+  end
+end

data/lib/console_update.rb

@@ -0,0 +1,149 @@
+current_dir = File.dirname(__FILE__)
+$:.unshift(current_dir) unless $:.include?(current_dir) || $:.include?(File.expand_path(current_dir))
+require 'tempfile'
+require 'console_update/named_scope'
+require 'console_update/filter'
+
+module ConsoleUpdate
+  class <<self; attr_accessor(:filter, :editor); end
+  def self.included(base) #:nodoc:
+    @filter = :yaml
+    @editor = ENV["EDITOR"]
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+    # Enable a model to be updated via the console and an editor. By default editable
+    # attributes are columns with text, boolean or integer-like values.
+    # ==== Options:
+    # [:only] Sets these attributes as the default editable attributes.
+    # [:except] Sets the default editable attributes as normal except for these attributes.
+    # [:editor] Overrides global editor for just this model.
+    def can_console_update(options={})
+      cattr_accessor :console_editor
+      self.console_editor = options[:editor] || ConsoleUpdate.editor
+      
+      cattr_accessor :default_editable_attributes
+      if options[:only]
+        self.default_editable_attributes = options[:only]
+      elsif options[:except]
+        self.default_editable_attributes = self.column_names.select {|e| !options[:except].include?(e) }
+      else
+        self.default_editable_attributes = get_default_editable_attributes 
+      end
+      
+      extend SingletonMethods
+      send :include, InstanceMethods
+    end
+    
+    private
+    def default_types_to_exclude
+      [:datetime, :timestamp, :binary, :time, :timestamp]
+    end
+    
+    def get_default_editable_attributes
+      self.columns.select {|e| !default_types_to_exclude.include?(e.type) }.map(&:name)
+    end
+  end
+  
+  module SingletonMethods
+    # This is the main method for updating records.
+    # All other update-like methods pass their options through here.
+    # ==== Options:
+    # [:only] Only edit these attributes.
+    # [:except] Edit default attributes except for these.
+    # Examples:
+    #   records = Url.all :limit=>10
+    #   Url.console_update records
+    #   Url.console_update records, :only=>%w{column1}
+    #   Url.console_update records, :except=>%w{column1}
+    def console_update(records, options={})
+      begin
+        editable_attributes_array = records.map {|e| e.console_editable_attributes(options) }
+        editable_string = filter.hashes_to_string(editable_attributes_array)
+        new_attributes_array = editor_update(editable_string)
+        records.each do |record|
+          if (record_attributes = new_attributes_array.detect {|e| e['id'] == record.id })
+            record.update_console_attributes(record_attributes)
+          end
+        end
+      rescue ConsoleUpdate::Filter::AbstractMethodError
+        puts "Undefined filter method for #{ConsoleUpdate::filter} filter"
+      rescue Test::Unit::AssertionFailedError=>e
+        raise e
+      rescue Exception=>e
+        puts "Some record(s) didn't update because of this error: #{e}"
+      ensure
+        #this attribute should only last duration of method
+        reset_editable_attribute_names
+      end
+    end
+    
+    def filter #:nodoc:
+      @filter ||= ConsoleUpdate::Filter.new(ConsoleUpdate.filter)
+    end
+    
+    # Console updates a record given an id.
+    def find_and_console_update(id, options={})
+      console_update([find(id)], options)
+    end
+    
+    # :stopdoc:
+    def editor_update(string) 
+      tmpfile = Tempfile.new('console_update')
+      File.open(tmpfile.path, 'w+') {|f| f.write(string)}
+      system(console_editor, tmpfile.path)
+      updated_string = File.read(tmpfile.path)
+      filter.string_to_hashes(updated_string)
+    end
+    
+    def reset_editable_attribute_names; @editable_attribute_names = nil ; end
+    
+    def editable_attribute_names(options={})
+      unless @editable_attribute_names
+        @editable_attribute_names = if options[:only]
+          options[:only]
+        elsif options[:except]
+          default_editable_attributes - options[:except]
+        else
+          default_editable_attributes
+        end
+      end
+      @editable_attribute_names
+    end
+    # :startdoc:
+  end
+  
+  module InstanceMethods
+    # Console updates the object.
+    def console_update(options={}) 
+      self.class.console_update([self], options)
+    end
+    
+    # :stopdoc:
+    def update_console_attributes(new_attributes)
+      # delete if value is the same or is an attribute that isn't supposed to be edited
+      new_attributes.delete_if {|k,v|
+        attributes[k] == v || !self.class.editable_attribute_names.include?(k)
+      }
+      new_attributes.each do |k, v|  
+        send("#{k}=", v)  
+      end
+      save
+    end
+    
+    def get_console_attributes(attribute_names)
+      attribute_names.inject({}) {|h,e|
+        h[e] = attributes.has_key?(e) ? attributes[e] : send(e)
+        h
+      }
+    end
+    
+    def console_editable_attributes(options)
+      fresh_attributes = get_console_attributes(self.class.editable_attribute_names(options))
+      fresh_attributes['id'] ||= self.id
+      fresh_attributes
+    end
+    #:startdoc:
+  end  
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+require 'console_update'
+ActiveRecord::Base.send :include, ConsoleUpdate

data/test/console_update_test.rb

@@ -0,0 +1,133 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ConsoleUpdateTest < Test::Unit::TestCase
+  def stub_editor_update_with_records(new_records, options={})
+    Bird.stub!(:system) { |editor, file|
+      if options[:expected_attributes]
+        YAML::load_file(file)[0].keys.sort.should == options[:expected_attributes]
+      end
+      File.open(file, 'w+') {|f| f.write(new_records.to_yaml)}
+    }
+  end
+  
+  def create_big_bird(attributes={})
+    @big_bird = Bird.create({:name=>"big bird"}.update(attributes))
+  end
+  
+  context "can_console_update" do
+    test "sets default_editable_attributes" do
+      Bird.column_names.include?('bin').should be(true)
+      Bird.default_editable_attributes.empty?.should be(false)
+      Bird.default_editable_attributes.include?('bin').should be(false)
+    end
+        
+    test "sets default_editable_attributes with only option" do
+      Bird.can_console_update :only=>['description']
+      Bird.default_editable_attributes.should == ['description']
+    end
+    
+    test "sets default_editable_attributes with except option" do
+      Bird.can_console_update :except=>['description']
+      Bird.default_editable_attributes.sort.should == ["bin", "created_at", "id", "name", "nickname", "updated_at"]
+    end
+    
+    test "sets console_editor with editor option" do
+      Bird.can_console_update :editor=>'vi'
+      Bird.console_editor.should == 'vi'
+    end
+  end
+  
+  context "console_update" do
+    before(:all) {|e| Bird.can_console_update }
+    before(:each) {|e| Bird.delete_all }
+    
+    test "updates multiple records" do
+      create_big_bird
+      @dodo = Bird.create(:name=>"dodo")
+      new_records = [@big_bird.attributes.update('name'=>'big birded'), @dodo.attributes.update('name'=>'dudu')]
+      stub_editor_update_with_records(new_records)
+      Bird.console_update([@big_bird, @dodo])
+      @big_bird.reload.name.should == 'big birded'
+      @dodo.reload.name.should == 'dudu'
+    end
+    
+    test "doesn't modify missing attributes" do
+      create_big_bird(:nickname=>'doofus')
+      # this record is missing all it's attributes except name
+      new_records = [{'name'=>'big birded', 'id'=>@big_bird.id}]
+      stub_editor_update_with_records(new_records)
+      Bird.console_update([@big_bird])
+      @big_bird.reload.nickname.should == 'doofus'
+      @big_bird.name.should == 'big birded'
+    end
+    
+    test "updates attr_protected column" do
+      create_big_bird
+      new_records = [@big_bird.attributes.update('description'=>"it's big")]
+      stub_editor_update_with_records(new_records)
+      Bird.console_update([@big_bird])
+      @big_bird.reload.description.should == "it's big"
+    end
+    
+    test "rescues exception" do
+      create_big_bird
+      Bird.stub!(:system) {|*args| raise "error" }
+      capture_stdout {
+        Bird.console_update([@big_bird])
+      }
+    end
+    
+    test "via instance method" do
+      create_big_bird
+      stub_editor_update_with_records([@big_bird.attributes.update('name'=>'small bird')])
+      @big_bird.console_update
+      @big_bird.reload.name.should == 'small bird'
+    end
+    
+    test "via find_and_console_update" do
+      create_big_bird
+      stub_editor_update_with_records([@big_bird.attributes.update('name'=>'small bird')])
+      Bird.find_and_console_update(@big_bird.id)
+      @big_bird.reload.name.should == 'small bird'
+    end
+    
+    test "with only option only edits those columns" do
+      create_big_bird(:description=>"something")
+      stub_editor_update_with_records([@big_bird.attributes.update('name'=>'big birded')], :expected_attributes=>['id', 'name'])
+      Bird.console_update([@big_bird], :only=>['name'])
+      @big_bird.reload.name.should == 'big birded'
+    end
+    
+    test "with except option edits all columns except those columns" do
+      create_big_bird(:description=>"something")
+      expected_attributes = ["id", "name", "nickname"]
+      stub_editor_update_with_records([@big_bird.attributes.update('name'=>'big birded')], :expected_attributes=>expected_attributes)
+      Bird.console_update([@big_bird], :except=>['description'])
+      @big_bird.reload.name.should == 'big birded'
+    end
+    
+    test "sets a non column attribute" do
+      create_big_bird
+      stub_editor_update_with_records([{'tag_list'=>["yellow"], 'id'=>@big_bird.id}], :expected_attributes=>["id","tag_list"])
+      Bird.console_update([@big_bird], :only=>["tag_list"] )
+      @big_bird.tag_list.should == ['yellow']
+    end
+    
+    test "updates and deletes extra attributes added in editor" do
+      create_big_bird
+      stub_editor_update_with_records([{'name'=>'big birded','nickname'=>'doofird', 'id'=>@big_bird.id}])
+      Bird.console_update([@big_bird], :only=>['name'])
+      @big_bird.reload.nickname.should_not == 'doofird'
+    end
+  end
+  
+  test "editable_attribute_names expire per console_update" do
+    create_big_bird
+    stub_editor_update_with_records([{'name'=>'big birded', 'id'=>@big_bird.id}], :expected_attributes=>["id", "name"])
+    Bird.console_update([@big_bird], :only=>['name'])
+    @big_bird.instance_eval("@editable_attribute_names").should == nil
+    #these expected_attributes would fail if @editable_attribute_names wasn't reset for each console_update()
+    stub_editor_update_with_records([{'description'=>'big birded','id'=>@big_bird.id}], :expected_attributes=>["description", "id"])
+    Bird.console_update([@big_bird], :only=>['description'])
+  end
+end

data/test/filter_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+#test filter
+module ConsoleUpdate
+  class Filter
+    module Test
+    end
+  end
+end
+
+class ConsoleUpdate::FilterTest < Test::Unit::TestCase
+  test "incorrect filter name raises FilterNotFoundError" do
+    assert_raises(ConsoleUpdate::Filter::FilterNotFoundError) {
+      ConsoleUpdate::Filter.new(:blah)
+    }
+  end
+  
+  test "filter without proper methods raises AbstractMethodError" do
+    assert_raises(ConsoleUpdate::Filter::AbstractMethodError) {
+      ConsoleUpdate::Filter.new(:test).string_to_hashes('blah')
+    }    
+  end
+
+  test "extends filter for a non-lowercase filter name correctly" do
+    filter_meta_class = ConsoleUpdate::Filter.new("Test").instance_eval("class<<self; self;end")
+    filter_meta_class.ancestors.include?(ConsoleUpdate::Filter::Test).should be(true)
+  end
+end

data/test/named_scope_test.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ConsoleUpdate::NamedScopeTest < Test::Unit::TestCase
+  test "chained console_update calls actual named_scope" do
+    big_bird = Bird.create({:name=>"big bird"})
+    Bird.stub!(:system) { |editor, file|
+      YAML::load_file(file)[0].keys.sort.should == Bird.default_editable_attributes.sort
+    }
+    ConsoleUpdate.enable_named_scope
+    Bird.just_big_bird.console_update
+  end
+end

data/test/schema.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :birds do |t|
+    t.string  :name, :nickname
+    t.text :description
+    t.timestamps
+    t.binary :bin
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'activerecord'
+require 'test/unit'
+require 'context' #gem install jeremymcanally-context -s http://gems.github.com
+require 'matchy' #gem install jeremymcanally-matchy -s http://gems.github.com
+require 'stump' #gem install jeremymcanally-stump -s http://gems.github.com
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(File.dirname(__FILE__), '..', 'init')
+
+#Setup logger
+require 'logger'
+# ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "test.log"))
+ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.logger.level = Logger::WARN
+
+#Setup db
+ActiveRecord::Base.configurations = {'sqlite3' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('sqlite3')
+
+#Define schema
+require File.join(File.dirname(__FILE__), 'schema')
+class Bird < ActiveRecord::Base
+  named_scope :just_big_bird, :conditions=>{:name=>'big bird'}
+  attr_protected :description
+  attr_accessor :tag_list
+  can_console_update
+end
+
+class Test::Unit::TestCase
+  def capture_stdout(&block)
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+    fake.string
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: console_update
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Gabriel Horner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-22 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Updates records from the console via your preferred editor. You can update a record's columns as well as any attribute that has accessor methods. Records are edited via a temporary file and once saved, the records are updated. Records go through a filter before and after editing the file. Yaml is the default filter, but you can define your own filters.
+email: gabriel.horner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- init.rb
+- lib/console_update.rb
+- lib/console_update/filter.rb
+- lib/console_update/filter/yaml.rb
+- lib/console_update/named_scope.rb
+- rails/init.rb
+- test/console_update_test.rb
+- test/filter_test.rb
+- test/named_scope_test.rb
+- test/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://tagaholic.me/console_update/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: []
+
+rubyforge_project: tagaholic
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A rails plugin which allows you to edit your database records via the console and your favorite editor.
+test_files: 
+- test/console_update_test.rb
+- test/filter_test.rb
+- test/named_scope_test.rb
+- test/schema.rb
+- test/test_helper.rb